[PATCH] Fix numerous kcalloc() calls, convert to kzalloc()
[linux-2.6.git] / drivers / usb / misc / uss720.c
1 /*****************************************************************************/
2
3 /*
4  *      uss720.c  --  USS720 USB Parport Cable.
5  *
6  *      Copyright (C) 1999, 2005
7  *          Thomas Sailer (t.sailer@alumni.ethz.ch)
8  *
9  *      This program is free software; you can redistribute it and/or modify
10  *      it under the terms of the GNU General Public License as published by
11  *      the Free Software Foundation; either version 2 of the License, or
12  *      (at your option) any later version.
13  *
14  *      This program is distributed in the hope that it will be useful,
15  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *      GNU General Public License for more details.
18  *
19  *      You should have received a copy of the GNU General Public License
20  *      along with this program; if not, write to the Free Software
21  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22  *
23  *  Based on parport_pc.c
24  *
25  *  History:
26  *   0.1  04.08.1999  Created
27  *   0.2  07.08.1999  Some fixes mainly suggested by Tim Waugh
28  *                    Interrupt handling currently disabled because
29  *                    usb_request_irq crashes somewhere within ohci.c
30  *                    for no apparent reason (that is for me, anyway)
31  *                    ECP currently untested
32  *   0.3  10.08.1999  fixing merge errors
33  *   0.4  13.08.1999  Added Vendor/Product ID of Brad Hard's cable
34  *   0.5  20.09.1999  usb_control_msg wrapper used
35  *        Nov01.2000  usb_device_table support by Adam J. Richter
36  *        08.04.2001  Identify version on module load.  gb
37  *   0.6  02.09.2005  Fix "scheduling in interrupt" problem by making save/restore
38  *                    context asynchronous
39  *
40  */
41
42 /*****************************************************************************/
43
44 #include <linux/module.h>
45 #include <linux/socket.h>
46 #include <linux/parport.h>
47 #include <linux/init.h>
48 #include <linux/usb.h>
49 #include <linux/delay.h>
50 #include <linux/completion.h>
51 #include <linux/kref.h>
52
53 /*
54  * Version Information
55  */
56 #define DRIVER_VERSION "v0.6"
57 #define DRIVER_AUTHOR "Thomas M. Sailer, t.sailer@alumni.ethz.ch"
58 #define DRIVER_DESC "USB Parport Cable driver for Cables using the Lucent Technologies USS720 Chip"
59
60 /* --------------------------------------------------------------------- */
61
62 struct parport_uss720_private {
63         struct usb_device *usbdev;
64         struct parport *pp;
65         struct kref ref_count;
66         __u8 reg[7];  /* USB registers */
67         struct list_head asynclist;
68         spinlock_t asynclock;
69 };
70
71 struct uss720_async_request {
72         struct parport_uss720_private *priv;
73         struct kref ref_count;
74         struct list_head asynclist;
75         struct completion compl;
76         struct urb *urb;
77         struct usb_ctrlrequest dr;
78         __u8 reg[7];
79 };
80
81 /* --------------------------------------------------------------------- */
82
83 static void destroy_priv(struct kref *kref)
84 {
85         struct parport_uss720_private *priv = container_of(kref, struct parport_uss720_private, ref_count);
86
87         usb_put_dev(priv->usbdev);
88         kfree(priv);
89         dbg("destroying priv datastructure");
90 }
91
92 static void destroy_async(struct kref *kref)
93 {
94         struct uss720_async_request *rq = container_of(kref, struct uss720_async_request, ref_count);
95         struct parport_uss720_private *priv = rq->priv;
96         unsigned long flags;
97
98         if (likely(rq->urb))
99                 usb_free_urb(rq->urb);
100         spin_lock_irqsave(&priv->asynclock, flags);
101         list_del_init(&rq->asynclist);
102         spin_unlock_irqrestore(&priv->asynclock, flags);
103         kfree(rq);
104         kref_put(&priv->ref_count, destroy_priv);
105 }
106
107 /* --------------------------------------------------------------------- */
108
109 static void async_complete(struct urb *urb)
110 {
111         struct uss720_async_request *rq;
112         struct parport *pp;
113         struct parport_uss720_private *priv;
114
115         rq = urb->context;
116         priv = rq->priv;
117         pp = priv->pp;
118         if (urb->status) {
119                 err("async_complete: urb error %d", urb->status);
120         } else if (rq->dr.bRequest == 3) {
121                 memcpy(priv->reg, rq->reg, sizeof(priv->reg));
122 #if 0
123                 dbg("async_complete regs %02x %02x %02x %02x %02x %02x %02x",
124                     (unsigned int)priv->reg[0], (unsigned int)priv->reg[1], (unsigned int)priv->reg[2],
125                     (unsigned int)priv->reg[3], (unsigned int)priv->reg[4], (unsigned int)priv->reg[5],
126                     (unsigned int)priv->reg[6]);
127 #endif
128                 /* if nAck interrupts are enabled and we have an interrupt, call the interrupt procedure */
129                 if (rq->reg[2] & rq->reg[1] & 0x10 && pp)
130                         parport_generic_irq(0, pp);
131         }
132         complete(&rq->compl);
133         kref_put(&rq->ref_count, destroy_async);
134 }
135
136 static struct uss720_async_request *submit_async_request(struct parport_uss720_private *priv,
137                                                          __u8 request, __u8 requesttype, __u16 value, __u16 index,
138                                                          gfp_t mem_flags)
139 {
140         struct usb_device *usbdev;
141         struct uss720_async_request *rq;
142         unsigned long flags;
143         int ret;
144
145         if (!priv)
146                 return NULL;
147         usbdev = priv->usbdev;
148         if (!usbdev)
149                 return NULL;
150         rq = kmalloc(sizeof(struct uss720_async_request), mem_flags);
151         if (!rq) {
152                 err("submit_async_request out of memory");
153                 return NULL;
154         }
155         kref_init(&rq->ref_count);
156         INIT_LIST_HEAD(&rq->asynclist);
157         init_completion(&rq->compl);
158         kref_get(&priv->ref_count);
159         rq->priv = priv;
160         rq->urb = usb_alloc_urb(0, mem_flags);
161         if (!rq->urb) {
162                 kref_put(&rq->ref_count, destroy_async);
163                 err("submit_async_request out of memory");
164                 return NULL;
165         }
166         rq->dr.bRequestType = requesttype;
167         rq->dr.bRequest = request;
168         rq->dr.wValue = cpu_to_le16(value);
169         rq->dr.wIndex = cpu_to_le16(index);
170         rq->dr.wLength = cpu_to_le16((request == 3) ? sizeof(rq->reg) : 0);
171         usb_fill_control_urb(rq->urb, usbdev, (requesttype & 0x80) ? usb_rcvctrlpipe(usbdev, 0) : usb_sndctrlpipe(usbdev, 0),
172                              (unsigned char *)&rq->dr,
173                              (request == 3) ? rq->reg : NULL, (request == 3) ? sizeof(rq->reg) : 0, async_complete, rq);
174         /* rq->urb->transfer_flags |= URB_ASYNC_UNLINK; */
175         spin_lock_irqsave(&priv->asynclock, flags);
176         list_add_tail(&rq->asynclist, &priv->asynclist);
177         spin_unlock_irqrestore(&priv->asynclock, flags);
178         ret = usb_submit_urb(rq->urb, mem_flags);
179         if (!ret) {
180                 kref_get(&rq->ref_count);
181                 return rq;
182         }
183         kref_put(&rq->ref_count, destroy_async);
184         err("submit_async_request submit_urb failed with %d", ret);
185         return NULL;
186 }
187
188 static unsigned int kill_all_async_requests_priv(struct parport_uss720_private *priv)
189 {
190         struct uss720_async_request *rq;
191         unsigned long flags;
192         unsigned int ret = 0;
193
194         spin_lock_irqsave(&priv->asynclock, flags);
195         list_for_each_entry(rq, &priv->asynclist, asynclist) {
196                 usb_unlink_urb(rq->urb);
197                 ret++;
198         }
199         spin_unlock_irqrestore(&priv->asynclock, flags);
200         return ret;
201 }
202
203 /* --------------------------------------------------------------------- */
204
205 static int get_1284_register(struct parport *pp, unsigned char reg, unsigned char *val, gfp_t mem_flags)
206 {
207         struct parport_uss720_private *priv;
208         struct uss720_async_request *rq;
209         static const unsigned char regindex[9] = {
210                 4, 0, 1, 5, 5, 0, 2, 3, 6
211         };
212         int ret;
213
214         if (!pp)
215                 return -EIO;
216         priv = pp->private_data;
217         rq = submit_async_request(priv, 3, 0xc0, ((unsigned int)reg) << 8, 0, mem_flags);
218         if (!rq) {
219                 err("get_1284_register(%u) failed", (unsigned int)reg);
220                 return -EIO;
221         }
222         if (!val) {
223                 kref_put(&rq->ref_count, destroy_async);
224                 return 0;
225         }
226         if (wait_for_completion_timeout(&rq->compl, HZ)) {
227                 ret = rq->urb->status;
228                 *val = priv->reg[(reg >= 9) ? 0 : regindex[reg]];
229                 if (ret)
230                         warn("get_1284_register: usb error %d", ret);
231                 kref_put(&rq->ref_count, destroy_async);
232                 return ret;
233         }
234         warn("get_1284_register timeout");
235         kill_all_async_requests_priv(priv);
236         return -EIO;
237 }
238
239 static int set_1284_register(struct parport *pp, unsigned char reg, unsigned char val, gfp_t mem_flags)
240 {
241         struct parport_uss720_private *priv;
242         struct uss720_async_request *rq;
243
244         if (!pp)
245                 return -EIO;
246         priv = pp->private_data;
247         rq = submit_async_request(priv, 4, 0x40, (((unsigned int)reg) << 8) | val, 0, mem_flags);
248         if (!rq) {
249                 err("set_1284_register(%u,%u) failed", (unsigned int)reg, (unsigned int)val);
250                 return -EIO;
251         }
252         kref_put(&rq->ref_count, destroy_async);
253         return 0;
254 }
255
256 /* --------------------------------------------------------------------- */
257
258 /* ECR modes */
259 #define ECR_SPP 00
260 #define ECR_PS2 01
261 #define ECR_PPF 02
262 #define ECR_ECP 03
263 #define ECR_EPP 04
264
265 /* Safely change the mode bits in the ECR */
266 static int change_mode(struct parport *pp, int m)
267 {
268         struct parport_uss720_private *priv = pp->private_data;
269         int mode;
270         __u8 reg;
271
272         if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
273                 return -EIO;
274         /* Bits <7:5> contain the mode. */
275         mode = (priv->reg[2] >> 5) & 0x7;
276         if (mode == m)
277                 return 0;
278         /* We have to go through mode 000 or 001 */
279         if (mode > ECR_PS2 && m > ECR_PS2)
280                 if (change_mode(pp, ECR_PS2))
281                         return -EIO;
282
283         if (m <= ECR_PS2 && !(priv->reg[1] & 0x20)) {
284                 /* This mode resets the FIFO, so we may
285                  * have to wait for it to drain first. */
286                 unsigned long expire = jiffies + pp->physport->cad->timeout;
287                 switch (mode) {
288                 case ECR_PPF: /* Parallel Port FIFO mode */
289                 case ECR_ECP: /* ECP Parallel Port mode */
290                         /* Poll slowly. */
291                         for (;;) {
292                                 if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
293                                         return -EIO;
294                                 if (priv->reg[2] & 0x01)
295                                         break;
296                                 if (time_after_eq (jiffies, expire))
297                                         /* The FIFO is stuck. */
298                                         return -EBUSY;
299                                 msleep_interruptible(10);
300                                 if (signal_pending (current))
301                                         break;
302                         }
303                 }
304         }
305         /* Set the mode. */
306         if (set_1284_register(pp, 6, m << 5, GFP_KERNEL))
307                 return -EIO;
308         if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
309                 return -EIO;
310         return 0;
311 }
312
313 /*
314  * Clear TIMEOUT BIT in EPP MODE
315  */
316 static int clear_epp_timeout(struct parport *pp)
317 {
318         unsigned char stat;
319
320         if (get_1284_register(pp, 1, &stat, GFP_KERNEL))
321                 return 1;
322         return stat & 1;
323 }
324
325 /*
326  * Access functions.
327  */
328 #if 0
329 static int uss720_irq(int usbstatus, void *buffer, int len, void *dev_id)
330 {
331         struct parport *pp = (struct parport *)dev_id;
332         struct parport_uss720_private *priv = pp->private_data; 
333
334         if (usbstatus != 0 || len < 4 || !buffer)
335                 return 1;
336         memcpy(priv->reg, buffer, 4);
337         /* if nAck interrupts are enabled and we have an interrupt, call the interrupt procedure */
338         if (priv->reg[2] & priv->reg[1] & 0x10)
339                 parport_generic_irq(0, pp, NULL);
340         return 1;
341 }
342 #endif
343
344 static void parport_uss720_write_data(struct parport *pp, unsigned char d)
345 {
346         set_1284_register(pp, 0, d, GFP_KERNEL);
347 }
348
349 static unsigned char parport_uss720_read_data(struct parport *pp)
350 {
351         unsigned char ret;
352
353         if (get_1284_register(pp, 0, &ret, GFP_KERNEL))
354                 return 0;
355         return ret;
356 }
357
358 static void parport_uss720_write_control(struct parport *pp, unsigned char d)
359 {
360         struct parport_uss720_private *priv = pp->private_data; 
361
362         d = (d & 0xf) | (priv->reg[1] & 0xf0);
363         if (set_1284_register(pp, 2, d, GFP_KERNEL))
364                 return;
365         priv->reg[1] = d;
366 }
367
368 static unsigned char parport_uss720_read_control(struct parport *pp)
369 {
370         struct parport_uss720_private *priv = pp->private_data; 
371         return priv->reg[1] & 0xf; /* Use soft copy */
372 }
373
374 static unsigned char parport_uss720_frob_control(struct parport *pp, unsigned char mask, unsigned char val)
375 {
376         struct parport_uss720_private *priv = pp->private_data; 
377         unsigned char d;
378
379         mask &= 0x0f;
380         val &= 0x0f;
381         d = (priv->reg[1] & (~mask)) ^ val;
382         if (set_1284_register(pp, 2, d, GFP_KERNEL))
383                 return 0;
384         priv->reg[1] = d;
385         return d & 0xf;
386 }
387
388 static unsigned char parport_uss720_read_status(struct parport *pp)
389 {
390         unsigned char ret;
391
392         if (get_1284_register(pp, 1, &ret, GFP_KERNEL))
393                 return 0;
394         return ret & 0xf8;
395 }
396
397 static void parport_uss720_disable_irq(struct parport *pp)
398 {
399         struct parport_uss720_private *priv = pp->private_data; 
400         unsigned char d;
401
402         d = priv->reg[1] & ~0x10;
403         if (set_1284_register(pp, 2, d, GFP_KERNEL))
404                 return;
405         priv->reg[1] = d;
406 }
407
408 static void parport_uss720_enable_irq(struct parport *pp)
409 {
410         struct parport_uss720_private *priv = pp->private_data; 
411         unsigned char d;
412
413         d = priv->reg[1] | 0x10;
414         if (set_1284_register(pp, 2, d, GFP_KERNEL))
415                 return;
416         priv->reg[1] = d;
417 }
418
419 static void parport_uss720_data_forward (struct parport *pp)
420 {
421         struct parport_uss720_private *priv = pp->private_data; 
422         unsigned char d;
423
424         d = priv->reg[1] & ~0x20;
425         if (set_1284_register(pp, 2, d, GFP_KERNEL))
426                 return;
427         priv->reg[1] = d;
428 }
429
430 static void parport_uss720_data_reverse (struct parport *pp)
431 {
432         struct parport_uss720_private *priv = pp->private_data; 
433         unsigned char d;
434
435         d = priv->reg[1] | 0x20;
436         if (set_1284_register(pp, 2, d, GFP_KERNEL))
437                 return;
438         priv->reg[1] = d;
439 }
440
441 static void parport_uss720_init_state(struct pardevice *dev, struct parport_state *s)
442 {
443         s->u.pc.ctr = 0xc | (dev->irq_func ? 0x10 : 0x0);
444         s->u.pc.ecr = 0x24;
445 }
446
447 static void parport_uss720_save_state(struct parport *pp, struct parport_state *s)
448 {
449         struct parport_uss720_private *priv = pp->private_data; 
450
451 #if 0
452         if (get_1284_register(pp, 2, NULL, GFP_ATOMIC))
453                 return;
454 #endif
455         s->u.pc.ctr = priv->reg[1];
456         s->u.pc.ecr = priv->reg[2];
457 }
458
459 static void parport_uss720_restore_state(struct parport *pp, struct parport_state *s)
460 {
461         struct parport_uss720_private *priv = pp->private_data;
462
463         set_1284_register(pp, 2, s->u.pc.ctr, GFP_ATOMIC);
464         set_1284_register(pp, 6, s->u.pc.ecr, GFP_ATOMIC);
465         get_1284_register(pp, 2, NULL, GFP_ATOMIC);
466         priv->reg[1] = s->u.pc.ctr;
467         priv->reg[2] = s->u.pc.ecr;
468 }
469
470 static size_t parport_uss720_epp_read_data(struct parport *pp, void *buf, size_t length, int flags)
471 {
472         struct parport_uss720_private *priv = pp->private_data; 
473         size_t got = 0;
474
475         if (change_mode(pp, ECR_EPP))
476                 return 0;
477         for (; got < length; got++) {
478                 if (get_1284_register(pp, 4, (char *)buf, GFP_KERNEL))
479                         break;
480                 buf++;
481                 if (priv->reg[0] & 0x01) {
482                         clear_epp_timeout(pp);
483                         break;
484                 }
485         }
486         change_mode(pp, ECR_PS2);
487         return got;
488 }
489
490 static size_t parport_uss720_epp_write_data(struct parport *pp, const void *buf, size_t length, int flags)
491 {
492 #if 0
493         struct parport_uss720_private *priv = pp->private_data; 
494         size_t written = 0;
495
496         if (change_mode(pp, ECR_EPP))
497                 return 0;
498         for (; written < length; written++) {
499                 if (set_1284_register(pp, 4, (char *)buf, GFP_KERNEL))
500                         break;
501                 ((char*)buf)++;
502                 if (get_1284_register(pp, 1, NULL, GFP_KERNEL))
503                         break;
504                 if (priv->reg[0] & 0x01) {
505                         clear_epp_timeout(pp);
506                         break;
507                 }
508         }
509         change_mode(pp, ECR_PS2);
510         return written;
511 #else
512         struct parport_uss720_private *priv = pp->private_data;
513         struct usb_device *usbdev = priv->usbdev;
514         int rlen;
515         int i;
516
517         if (!usbdev)
518                 return 0;
519         if (change_mode(pp, ECR_EPP))
520                 return 0;
521         i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buf, length, &rlen, 20000);
522         if (i)
523                 printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buf, length, rlen);
524         change_mode(pp, ECR_PS2);
525         return rlen;
526 #endif
527 }
528
529 static size_t parport_uss720_epp_read_addr(struct parport *pp, void *buf, size_t length, int flags)
530 {
531         struct parport_uss720_private *priv = pp->private_data; 
532         size_t got = 0;
533
534         if (change_mode(pp, ECR_EPP))
535                 return 0;
536         for (; got < length; got++) {
537                 if (get_1284_register(pp, 3, (char *)buf, GFP_KERNEL))
538                         break;
539                 buf++;
540                 if (priv->reg[0] & 0x01) {
541                         clear_epp_timeout(pp);
542                         break;
543                 }
544         }
545         change_mode(pp, ECR_PS2);
546         return got;
547 }
548
549 static size_t parport_uss720_epp_write_addr(struct parport *pp, const void *buf, size_t length, int flags)
550 {
551         struct parport_uss720_private *priv = pp->private_data; 
552         size_t written = 0;
553
554         if (change_mode(pp, ECR_EPP))
555                 return 0;
556         for (; written < length; written++) {
557                 if (set_1284_register(pp, 3, *(char *)buf, GFP_KERNEL))
558                         break;
559                 buf++;
560                 if (get_1284_register(pp, 1, NULL, GFP_KERNEL))
561                         break;
562                 if (priv->reg[0] & 0x01) {
563                         clear_epp_timeout(pp);
564                         break;
565                 }
566         }
567         change_mode(pp, ECR_PS2);
568         return written;
569 }
570
571 static size_t parport_uss720_ecp_write_data(struct parport *pp, const void *buffer, size_t len, int flags)
572 {
573         struct parport_uss720_private *priv = pp->private_data;
574         struct usb_device *usbdev = priv->usbdev;
575         int rlen;
576         int i;
577
578         if (!usbdev)
579                 return 0;
580         if (change_mode(pp, ECR_ECP))
581                 return 0;
582         i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, 20000);
583         if (i)
584                 printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buffer, len, rlen);
585         change_mode(pp, ECR_PS2);
586         return rlen;
587 }
588
589 static size_t parport_uss720_ecp_read_data(struct parport *pp, void *buffer, size_t len, int flags)
590 {
591         struct parport_uss720_private *priv = pp->private_data;
592         struct usb_device *usbdev = priv->usbdev;
593         int rlen;
594         int i;
595
596         if (!usbdev)
597                 return 0;
598         if (change_mode(pp, ECR_ECP))
599                 return 0;
600         i = usb_bulk_msg(usbdev, usb_rcvbulkpipe(usbdev, 2), buffer, len, &rlen, 20000);
601         if (i)
602                 printk(KERN_ERR "uss720: recvbulk ep 2 buf %p len %Zu rlen %u\n", buffer, len, rlen);
603         change_mode(pp, ECR_PS2);
604         return rlen;
605 }
606
607 static size_t parport_uss720_ecp_write_addr(struct parport *pp, const void *buffer, size_t len, int flags)
608 {
609         size_t written = 0;
610
611         if (change_mode(pp, ECR_ECP))
612                 return 0;
613         for (; written < len; written++) {
614                 if (set_1284_register(pp, 5, *(char *)buffer, GFP_KERNEL))
615                         break;
616                 buffer++;
617         }
618         change_mode(pp, ECR_PS2);
619         return written;
620 }
621
622 static size_t parport_uss720_write_compat(struct parport *pp, const void *buffer, size_t len, int flags)
623 {
624         struct parport_uss720_private *priv = pp->private_data;
625         struct usb_device *usbdev = priv->usbdev;
626         int rlen;
627         int i;
628
629         if (!usbdev)
630                 return 0;
631         if (change_mode(pp, ECR_PPF))
632                 return 0;
633         i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, 20000);
634         if (i)
635                 printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %u\n", buffer, len, rlen);
636         change_mode(pp, ECR_PS2);
637         return rlen;
638 }
639
640 /* --------------------------------------------------------------------- */
641
642 static struct parport_operations parport_uss720_ops = 
643 {
644         .owner =                THIS_MODULE,
645         .write_data =           parport_uss720_write_data,
646         .read_data =            parport_uss720_read_data,
647
648         .write_control =        parport_uss720_write_control,
649         .read_control =         parport_uss720_read_control,
650         .frob_control =         parport_uss720_frob_control,
651
652         .read_status =          parport_uss720_read_status,
653
654         .enable_irq =           parport_uss720_enable_irq,
655         .disable_irq =          parport_uss720_disable_irq,
656
657         .data_forward =         parport_uss720_data_forward,
658         .data_reverse =         parport_uss720_data_reverse,
659
660         .init_state =           parport_uss720_init_state,
661         .save_state =           parport_uss720_save_state,
662         .restore_state =        parport_uss720_restore_state,
663
664         .epp_write_data =       parport_uss720_epp_write_data,
665         .epp_read_data =        parport_uss720_epp_read_data,
666         .epp_write_addr =       parport_uss720_epp_write_addr,
667         .epp_read_addr =        parport_uss720_epp_read_addr,
668
669         .ecp_write_data =       parport_uss720_ecp_write_data,
670         .ecp_read_data =        parport_uss720_ecp_read_data,
671         .ecp_write_addr =       parport_uss720_ecp_write_addr,
672
673         .compat_write_data =    parport_uss720_write_compat,
674         .nibble_read_data =     parport_ieee1284_read_nibble,
675         .byte_read_data =       parport_ieee1284_read_byte,
676 };
677
678 /* --------------------------------------------------------------------- */
679
680 static int uss720_probe(struct usb_interface *intf,
681                         const struct usb_device_id *id)
682 {
683         struct usb_device *usbdev = usb_get_dev(interface_to_usbdev(intf));
684         struct usb_host_interface *interface;
685         struct usb_host_endpoint *endpoint;
686         struct parport_uss720_private *priv;
687         struct parport *pp;
688         unsigned char reg;
689         int i;
690
691         dbg("probe: vendor id 0x%x, device id 0x%x\n",
692             le16_to_cpu(usbdev->descriptor.idVendor),
693             le16_to_cpu(usbdev->descriptor.idProduct));
694
695         /* our known interfaces have 3 alternate settings */
696         if (intf->num_altsetting != 3) {
697                 usb_put_dev(usbdev);
698                 return -ENODEV;
699         }
700         i = usb_set_interface(usbdev, intf->altsetting->desc.bInterfaceNumber, 2);
701         dbg("set inteface result %d", i);
702
703         interface = intf->cur_altsetting;
704
705         /*
706          * Allocate parport interface 
707          */
708         if (!(priv = kzalloc(sizeof(struct parport_uss720_private), GFP_KERNEL))) {
709                 usb_put_dev(usbdev);
710                 return -ENOMEM;
711         }
712         priv->pp = NULL;
713         priv->usbdev = usbdev;
714         kref_init(&priv->ref_count);
715         spin_lock_init(&priv->asynclock);
716         INIT_LIST_HEAD(&priv->asynclist);
717         if (!(pp = parport_register_port(0, PARPORT_IRQ_NONE, PARPORT_DMA_NONE, &parport_uss720_ops))) {
718                 warn("could not register parport");
719                 goto probe_abort;
720         }
721
722         priv->pp = pp;
723         pp->private_data = priv;
724         pp->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_TRISTATE | PARPORT_MODE_EPP | PARPORT_MODE_ECP | PARPORT_MODE_COMPAT;
725
726         /* set the USS720 control register to manual mode, no ECP compression, enable all ints */
727         set_1284_register(pp, 7, 0x00, GFP_KERNEL);
728         set_1284_register(pp, 6, 0x30, GFP_KERNEL);  /* PS/2 mode */
729         set_1284_register(pp, 2, 0x0c, GFP_KERNEL);
730         /* debugging */
731         get_1284_register(pp, 0, &reg, GFP_KERNEL);
732         dbg("reg: %02x %02x %02x %02x %02x %02x %02x",
733             priv->reg[0], priv->reg[1], priv->reg[2], priv->reg[3], priv->reg[4], priv->reg[5], priv->reg[6]);
734
735         endpoint = &interface->endpoint[2];
736         dbg("epaddr %d interval %d", endpoint->desc.bEndpointAddress, endpoint->desc.bInterval);
737         parport_announce_port(pp);
738
739         usb_set_intfdata(intf, pp);
740         return 0;
741
742 probe_abort:
743         kill_all_async_requests_priv(priv);
744         kref_put(&priv->ref_count, destroy_priv);
745         return -ENODEV;
746 }
747
748 static void uss720_disconnect(struct usb_interface *intf)
749 {
750         struct parport *pp = usb_get_intfdata(intf);
751         struct parport_uss720_private *priv;
752         struct usb_device *usbdev;
753
754         dbg("disconnect");
755         usb_set_intfdata(intf, NULL);
756         if (pp) {
757                 priv = pp->private_data;
758                 usbdev = priv->usbdev;
759                 priv->usbdev = NULL;
760                 priv->pp = NULL;
761                 dbg("parport_remove_port");
762                 parport_remove_port(pp);
763                 parport_put_port(pp);
764                 kill_all_async_requests_priv(priv);
765                 kref_put(&priv->ref_count, destroy_priv);
766         }
767         dbg("disconnect done");
768 }
769
770 /* table of cables that work through this driver */
771 static struct usb_device_id uss720_table [] = {
772         { USB_DEVICE(0x047e, 0x1001) },
773         { USB_DEVICE(0x0557, 0x2001) },
774         { USB_DEVICE(0x0729, 0x1284) },
775         { USB_DEVICE(0x1293, 0x0002) },
776         { }                                             /* Terminating entry */
777 };
778
779 MODULE_DEVICE_TABLE (usb, uss720_table);
780
781
782 static struct usb_driver uss720_driver = {
783         .name =         "uss720",
784         .probe =        uss720_probe,
785         .disconnect =   uss720_disconnect,
786         .id_table =     uss720_table,
787 };
788
789 /* --------------------------------------------------------------------- */
790
791 MODULE_AUTHOR(DRIVER_AUTHOR);
792 MODULE_DESCRIPTION(DRIVER_DESC);
793 MODULE_LICENSE("GPL");
794
795 static int __init uss720_init(void)
796 {
797         int retval;
798         retval = usb_register(&uss720_driver);
799         if (retval)
800                 goto out;
801
802         info(DRIVER_VERSION ":" DRIVER_DESC);
803         info("NOTE: this is a special purpose driver to allow nonstandard");
804         info("protocols (eg. bitbang) over USS720 usb to parallel cables");
805         info("If you just want to connect to a printer, use usblp instead");
806 out:
807         return retval;
808 }
809
810 static void __exit uss720_cleanup(void)
811 {
812         usb_deregister(&uss720_driver);
813 }
814
815 module_init(uss720_init);
816 module_exit(uss720_cleanup);
817
818 /* --------------------------------------------------------------------- */