嵌入式linux驱动 开发教程-源代码.7z

#include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/cdev.h> #include <linux/fs.h> #include <linux/usb.h> #include <linux/slab.h> #include <linux/sched.h> #include <linux/types.h> #include <linux/errno.h> #include <linux/uaccess.h> #include "pdiusbd12.h" #define PDIUSBD12_MAJOR 256 #define PDIUSBD12_MINOR 10 #define PDIUSBD12_DEV_NAME "pdiusbd12" struct pdiusbd12_dev { int pipe_ep1_out; int pipe_ep1_in; int pipe_ep2_out; int pipe_ep2_in; int maxp_ep1_out; int maxp_ep1_in; int maxp_ep2_out; int maxp_ep2_in; struct urb *ep2inurb; int errors; unsigned int ep2inlen; unsigned char ep1inbuf[16]; unsigned char ep1outbuf[16]; unsigned char ep2inbuf[64]; unsigned char ep2outbuf[64]; struct usb_device *usbdev; wait_queue_head_t wq; struct cdev cdev; dev_t dev; }; static unsigned int minor = PDIUSBD12_MINOR; static int pdiusbd12_open(struct inode *inode, struct file *filp) { struct pdiusbd12_dev *pdiusbd12; pdiusbd12 = container_of(inode->i_cdev, struct pdiusbd12_dev, cdev); filp->private_data = pdiusbd12; return 0; } static int pdiusbd12_release(struct inode *inode, struct file *filp) { struct pdiusbd12_dev *pdiusbd12; pdiusbd12 = container_of(inode->i_cdev, struct pdiusbd12_dev, cdev); usb_kill_urb(pdiusbd12->ep2inurb); return 0; } void usb_read_complete(struct urb * urb) { struct pdiusbd12_dev *pdiusbd12 = urb->context; switch (urb->status) { case 0: pdiusbd12->ep2inlen = urb->actual_length; break; case -ECONNRESET: case -ENOENT: case -ESHUTDOWN: default: pdiusbd12->ep2inlen = 0; break; } pdiusbd12->errors = urb->status; wake_up_interruptible(&pdiusbd12->wq); } static ssize_t pdiusbd12_read(struct file *filp, char __user *buf, size_t count, loff_t *f_ops) { int ret; struct usb_device *usbdev; struct pdiusbd12_dev *pdiusbd12 = filp->private_data; count = count > sizeof(pdiusbd12->ep2inbuf) ? sizeof(pdiusbd12->ep1inbuf) : count; ret = count; usbdev = pdiusbd12->usbdev; usb_fill_bulk_urb(pdiusbd12->ep2inurb, usbdev, pdiusbd12->pipe_ep2_in, pdiusbd12->ep2inbuf, ret, usb_read_complete, pdiusbd12); if (usb_submit_urb(pdiusbd12->ep2inurb, GFP_KERNEL)) return -EIO; interruptible_sleep_on(&pdiusbd12->wq); if (pdiusbd12->errors) return pdiusbd12->errors; else { if (copy_to_user(buf, pdiusbd12->ep2inbuf, pdiusbd12->ep2inlen)) return -EFAULT; else return pdiusbd12->ep2inlen; } } static ssize_t pdiusbd12_write(struct file *filp, const char __user *buf, size_t count, loff_t *f_ops) { int len; ssize_t ret = 0; struct pdiusbd12_dev *pdiusbd12 = filp->private_data; count = count > sizeof(pdiusbd12->ep2outbuf) ? sizeof(pdiusbd12->ep2outbuf) : count; if (copy_from_user(pdiusbd12->ep2outbuf, buf, count)) return -EFAULT; ret = usb_bulk_msg(pdiusbd12->usbdev, pdiusbd12->pipe_ep2_out, pdiusbd12->ep2outbuf, count, &len, 10 * HZ); if (ret) return ret; else return len; } long pdiusbd12_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { int ret; int len; struct pdiusbd12_dev *pdiusbd12 = filp->private_data; if (_IOC_TYPE(cmd) != PDIUSBD12_MAGIC) return -ENOTTY; switch (cmd) { case PDIUSBD12_GET_KEY: ret = usb_interrupt_msg(pdiusbd12->usbdev, pdiusbd12->pipe_ep1_in, pdiusbd12->ep1inbuf, 8, &len, 10 * HZ); if (ret) return ret; else { if (copy_to_user((unsigned char __user *)arg, pdiusbd12->ep1inbuf, len)) return -EFAULT; else return 0; } break; case PDIUSBD12_SET_LED: if (copy_from_user(pdiusbd12->ep1outbuf, (unsigned char __user *)arg, 8)) return -EFAULT; ret = usb_interrupt_msg(pdiusbd12->usbdev, pdiusbd12->pipe_ep1_out, pdiusbd12->ep1outbuf, 8, &len, 10 * HZ); if (ret) return ret; else return 0; default: return -ENOTTY; } return 0; } static struct file_operations pdiusbd12_ops = { .owner = THIS_MODULE, .open = pdiusbd12_open, .release = pdiusbd12_release, .read = pdiusbd12_read, .write = pdiusbd12_write, .unlocked_ioctl = pdiusbd12_ioctl, }; int pdiusbd12_probe(struct usb_interface *intf, const struct usb_device_id *id) { static struct pdiusbd12_dev *pdiusbd12; struct usb_device *usbdev; struct usb_host_interface *interface; struct usb_endpoint_descriptor *endpoint; int ret = 0; pdiusbd12 = kmalloc(sizeof(struct pdiusbd12_dev), GFP_KERNEL); if (!pdiusbd12) return -ENOMEM; usbdev = interface_to_usbdev(intf); interface = intf->cur_altsetting; if (interface->desc.bNumEndpoints != 4) { ret = -ENODEV; goto out_no_dev; } /* EP1 Interrupt IN */ endpoint = &interface->endpoint[0].desc; if (!(endpoint->bEndpointAddress & 0x80)) { /* IN */ ret = -ENODEV; goto out_no_dev; } if ((endpoint->bmAttributes & 0x7F) != 3) { /* Interrupt */ ret = -ENODEV; goto out_no_dev; } pdiusbd12->pipe_ep1_in = usb_rcvintpipe(usbdev, endpoint->bEndpointAddress); pdiusbd12->maxp_ep1_in = usb_maxpacket(usbdev, pdiusbd12->pipe_ep1_in, usb_pipeout(pdiusbd12->pipe_ep1_in)); /* EP1 Interrupt Out */ endpoint = &interface->endpoint[1].desc; if (endpoint->bEndpointAddress & 0x80) { /* OUT */ ret = -ENODEV; goto out_no_dev; } if ((endpoint->bmAttributes & 0x7F) != 3) { /* Interrupt */ ret = -ENODEV; goto out_no_dev; } pdiusbd12->pipe_ep1_out = usb_sndintpipe(usbdev, endpoint->bEndpointAddress); pdiusbd12->maxp_ep1_out = usb_maxpacket(usbdev, pdiusbd12->pipe_ep1_out, usb_pipeout(pdiusbd12->pipe_ep1_out)); /* EP2 Bulk IN */ endpoint = &interface->endpoint[2].desc; if (!(endpoint->bEndpointAddress & 0x80)) { /* IN */ ret = -ENODEV; goto out_no_dev; } if ((endpoint->bmAttributes & 0x7F) != 2) { /* Bulk */ ret = -ENODEV; goto out_no_dev; } pdiusbd12->pipe_ep2_in = usb_rcvintpipe(usbdev, endpoint->bEndpointAddress); pdiusbd12->maxp_ep2_in = usb_maxpacket(usbdev, pdiusbd12->pipe_ep2_in, usb_pipeout(pdiusbd12->pipe_ep2_in)); endpoint = &interface->endpoint[3].desc; if (endpoint->bEndpointAddress & 0x80) { /* OUT */ ret = -ENODEV; goto out_no_dev; } if ((endpoint->bmAttributes & 0x7F) != 2) { /* Bulk */ ret = -ENODEV; goto out_no_dev; } pdiusbd12->pipe_ep2_out = usb_sndintpipe(usbdev, endpoint->bEndpointAddress); pdiusbd12->maxp_ep2_out = usb_maxpacket(usbdev, pdiusbd12->pipe_ep2_out, usb_pipeout(pdiusbd12->pipe_ep2_out)); pdiusbd12->ep2inurb = usb_alloc_urb(0, GFP_KERNEL); pdiusbd12->usbdev = usbdev; usb_set_intfdata(intf, pdiusbd12); pdiusbd12->dev = MKDEV(PDIUSBD12_MAJOR, minor++); ret = register_chrdev_region (pdiusbd12->dev, 1, PDIUSBD12_DEV_NAME); if (ret < 0) goto out_reg_region; cdev_init(&pdiusbd12->cdev, &pdiusbd12_ops); pdiusbd12->cdev.owner = THIS_MODULE; ret = cdev_add(&pdiusbd12->cdev, pdiusbd12->dev, 1); if (ret) goto out_cdev_add; init_waitqueue_head(&pdiusbd12->wq); return 0; out_cdev_add: unregister_chrdev_region(pdiusbd12->dev, 1); out_reg_region: usb_free_urb(pdiusbd12->ep2inurb); out_no_dev: kfree(pdiusbd12); return ret; } void pdiusbd12_disconnect(struct usb_interface *intf) { struct pdiusbd12_dev *pdiusbd12 = usb_get_intfdata(intf); cdev_del(&pdiusbd12->cdev); unregister_chrdev_region(pdiusbd12->dev, 1); usb_kill_urb(pdiusbd12->ep2inurb); usb_free_urb(pdiusbd12->ep2inurb); kfree(pdiusbd12); } static struct usb_device_id id_table [] = { { USB_DEVICE(0x8888, 0x000b) }, { } }; MODULE_DEVICE_TABLE(usb, id_table); static struct usb_driver pdiusbd12_driver = { .name = "pdiusbd12", .id_table = id_table, .probe = pdiusbd12_probe, .disconnect = pdiusbd12_disconnect, }; module_usb_driver(pdiusbd12_driver); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Kevin Jiang <jiangxg@farsight.com.cn>"); MODULE_DESCRIPTION("PDIUSBD12 driver");