URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [usb/] [usblcd.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*****************************************************************************
 *                          USBLCD Kernel Driver                             *
 *        See http://www.usblcd.de for Hardware and Documentation.           *
 *                            Version 1.03                                   *
 *             (C) 2002 Adams IT Services <info@usblcd.de>                   *
 *                                                                           *
 *     This file is licensed under the GPL. See COPYING in the package.      *
 * Based on rio500.c by Cesar Miquel (miquel@df.uba.ar) which is based on    *
 * hp_scanner.c by David E. Nelson (dnelson@jump.net)                        *
 *                                                                           *
 * 23.7.02 RA changed minor device number to the official assigned one       *
 * 18.9.02 RA Vendor ID change, longer timeouts                              *
 *****************************************************************************/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <asm/uaccess.h>
#include <linux/usb.h>
 
#define DRIVER_VERSION "USBLCD Driver Version 1.03"
 
#define USBLCD_MINOR            144
 
#define IOCTL_GET_HARD_VERSION  1
#define IOCTL_GET_DRV_VERSION   2
 
/* stall/wait timeout for USBLCD */
#define NAK_TIMEOUT     (10*HZ)
 
#define IBUF_SIZE       0x1000
#define OBUF_SIZE       0x10000
 
struct lcd_usb_data {
        struct usb_device *lcd_dev;     /* init: probe_lcd */
        unsigned int ifnum;             /* Interface number of the USB device */
        int isopen;                     /* nz if open */
        int present;                    /* Device is present on the bus */
        char *obuf, *ibuf;              /* transfer buffers */
        char bulk_in_ep, bulk_out_ep;   /* Endpoint assignments */
        wait_queue_head_t wait_q;       /* for timeouts */
};
 
static struct lcd_usb_data lcd_instance;
 
static int open_lcd(struct inode *inode, struct file *file)
{
        struct lcd_usb_data *lcd = &lcd_instance;
 
        if (lcd->isopen || !lcd->present) {
                return -EBUSY;
        }
        lcd->isopen = 1;
 
        init_waitqueue_head(&lcd->wait_q);
 
        info("USBLCD opened.");
 
        return 0;
}
 
static int close_lcd(struct inode *inode, struct file *file)
{
        struct lcd_usb_data *lcd = &lcd_instance;
 
        lcd->isopen = 0;
 
        info("USBLCD closed.");
        return 0;
}
 
static int
ioctl_lcd(struct inode *inode, struct file *file, unsigned int cmd,
          unsigned long arg)
{
        struct lcd_usb_data *lcd = &lcd_instance;
        int i;
        char buf[30];
 
        /* Sanity check to make sure lcd is connected, powered, etc */
        if (lcd == NULL ||
            lcd->present == 0 ||
            lcd->lcd_dev == NULL)
                return -1;
 
        switch (cmd) {
        case IOCTL_GET_HARD_VERSION:
                i = (lcd->lcd_dev)->descriptor.bcdDevice;
                sprintf(buf,"%1d%1d.%1d%1d",(i & 0xF000)>>12,(i & 0xF00)>>8,
                        (i & 0xF0)>>4,(i & 0xF));
                if (copy_to_user((void *)arg,buf,strlen(buf))!=0)
                        return -EFAULT;
                break;
        case IOCTL_GET_DRV_VERSION:
                sprintf(buf,DRIVER_VERSION);
                if (copy_to_user((void *)arg,buf,strlen(buf))!=0)
                        return -EFAULT;
                break;
        default:
                return -ENOIOCTLCMD;
                break;
        }
 
        return 0;
}
 
static ssize_t
write_lcd(struct file *file, const char *buffer,
          size_t count, loff_t * ppos)
{
        struct lcd_usb_data *lcd = &lcd_instance;
 
        unsigned long copy_size;
        unsigned long bytes_written = 0;
        unsigned int partial;
 
        int result = 0;
        int maxretry;
 
        /* Sanity check to make sure lcd is connected, powered, etc */
        if (lcd == NULL ||
            lcd->present == 0 ||
            lcd->lcd_dev == NULL)
                return -1;
 
        do {
                unsigned long thistime;
                char *obuf = lcd->obuf;
 
                thistime = copy_size =
                    (count >= OBUF_SIZE) ? OBUF_SIZE : count;
                if (copy_from_user(lcd->obuf, buffer, copy_size))
                        return -EFAULT;
                maxretry = 5;
                while (thistime) {
                        if (!lcd->lcd_dev)
                                return -ENODEV;
                        if (signal_pending(current)) {
                                return bytes_written ? bytes_written : -EINTR;
                        }
 
                        result = usb_bulk_msg(lcd->lcd_dev,
                                         usb_sndbulkpipe(lcd->lcd_dev, 1),
                                         obuf, thistime, &partial, 10 * HZ);
 
                        dbg("write stats: result:%d thistime:%lu partial:%u",
                             result, thistime, partial);
 
                        if (result == USB_ST_TIMEOUT) { /* NAK - so hold for a while */
                                if (!maxretry--) {
                                        return -ETIME;
                                }
                                interruptible_sleep_on_timeout(&lcd-> wait_q, NAK_TIMEOUT);
                                continue;
                        } else if (!result & partial) {
                                obuf += partial;
                                thistime -= partial;
                        } else
                                break;
                };
                if (result) {
                        err("Write Whoops - %x", result);
                        return -EIO;
                }
                bytes_written += copy_size;
                count -= copy_size;
                buffer += copy_size;
        } while (count > 0);
 
        return bytes_written ? bytes_written : -EIO;
}
 
static ssize_t
read_lcd(struct file *file, char *buffer, size_t count, loff_t * ppos)
{
        struct lcd_usb_data *lcd = &lcd_instance;
        ssize_t read_count;
        unsigned int partial;
        int this_read;
        int result;
        int maxretry = 10;
        char *ibuf = lcd->ibuf;
 
        /* Sanity check to make sure lcd is connected, powered, etc */
        if (lcd == NULL ||
            lcd->present == 0 ||
            lcd->lcd_dev == NULL)
                return -1;
 
        read_count = 0;
 
        while (count > 0) {
                if (signal_pending(current)) {
                        return read_count ? read_count : -EINTR;
                }
                if (!lcd->lcd_dev)
                        return -ENODEV;
                this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;
 
                result = usb_bulk_msg(lcd->lcd_dev,
                                      usb_rcvbulkpipe(lcd->lcd_dev, 0),
                                      ibuf, this_read, &partial,
                                      (int) (HZ * 8));
 
                dbg(KERN_DEBUG "read stats: result:%d this_read:%u partial:%u",
                       result, this_read, partial);
 
                if (partial) {
                        count = this_read = partial;
                } else if (result == USB_ST_TIMEOUT || result == 15) {  /* FIXME: 15 ??? */
                        if (!maxretry--) {
                                err("read_lcd: maxretry timeout");
                                return -ETIME;
                        }
                        interruptible_sleep_on_timeout(&lcd->wait_q,
                                                       NAK_TIMEOUT);
                        continue;
                } else if (result != USB_ST_DATAUNDERRUN) {
                        err("Read Whoops - result:%u partial:%u this_read:%u",
                             result, partial, this_read);
                        return -EIO;
                } else {
                        return (0);
                }
 
                if (this_read) {
                        if (copy_to_user(buffer, ibuf, this_read))
                                return -EFAULT;
                        count -= this_read;
                        read_count += this_read;
                        buffer += this_read;
                }
        }
        return read_count;
}
 
static void *probe_lcd(struct usb_device *dev, unsigned int ifnum)
{
        struct lcd_usb_data *lcd = &lcd_instance;
        int i;
 
        if (dev->descriptor.idProduct != 0x0001  ) {
                warn(KERN_INFO "USBLCD model not supported.");
                return NULL;
        }
 
        if (lcd->present == 1) {
                warn(KERN_INFO "Multiple USBLCDs are not supported!");
                return NULL;
        }
 
        i = dev->descriptor.bcdDevice;
 
        info("USBLCD Version %1d%1d.%1d%1d found at address %d",
                (i & 0xF000)>>12,(i & 0xF00)>>8,(i & 0xF0)>>4,(i & 0xF),
                dev->devnum);
 
        lcd->present = 1;
        lcd->lcd_dev = dev;
 
        if (!(lcd->obuf = (char *) kmalloc(OBUF_SIZE, GFP_KERNEL))) {
                err("probe_lcd: Not enough memory for the output buffer");
                return NULL;
        }
        dbg("probe_lcd: obuf address:%p", lcd->obuf);
 
        if (!(lcd->ibuf = (char *) kmalloc(IBUF_SIZE, GFP_KERNEL))) {
                err("probe_lcd: Not enough memory for the input buffer");
                kfree(lcd->obuf);
                return NULL;
        }
        dbg("probe_lcd: ibuf address:%p", lcd->ibuf);
 
        return lcd;
}
 
static void disconnect_lcd(struct usb_device *dev, void *ptr)
{
        struct lcd_usb_data *lcd = (struct lcd_usb_data *) ptr;
 
        if (lcd->isopen) {
                lcd->isopen = 0;
                /* better let it finish - the release will do whats needed */
                lcd->lcd_dev = NULL;
                return;
        }
        kfree(lcd->ibuf);
        kfree(lcd->obuf);
 
        info("USBLCD disconnected.");
 
        lcd->present = 0;
}
 
static struct usb_device_id id_table [] = {
        { .idVendor = 0x10D2, .match_flags = USB_DEVICE_ID_MATCH_VENDOR, },
        {},
};
 
MODULE_DEVICE_TABLE (usb, id_table);
 
static struct
file_operations usb_lcd_fops = {
        .owner =        THIS_MODULE,
        .read =         read_lcd,
        .write =        write_lcd,
        .ioctl =        ioctl_lcd,
        .open =         open_lcd,
        .release =      close_lcd,
};
 
static struct
usb_driver lcd_driver = {
        .name =         "usblcd",
        .probe =        (void *)probe_lcd,
        .disconnect =   disconnect_lcd,
        .id_table =     id_table,
        .fops =         &usb_lcd_fops,
        .minor =        USBLCD_MINOR,
};
 
int usb_lcd_init(void)
{
        if (usb_register(&lcd_driver) < 0)
                return -1;
 
        info("%s (C) Adams IT Services http://www.usblcd.de", DRIVER_VERSION);
        info("USBLCD support registered.");
        return 0;
}
 
 
void usb_lcd_cleanup(void)
{
        struct lcd_usb_data *lcd = &lcd_instance;
 
        lcd->present = 0;
        usb_deregister(&lcd_driver);
}
 
module_init(usb_lcd_init);
module_exit(usb_lcd_cleanup);
 
MODULE_AUTHOR("Adams IT Services <info@usblcd.de>");
MODULE_DESCRIPTION(DRIVER_VERSION);
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [usb/] [usblcd.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*****************************************************************************`
2			`* USBLCD Kernel Driver *`
3			`* See http://www.usblcd.de for Hardware and Documentation. *`
4			`* Version 1.03 *`
5			`* (C) 2002 Adams IT Services <info@usblcd.de> *`
6			`* *`
7			`* This file is licensed under the GPL. See COPYING in the package. *`
8			`* Based on rio500.c by Cesar Miquel (miquel@df.uba.ar) which is based on *`
9			`* hp_scanner.c by David E. Nelson (dnelson@jump.net) *`
10			`* *`
11			`* 23.7.02 RA changed minor device number to the official assigned one *`
12			`* 18.9.02 RA Vendor ID change, longer timeouts *`
13			`*****************************************************************************/`
14			`#include <linux/module.h>`
15			`#include <linux/kernel.h>`
16			`#include <linux/init.h>`
17			`#include <linux/slab.h>`
18			`#include <linux/errno.h>`
19			`#include <asm/uaccess.h>`
20			`#include <linux/usb.h>`
21
22			`#define DRIVER_VERSION "USBLCD Driver Version 1.03"`
23
24			`#define USBLCD_MINOR 144`
25
26			`#define IOCTL_GET_HARD_VERSION 1`
27			`#define IOCTL_GET_DRV_VERSION 2`
28
29			`/* stall/wait timeout for USBLCD */`
30			`#define NAK_TIMEOUT (10*HZ)`
31
32			`#define IBUF_SIZE 0x1000`
33			`#define OBUF_SIZE 0x10000`
34
35			`struct lcd_usb_data {`
36			`struct usb_device lcd_dev; / init: probe_lcd */`
37			`unsigned int ifnum; /* Interface number of the USB device */`
38			`int isopen; /* nz if open */`
39			`int present; /* Device is present on the bus */`
40			`char obuf, ibuf; /* transfer buffers */`
41			`char bulk_in_ep, bulk_out_ep; /* Endpoint assignments */`
42			`wait_queue_head_t wait_q; /* for timeouts */`
43			`};`
44
45			`static struct lcd_usb_data lcd_instance;`
46
47			`static int open_lcd(struct inode inode, struct file file)`
48			`{`
49			`struct lcd_usb_data *lcd = &lcd_instance;`
50
51			`if (lcd->isopen \|\| !lcd->present) {`
52			`return -EBUSY;`
53			`}`
54			`lcd->isopen = 1;`
55
56			`init_waitqueue_head(&lcd->wait_q);`
57
58			`info("USBLCD opened.");`
59
60			`return 0;`
61			`}`
62
63			`static int close_lcd(struct inode inode, struct file file)`
64			`{`
65			`struct lcd_usb_data *lcd = &lcd_instance;`
66
67			`lcd->isopen = 0;`
68
69			`info("USBLCD closed.");`
70			`return 0;`
71			`}`
72
73			`static int`
74			`ioctl_lcd(struct inode inode, struct file file, unsigned int cmd,`
75			`unsigned long arg)`
76			`{`
77			`struct lcd_usb_data *lcd = &lcd_instance;`
78			`int i;`
79			`char buf[30];`
80
81			`/* Sanity check to make sure lcd is connected, powered, etc */`
82			`if (lcd == NULL \|\|`
83			`lcd->present == 0 \|\|`
84			`lcd->lcd_dev == NULL)`
85			`return -1;`
86
87			`switch (cmd) {`
88			`case IOCTL_GET_HARD_VERSION:`
89			`i = (lcd->lcd_dev)->descriptor.bcdDevice;`
90			`sprintf(buf,"%1d%1d.%1d%1d",(i & 0xF000)>>12,(i & 0xF00)>>8,`
91			`(i & 0xF0)>>4,(i & 0xF));`
92			`if (copy_to_user((void *)arg,buf,strlen(buf))!=0)`
93			`return -EFAULT;`
94			`break;`
95			`case IOCTL_GET_DRV_VERSION:`
96			`sprintf(buf,DRIVER_VERSION);`
97			`if (copy_to_user((void *)arg,buf,strlen(buf))!=0)`
98			`return -EFAULT;`
99			`break;`
100			`default:`
101			`return -ENOIOCTLCMD;`
102			`break;`
103			`}`
104
105			`return 0;`
106			`}`
107
108			`static ssize_t`
109			`write_lcd(struct file file, const char buffer,`
110			`size_t count, loff_t * ppos)`
111			`{`
112			`struct lcd_usb_data *lcd = &lcd_instance;`
113
114			`unsigned long copy_size;`
115			`unsigned long bytes_written = 0;`
116			`unsigned int partial;`
117
118			`int result = 0;`
119			`int maxretry;`
120
121			`/* Sanity check to make sure lcd is connected, powered, etc */`
122			`if (lcd == NULL \|\|`
123			`lcd->present == 0 \|\|`
124			`lcd->lcd_dev == NULL)`
125			`return -1;`
126
127			`do {`
128			`unsigned long thistime;`
129			`char *obuf = lcd->obuf;`
130
131			`thistime = copy_size =`
132			`(count >= OBUF_SIZE) ? OBUF_SIZE : count;`
133			`if (copy_from_user(lcd->obuf, buffer, copy_size))`
134			`return -EFAULT;`
135			`maxretry = 5;`
136			`while (thistime) {`
137			`if (!lcd->lcd_dev)`
138			`return -ENODEV;`
139			`if (signal_pending(current)) {`
140			`return bytes_written ? bytes_written : -EINTR;`
141			`}`
142
143			`result = usb_bulk_msg(lcd->lcd_dev,`
144			`usb_sndbulkpipe(lcd->lcd_dev, 1),`
145			`obuf, thistime, &partial, 10 * HZ);`
146
147			`dbg("write stats: result:%d thistime:%lu partial:%u",`
148			`result, thistime, partial);`
149
150			`if (result == USB_ST_TIMEOUT) { /* NAK - so hold for a while */`
151			`if (!maxretry--) {`
152			`return -ETIME;`
153			`}`
154			`interruptible_sleep_on_timeout(&lcd-> wait_q, NAK_TIMEOUT);`
155			`continue;`
156			`} else if (!result & partial) {`
157			`obuf += partial;`
158			`thistime -= partial;`
159			`} else`
160			`break;`
161			`};`
162			`if (result) {`
163			`err("Write Whoops - %x", result);`
164			`return -EIO;`
165			`}`
166			`bytes_written += copy_size;`
167			`count -= copy_size;`
168			`buffer += copy_size;`
169			`} while (count > 0);`
170
171			`return bytes_written ? bytes_written : -EIO;`
172			`}`
173
174			`static ssize_t`
175			`read_lcd(struct file file, char buffer, size_t count, loff_t * ppos)`
176			`{`
177			`struct lcd_usb_data *lcd = &lcd_instance;`
178			`ssize_t read_count;`
179			`unsigned int partial;`
180			`int this_read;`
181			`int result;`
182			`int maxretry = 10;`
183			`char *ibuf = lcd->ibuf;`
184
185			`/* Sanity check to make sure lcd is connected, powered, etc */`
186			`if (lcd == NULL \|\|`
187			`lcd->present == 0 \|\|`
188			`lcd->lcd_dev == NULL)`
189			`return -1;`
190
191			`read_count = 0;`
192
193			`while (count > 0) {`
194			`if (signal_pending(current)) {`
195			`return read_count ? read_count : -EINTR;`
196			`}`
197			`if (!lcd->lcd_dev)`
198			`return -ENODEV;`
199			`this_read = (count >= IBUF_SIZE) ? IBUF_SIZE : count;`
200
201			`result = usb_bulk_msg(lcd->lcd_dev,`
202			`usb_rcvbulkpipe(lcd->lcd_dev, 0),`
203			`ibuf, this_read, &partial,`
204			`(int) (HZ * 8));`
205
206			`dbg(KERN_DEBUG "read stats: result:%d this_read:%u partial:%u",`
207			`result, this_read, partial);`
208
209			`if (partial) {`
210			`count = this_read = partial;`
211			`} else if (result == USB_ST_TIMEOUT \|\| result == 15) { /* FIXME: 15 ??? */`
212			`if (!maxretry--) {`
213			`err("read_lcd: maxretry timeout");`
214			`return -ETIME;`
215			`}`
216			`interruptible_sleep_on_timeout(&lcd->wait_q,`
217			`NAK_TIMEOUT);`
218			`continue;`
219			`} else if (result != USB_ST_DATAUNDERRUN) {`
220			`err("Read Whoops - result:%u partial:%u this_read:%u",`
221			`result, partial, this_read);`
222			`return -EIO;`
223			`} else {`
224			`return (0);`
225			`}`
226
227			`if (this_read) {`
228			`if (copy_to_user(buffer, ibuf, this_read))`
229			`return -EFAULT;`
230			`count -= this_read;`
231			`read_count += this_read;`
232			`buffer += this_read;`
233			`}`
234			`}`
235			`return read_count;`
236			`}`
237
238			`static void probe_lcd(struct usb_device dev, unsigned int ifnum)`
239			`{`
240			`struct lcd_usb_data *lcd = &lcd_instance;`
241			`int i;`
242
243			`if (dev->descriptor.idProduct != 0x0001 ) {`
244			`warn(KERN_INFO "USBLCD model not supported.");`
245			`return NULL;`
246			`}`
247
248			`if (lcd->present == 1) {`
249			`warn(KERN_INFO "Multiple USBLCDs are not supported!");`
250			`return NULL;`
251			`}`
252
253			`i = dev->descriptor.bcdDevice;`
254
255			`info("USBLCD Version %1d%1d.%1d%1d found at address %d",`
256			`(i & 0xF000)>>12,(i & 0xF00)>>8,(i & 0xF0)>>4,(i & 0xF),`
257			`dev->devnum);`
258
259			`lcd->present = 1;`
260			`lcd->lcd_dev = dev;`
261
262			`if (!(lcd->obuf = (char *) kmalloc(OBUF_SIZE, GFP_KERNEL))) {`
263			`err("probe_lcd: Not enough memory for the output buffer");`
264			`return NULL;`
265			`}`
266			`dbg("probe_lcd: obuf address:%p", lcd->obuf);`
267
268			`if (!(lcd->ibuf = (char *) kmalloc(IBUF_SIZE, GFP_KERNEL))) {`
269			`err("probe_lcd: Not enough memory for the input buffer");`
270			`kfree(lcd->obuf);`
271			`return NULL;`
272			`}`
273			`dbg("probe_lcd: ibuf address:%p", lcd->ibuf);`
274
275			`return lcd;`
276			`}`
277
278			`static void disconnect_lcd(struct usb_device dev, void ptr)`
279			`{`
280			`struct lcd_usb_data lcd = (struct lcd_usb_data ) ptr;`
281
282			`if (lcd->isopen) {`
283			`lcd->isopen = 0;`
284			`/* better let it finish - the release will do whats needed */`
285			`lcd->lcd_dev = NULL;`
286			`return;`
287			`}`
288			`kfree(lcd->ibuf);`
289			`kfree(lcd->obuf);`
290
291			`info("USBLCD disconnected.");`
292
293			`lcd->present = 0;`
294			`}`
295
296			`static struct usb_device_id id_table [] = {`
297			`{ .idVendor = 0x10D2, .match_flags = USB_DEVICE_ID_MATCH_VENDOR, },`
298			`{},`
299			`};`
300
301			`MODULE_DEVICE_TABLE (usb, id_table);`
302
303			`static struct`
304			`file_operations usb_lcd_fops = {`
305			`.owner = THIS_MODULE,`
306			`.read = read_lcd,`
307			`.write = write_lcd,`
308			`.ioctl = ioctl_lcd,`
309			`.open = open_lcd,`
310			`.release = close_lcd,`
311			`};`
312
313			`static struct`
314			`usb_driver lcd_driver = {`
315			`.name = "usblcd",`
316			`.probe = (void *)probe_lcd,`
317			`.disconnect = disconnect_lcd,`
318			`.id_table = id_table,`
319			`.fops = &usb_lcd_fops,`
320			`.minor = USBLCD_MINOR,`
321			`};`
322
323			`int usb_lcd_init(void)`
324			`{`
325			`if (usb_register(&lcd_driver) < 0)`
326			`return -1;`
327
328			`info("%s (C) Adams IT Services http://www.usblcd.de", DRIVER_VERSION);`
329			`info("USBLCD support registered.");`
330			`return 0;`
331			`}`
332
333
334			`void usb_lcd_cleanup(void)`
335			`{`
336			`struct lcd_usb_data *lcd = &lcd_instance;`
337
338			`lcd->present = 0;`
339			`usb_deregister(&lcd_driver);`
340			`}`
341
342			`module_init(usb_lcd_init);`
343			`module_exit(usb_lcd_cleanup);`
344
345			`MODULE_AUTHOR("Adams IT Services <info@usblcd.de>");`
346			`MODULE_DESCRIPTION(DRIVER_VERSION);`
347			`MODULE_LICENSE("GPL");`