Find the answer to your Linux question:
Results 1 to 4 of 4
Hi all, We are planing to write a usb device driver on the host. The driver should support read and write operations. We used the usb-skeleton.c we removed the existing ...
Enjoy an ad free experience by logging in. Not a member yet? Register.
  1. #1
    Just Joined!
    Join Date
    Jul 2010
    Posts
    2

    USB Device driver


    Hi all,

    We are planing to write a usb device driver on the
    host. The driver should support read and write operations.
    We used the usb-skeleton.c
    we removed the existing usb-storage.ko and placed
    the .ko of usb-skeleton.c.
    The following were the observations
    1)When we plug in the usb device(mass storage)
    The probe function is getting invoked and the device is
    getting detected and registered.

    2)A device file named skel0 gets created. Its a char file

    The problems that we encounterd are:
    1) The device is getting detected, but the read and write
    to the device are not working. when I try to write some data
    the logs say that the data is getting transferrred but I dont see
    any data written in the device.
    2) Is this the right approach??

    Please help me out.

    Thanks in advance.
    Nilesh Shah

  2. #2
    Linux Guru Rubberman's Avatar
    Join Date
    Apr 2009
    Location
    I can be found either 40 miles west of Chicago, in Chicago, or in a galaxy far, far away.
    Posts
    11,380
    Without your code (complete) one cannot say what is the problem.
    Sometimes, real fast is almost as good as real time.
    Just remember, Semper Gumbi - always be flexible!

  3. #3
    Just Joined!
    Join Date
    Jul 2010
    Posts
    2

    Here is the code.

    this is the driver code usb-skeleton.c which i am using. And below the driver code is the code for testing the driver by name test.c


    /*
    * USB Skeleton driver - 2.0
    *
    * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
    *
    * This program is free software; you can redistribute it and/or
    * modify it under the terms of the GNU General Public License as
    * published by the Free Software Foundation, version 2.
    *
    * This driver is based on the 2.6.3 version of drivers/usb/usb-skeleton.c
    * but has been rewritten to be easy to read and use, as no locks are now
    * needed anymore.
    *
    */

    #include <linux/kernel.h>
    #include <linux/errno.h>
    #include <linux/init.h>
    #include <linux/slab.h>
    #include <linux/module.h>
    #include <linux/kref.h>
    #include <linux/smp_lock.h>
    #include <linux/usb.h>
    #include <asm/uaccess.h>


    /* Define these values to match your devices */
    //#define USB_SKEL_VENDOR_ID 0x058f
    //#define USB_SKEL_PRODUCT_ID 0x6387

    #define USB_SKEL_VENDOR_ID 0x0951
    #define USB_SKEL_PRODUCT_ID 0x1607
    /* table of devices that work with this driver */
    static struct usb_device_id skel_table [] = {
    { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
    { } /* Terminating entry */
    };
    MODULE_DEVICE_TABLE (usb, skel_table);


    /* Get a minor range for your devices from the usb maintainer */
    #define USB_SKEL_MINOR_BASE 192

    /* Structure to hold all of our device specific stuff */
    struct usb_skel {
    struct usb_device * udev; /* the usb device for this device */
    struct usb_interface * interface; /* the interface for this device */
    unsigned char * bulk_in_buffer; /* the buffer to receive data */
    size_t bulk_in_size; /* the size of the receive buffer */
    __u8 bulk_in_endpointAddr; /* the address of the bulk in endpoint */
    __u8 bulk_out_endpointAddr; /* the address of the bulk out endpoint */
    struct kref kref;
    };
    #define to_skel_dev(d) container_of(d, struct usb_skel, kref)

    static struct usb_driver skel_driver;

    static void skel_delete(struct kref *kref)
    {
    struct usb_skel *dev = to_skel_dev(kref);

    usb_put_dev(dev->udev);
    kfree (dev->bulk_in_buffer);
    kfree (dev);
    }

    static int skel_open(struct inode *inode, struct file *file)
    {
    struct usb_skel *dev;
    struct usb_interface *interface;
    int subminor;
    int retval = 0;

    subminor = iminor(inode);
    printk(KERN_ALERT "I am in skel_open");
    interface = usb_find_interface(&skel_driver, subminor);
    if (!interface) {
    err ("%s - error, can't find device for minor %d",
    __FUNCTION__, subminor);
    retval = -ENODEV;
    goto exit;
    }

    dev = usb_get_intfdata(interface);
    if (!dev) {
    retval = -ENODEV;
    goto exit;
    }
    /* increment our usage count for the device */
    kref_get(&dev->kref);

    /* save our object in the file's private structure */
    file->private_data = dev;

    exit:
    return retval;
    }

    static int skel_release(struct inode *inode, struct file *file)
    {
    struct usb_skel *dev;

    dev = (struct usb_skel *)file->private_data;
    if (dev == NULL)
    return -ENODEV;

    /* decrement the count on our device */
    kref_put(&dev->kref, skel_delete);
    return 0;
    }

    static ssize_t skel_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
    {
    struct usb_skel *dev;
    int retval = 0;
    int actual_size;

    dev = (struct usb_skel *)file->private_data;
    printk(KERN_ALERT "In skel_read\n");
    /* do a blocking bulk read to get data from the device */
    retval = usb_bulk_msg(dev->udev,
    usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
    dev->bulk_in_buffer,
    min(dev->bulk_in_size, count),
    &actual_size,
    HZ*10);
    printk(KERN_ALERT "Retval = %d\n", retval);
    /* if the read was successful, copy the data to userspace */
    if (!retval) {
    printk(KERN_ALERT "Read was successful\n");
    if (copy_to_user(buffer, dev->bulk_in_buffer, actual_size))
    retval = -EFAULT;
    else
    retval = count;
    }

    return retval;
    }

    static void skel_write_bulk_callback(struct urb *urb)
    {
    /* sync/async unlink faults aren't errors */
    if (urb->status &&
    !(urb->status == -ENOENT ||
    urb->status == -ECONNRESET ||
    urb->status == -ESHUTDOWN)) {
    dbg("%s - nonzero write bulk status received: %d",
    __FUNCTION__, urb->status);
    }

    /* free up our allocated buffer */
    usb_buffer_free(urb->dev, urb->transfer_buffer_length,
    urb->transfer_buffer, urb->transfer_dma);
    }

    static ssize_t skel_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *ppos)
    {
    struct usb_skel *dev;
    int retval = 0;
    struct urb *urb = NULL;
    char *buf = NULL;

    dev = (struct usb_skel *)file->private_data;

    /* verify that we actually have some data to write */
    if (count == 0)
    goto exit;
    /* create a urb, and a buffer for it, and copy the data to the urb */
    urb = usb_alloc_urb(0, GFP_KERNEL);
    if (!urb) {
    retval = -ENOMEM;
    goto error;
    }

    buf = usb_buffer_alloc(dev->udev, count, GFP_KERNEL, &urb->transfer_dma);
    if (!buf) {
    retval = -ENOMEM;
    goto error;
    }
    if (copy_from_user(buf, user_buffer, count)) {
    retval = -EFAULT;
    goto error;
    }

    /* initialize the urb properly */
    usb_fill_bulk_urb(urb, dev->udev,
    usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
    buf, count, skel_write_bulk_callback, dev);
    urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

    /* send the data out the bulk port */
    retval = usb_submit_urb(urb, GFP_KERNEL);
    if (retval) {
    err("%s - failed submitting write urb, error %d", __FUNCTION__, retval);
    goto error;
    }

    /* release our reference to this urb, the USB core will eventually free it entirely */
    usb_free_urb(urb);

    exit:
    return count;

    error:
    usb_buffer_free(dev->udev, count, buf, urb->transfer_dma);
    usb_free_urb(urb);
    kfree(buf);
    return retval;
    }

    static struct file_operations skel_fops = {
    .owner = THIS_MODULE,
    .read = skel_read,
    .write = skel_write,
    .open = skel_open,
    .release = skel_release,
    };

    /*
    * usb class driver info in order to get a minor number from the usb core,
    * and to have the device registered with devfs and the driver core
    */
    static struct usb_class_driver skel_class = {
    .name = "usb/skel%d",
    .fops = &skel_fops,
    .minor_base = USB_SKEL_MINOR_BASE,
    };

    static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
    {
    struct usb_skel *dev = NULL;
    struct usb_host_interface *iface_desc;
    struct usb_endpoint_descriptor *endpoint;
    size_t buffer_size;
    int i;
    int retval = -ENOMEM;
    printk(KERN_ALERT "I am in probe\n");
    /* allocate memory for our device state and initialize it */
    dev = kmalloc(sizeof(struct usb_skel), GFP_KERNEL);
    if (dev == NULL) {
    err("Out of memory");
    goto error;
    }
    memset(dev, 0x00, sizeof (*dev));
    kref_init(&dev->kref);

    dev->udev = usb_get_dev(interface_to_usbdev(interface));
    dev->interface = interface;

    /* set up the endpoint information */
    /* use only the first bulk-in and bulk-out endpoints */
    iface_desc = interface->cur_altsetting;
    for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
    endpoint = &iface_desc->endpoint[i].desc;

    if (!dev->bulk_in_endpointAddr &&
    (endpoint->bEndpointAddress & USB_DIR_IN) &&
    ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
    == USB_ENDPOINT_XFER_BULK)) {
    /* we found a bulk in endpoint */
    buffer_size = endpoint->wMaxPacketSize;
    dev->bulk_in_size = buffer_size;
    dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
    dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
    if (!dev->bulk_in_buffer) {
    err("Could not allocate bulk_in_buffer");
    goto error;
    }
    }

    if (!dev->bulk_out_endpointAddr &&
    !(endpoint->bEndpointAddress & USB_DIR_IN) &&
    ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
    == USB_ENDPOINT_XFER_BULK)) {
    /* we found a bulk out endpoint */
    dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
    }
    }
    if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
    err("Could not find both bulk-in and bulk-out endpoints");
    goto error;
    }

    /* save our data pointer in this interface device */
    usb_set_intfdata(interface, dev);

    /* we can register the device now, as it is ready */
    retval = usb_register_dev(interface, &skel_class);
    if (retval) {
    /* something prevented us from registering this driver */
    err("Not able to get a minor for this device.");
    usb_set_intfdata(interface, NULL);
    goto error;
    }

    /* let the user know what node this device is now attached to */
    printk(KERN_ALERT "USB Skeleton device now attached to USBSkel-%d", interface->minor);
    return 0;

    error:
    if (dev)
    kref_put(&dev->kref, skel_delete);
    return retval;
    }

    static void skel_disconnect(struct usb_interface *interface)
    {
    struct usb_skel *dev;
    int minor = interface->minor;

    /* prevent skel_open() from racing skel_disconnect() */
    lock_kernel();

    dev = usb_get_intfdata(interface);
    usb_set_intfdata(interface, NULL);

    /* give back our minor */
    usb_deregister_dev(interface, &skel_class);

    unlock_kernel();

    /* decrement our usage count */
    kref_put(&dev->kref, skel_delete);

    printk(KERN_ALERT "USB Skeleton #%d now disconnected", minor);
    }

    static struct usb_driver skel_driver = {
    .name = "skeleton",
    .id_table = skel_table,
    .probe = skel_probe,
    .disconnect = skel_disconnect,
    };

    static int __init usb_skel_init(void)
    {
    int result;

    /* register this driver with the USB subsystem */
    result = usb_register(&skel_driver);
    if (result)
    err("usb_register failed. Error number %d", result);

    return result;
    }

    static void __exit usb_skel_exit(void)
    {
    /* deregister this driver with the USB subsystem */
    usb_deregister(&skel_driver);
    }

    module_init (usb_skel_init);
    module_exit (usb_skel_exit);

    MODULE_LICENSE("GPL");
    ================================================== ==========
    test.c

    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<sys/ioctl.h>
    #include<string.h>
    #include<stdio.h>

    main()
    {
    int fd, len, wlen;
    char string[]="Skeleton kernel module test";
    char receive[128];
    int data, rdata;
    fd=open("/dev/skel0", O_RDWR);
    if(fd==-1)
    {
    printf("Open error....\n");
    exit(1);
    }

    wlen=strlen(string)+1;
    len=write(fd, string, wlen);
    if(len==-1)
    {
    printf("\nWrite error...\n");
    exit(1);
    }
    len=read(fd, receive, 12;
    if(len==-1)
    {
    printf("\nRead error....\n");
    exit(1);
    }
    printf("String '%s' read from /dev/skel0\n", receive);
    close(fd);
    }


    Best regards,
    Nilesh Shah

  4. #4
    Linux Guru Rubberman's Avatar
    Join Date
    Apr 2009
    Location
    I can be found either 40 miles west of Chicago, in Chicago, or in a galaxy far, far away.
    Posts
    11,380
    Quote Originally Posted by nileshshah89 View Post
    this is the driver code usb-skeleton.c which i am using. And below the driver code is the code for testing the driver by name test.c
    I am encapsulating your code inside code braces so that the indents and such are properly rendered.

    Code:
    /*
     * USB Skeleton driver - 2.0
     *
     * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
     *
     *	This program is free software; you can redistribute it and/or
     *	modify it under the terms of the GNU General Public License as
     *	published by the Free Software Foundation, version 2.
     *
     * This driver is based on the 2.6.3 version of drivers/usb/usb-skeleton.c 
     * but has been rewritten to be easy to read and use, as no locks are now
     * needed anymore.
     *
     */
    
    #include <linux/kernel.h>
    #include <linux/errno.h>
    #include <linux/init.h>
    #include <linux/slab.h>
    #include <linux/module.h>
    #include <linux/kref.h>
    #include <linux/smp_lock.h>
    #include <linux/usb.h>
    #include <asm/uaccess.h>
    
    
    /* Define these values to match your devices */
    //#define USB_SKEL_VENDOR_ID	0x058f
    //#define USB_SKEL_PRODUCT_ID	0x6387
    
    #define USB_SKEL_VENDOR_ID	0x0951
    #define USB_SKEL_PRODUCT_ID	0x1607
    /* table of devices that work with this driver */
    static struct usb_device_id skel_table [] = {
    	{ USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
    	{ }					/* Terminating entry */
    };
    MODULE_DEVICE_TABLE (usb, skel_table);
    
    
    /* Get a minor range for your devices from the usb maintainer */
    #define USB_SKEL_MINOR_BASE	192
    
    /* Structure to hold all of our device specific stuff */
    struct usb_skel {
    	struct usb_device *	udev;			/* the usb device for this device */
    	struct usb_interface *	interface;		/* the interface for this device */
    	unsigned char *		bulk_in_buffer;		/* the buffer to receive data */
    	size_t			bulk_in_size;		/* the size of the receive buffer */
    	__u8			bulk_in_endpointAddr;	/* the address of the bulk in endpoint */
    	__u8			bulk_out_endpointAddr;	/* the address of the bulk out endpoint */
    	struct kref		kref;
    };
    #define to_skel_dev(d) container_of(d, struct usb_skel, kref)
    
    static struct usb_driver skel_driver;
    
    static void skel_delete(struct kref *kref)
    {	
    	struct usb_skel *dev = to_skel_dev(kref);
    
    	usb_put_dev(dev->udev);
    	kfree (dev->bulk_in_buffer);
    	kfree (dev);
    }
    
    static int skel_open(struct inode *inode, struct file *file)
    {
    	struct usb_skel *dev;
    	struct usb_interface *interface;
    	int subminor;
    	int retval = 0;
    
    	subminor = iminor(inode);
    	printk(KERN_ALERT "I am in skel_open");
    	interface = usb_find_interface(&skel_driver, subminor);
    	if (!interface) {
    		err ("%s - error, can't find device for minor %d",
    		     __FUNCTION__, subminor);
    		retval = -ENODEV;
    		goto exit;
    	}
    
    	dev = usb_get_intfdata(interface);
    	if (!dev) {
    		retval = -ENODEV;
    		goto exit;
    	}
    	/* increment our usage count for the device */
    	kref_get(&dev->kref);
    
    	/* save our object in the file's private structure */
    	file->private_data = dev;
    
    exit:
    	return retval;
    }
    
    static int skel_release(struct inode *inode, struct file *file)
    {
    	struct usb_skel *dev;
    
    	dev = (struct usb_skel *)file->private_data;
    	if (dev == NULL)
    		return -ENODEV;
    
    	/* decrement the count on our device */
    	kref_put(&dev->kref, skel_delete);
    	return 0;
    }
    
    static ssize_t skel_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
    {
    	struct usb_skel *dev;
    	int retval = 0;
            int actual_size;
    
    	dev = (struct usb_skel *)file->private_data;
    	printk(KERN_ALERT "In skel_read\n");	
    	/* do a blocking bulk read to get data from the device */
    	retval = usb_bulk_msg(dev->udev,
    			      usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
    			      dev->bulk_in_buffer,
    			      min(dev->bulk_in_size, count),
    			      &actual_size,
                                  HZ*10);
    	printk(KERN_ALERT "Retval = %d\n", retval);
    	/* if the read was successful, copy the data to userspace */
    	if (!retval) {
    		printk(KERN_ALERT "Read was successful\n");
              if (copy_to_user(buffer, dev->bulk_in_buffer, actual_size))
    			retval = -EFAULT;
    		else
    			retval = count;
    	}
    
    	return retval;
    }
    
    static void skel_write_bulk_callback(struct urb *urb)
    {
    	/* sync/async unlink faults aren't errors */
    	if (urb->status && 
    	    !(urb->status == -ENOENT || 
    	      urb->status == -ECONNRESET ||
    	      urb->status == -ESHUTDOWN)) {
    		dbg("%s - nonzero write bulk status received: %d",
    		    __FUNCTION__, urb->status);
    	}
    
    	/* free up our allocated buffer */
    	usb_buffer_free(urb->dev, urb->transfer_buffer_length, 
    			urb->transfer_buffer, urb->transfer_dma);
    }
    
    static ssize_t skel_write(struct file *file, const char __user *user_buffer, size_t count, loff_t *ppos)
    {
    	struct usb_skel *dev;
    	int retval = 0;
    	struct urb *urb = NULL;
    	char *buf = NULL;
    
    	dev = (struct usb_skel *)file->private_data;
    
    	/* verify that we actually have some data to write */
    	if (count == 0)
    		goto exit;
    	/* create a urb, and a buffer for it, and copy the data to the urb */
    	urb = usb_alloc_urb(0, GFP_KERNEL);
    	if (!urb) {
    		retval = -ENOMEM;
    		goto error;
    	}
    
    	buf = usb_buffer_alloc(dev->udev, count, GFP_KERNEL, &urb->transfer_dma);
    	if (!buf) {
    		retval = -ENOMEM;
    		goto error;
    	}
    	if (copy_from_user(buf, user_buffer, count)) {
    		retval = -EFAULT;
    		goto error;
    	}
    
    	/* initialize the urb properly */
    	usb_fill_bulk_urb(urb, dev->udev,
    			  usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
    			  buf, count, skel_write_bulk_callback, dev);
    	urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
    
    	/* send the data out the bulk port */
    	retval = usb_submit_urb(urb, GFP_KERNEL);
    	if (retval) {
    		err("%s - failed submitting write urb, error %d", __FUNCTION__, retval);
    		goto error;
    	}
    
    	/* release our reference to this urb, the USB core will eventually free it entirely */
    	usb_free_urb(urb);
    
    exit:
    	return count;
    
    error:
    	usb_buffer_free(dev->udev, count, buf, urb->transfer_dma);
    	usb_free_urb(urb);
    	kfree(buf);
    	return retval;
    }
    
    static struct file_operations skel_fops = {
    	.owner =	THIS_MODULE,
    	.read =		skel_read,
    	.write =	skel_write,
    	.open =		skel_open,
    	.release =	skel_release,
    };
    
    /* 
     * usb class driver info in order to get a minor number from the usb core,
     * and to have the device registered with devfs and the driver core
     */
    static struct usb_class_driver skel_class = {
    	.name = "usb/skel%d",
    	.fops = &skel_fops,
    	.minor_base = USB_SKEL_MINOR_BASE,
    };
    
    static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id)
    {
    	struct usb_skel *dev = NULL;
    	struct usb_host_interface *iface_desc;
    	struct usb_endpoint_descriptor *endpoint;
    	size_t buffer_size;
    	int i;
    	int retval = -ENOMEM;
    	printk(KERN_ALERT "I am in probe\n");
    	/* allocate memory for our device state and initialize it */
    	dev = kmalloc(sizeof(struct usb_skel), GFP_KERNEL);
    	if (dev == NULL) {
    		err("Out of memory");
    		goto error;
    	}
    	memset(dev, 0x00, sizeof (*dev));
    	kref_init(&dev->kref);
    
    	dev->udev = usb_get_dev(interface_to_usbdev(interface));
    	dev->interface = interface;
    
    	/* set up the endpoint information */
    	/* use only the first bulk-in and bulk-out endpoints */
    	iface_desc = interface->cur_altsetting;
    	for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
    		endpoint = &iface_desc->endpoint[i].desc;
    
    		if (!dev->bulk_in_endpointAddr &&
    		    (endpoint->bEndpointAddress & USB_DIR_IN) &&
    		    ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
    					== USB_ENDPOINT_XFER_BULK)) {
    			/* we found a bulk in endpoint */
    			buffer_size = endpoint->wMaxPacketSize;
    			dev->bulk_in_size = buffer_size;
    			dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
    			dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
    			if (!dev->bulk_in_buffer) {
    				err("Could not allocate bulk_in_buffer");
    				goto error;
    			}
    		}
    
    		if (!dev->bulk_out_endpointAddr &&
    		    !(endpoint->bEndpointAddress & USB_DIR_IN) &&
    		    ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
    					== USB_ENDPOINT_XFER_BULK)) {
    			/* we found a bulk out endpoint */
    			dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
    		}
    	}
    	if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
    		err("Could not find both bulk-in and bulk-out endpoints");
    		goto error;
    	}
    
    	/* save our data pointer in this interface device */
    	usb_set_intfdata(interface, dev);
    
    	/* we can register the device now, as it is ready */
    	retval = usb_register_dev(interface, &skel_class);
    	if (retval) {
    		/* something prevented us from registering this driver */
    		err("Not able to get a minor for this device.");
    		usb_set_intfdata(interface, NULL);
    		goto error;
    	}
    
    	/* let the user know what node this device is now attached to */
    	printk(KERN_ALERT "USB Skeleton device now attached to USBSkel-%d", interface->minor);
    	return 0;
    
    error:
    	if (dev)
    		kref_put(&dev->kref, skel_delete);
    	return retval;
    }
    
    static void skel_disconnect(struct usb_interface *interface)
    {
    	struct usb_skel *dev;
    	int minor = interface->minor;
    
    	/* prevent skel_open() from racing skel_disconnect() */
    	lock_kernel();
    
    	dev = usb_get_intfdata(interface);
    	usb_set_intfdata(interface, NULL);
    
    	/* give back our minor */
    	usb_deregister_dev(interface, &skel_class);
    
    	unlock_kernel();
    
    	/* decrement our usage count */
    	kref_put(&dev->kref, skel_delete);
    
    	printk(KERN_ALERT "USB Skeleton #%d now disconnected", minor);
    }
    
    static struct usb_driver skel_driver = {
    	.name = "skeleton",
    	.id_table = skel_table,
    	.probe = skel_probe,
    	.disconnect = skel_disconnect,
    };
    
    static int __init usb_skel_init(void)
    {
    	int result;
    
    	/* register this driver with the USB subsystem */
    	result = usb_register(&skel_driver);
    	if (result)
    		err("usb_register failed. Error number %d", result);
    
    	return result;
    }
    
    static void __exit usb_skel_exit(void)
    {
    	/* deregister this driver with the USB subsystem */
    	usb_deregister(&skel_driver);
    }
    
    module_init (usb_skel_init);
    module_exit (usb_skel_exit);
    
    MODULE_LICENSE("GPL");
    ================================================== ==========
    test.c
    Code:
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<sys/ioctl.h>
    #include<string.h>
    #include<stdio.h>
    
    main()
    {
    	int fd, len, wlen;
    	char string[]="Skeleton kernel module test";
    	char receive[128];
    	int data, rdata;
    	fd=open("/dev/skel0", O_RDWR);
    	if(fd==-1)
    	{
    		printf("Open error....\n");
    		exit(1);
    	}
    	
    	wlen=strlen(string)+1;
    	len=write(fd, string, wlen);
    	if(len==-1)
    	{
    		printf("\nWrite error...\n");
    		exit(1);
    	}
    	len=read(fd, receive, 128);
    	if(len==-1)
    	{
    		printf("\nRead error....\n");
    		exit(1);
    	}
    	printf("String '%s' read from /dev/skel0\n", receive);
    	close(fd);
    }
    Sometimes, real fast is almost as good as real time.
    Just remember, Semper Gumbi - always be flexible!

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •