Version:  2.0.40 2.2.26 2.4.37 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9

Linux/drivers/usb/misc/uss720.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us