1 /*****************************************************************************/
2 /*
3 * auermain.c -- Auerswald PBX/System Telephone usb driver.
4 *
5 * Copyright (C) 2002-2004 Wolfgang M�es (wolfgang@iksw-muees.de)
6 *
7 * Very much code of this driver is borrowed from dabusb.c (Deti Fliegl)
8 * and from the USB Skeleton driver (Greg Kroah-Hartman). Thank you.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24 /*****************************************************************************/
25
26 /* Standard Linux module include files */
27 #include <linux/slab.h>
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/devfs_fs_kernel.h>
31 #undef DEBUG /* include debug macros until it's done */
32 #include <linux/usb.h>
33 #include "auerchain.h"
34 #include "auerbuf.h"
35 #include "auerchar.h"
36 #include "auerserv.h"
37 #include "auermain.h"
38 #include "auerisdn.h"
39
40 /*-------------------------------------------------------------------*/
41 /* Debug support */
42 #ifdef DEBUG
43 #define dump( desc, adr, len) \
44 do { \
45 unsigned int u; \
46 printk (KERN_DEBUG); \
47 printk (desc); \
48 for (u = 0; u < len; u++) \
49 printk (" %02X", adr[u] & 0xFF); \
50 printk ("\n"); \
51 } while (0)
52 #else
53 #define dump( desc, adr, len)
54 #endif
55
56 /*-------------------------------------------------------------------*/
57 /* Version Information */
58 #define DRIVER_VERSION "1.2.7"
59 #define DRIVER_AUTHOR "Wolfgang M�es <wolfgang@iksw-muees.de>"
60 #define DRIVER_DESC "Auerswald PBX/System Telephone usb driver"
61
62 /*-------------------------------------------------------------------*/
63 /* Internal data structures */
64
65 /* the global usb devfs handle */
66 extern devfs_handle_t usb_devfs_handle;
67
68 /* array of pointers to our devices that are currently connected */
69 struct auerswald *auerdev_table[AUER_MAX_DEVICES];
70
71 /* lock to protect the auerdev_table structure */
72 struct semaphore auerdev_table_mutex;
73
74 /*-------------------------------------------------------------------*/
75 /* Forwards */
76 static void auerswald_ctrlread_complete(struct urb *urb);
77
78 /*-------------------------------------------------------------------*/
79 /* Completion handlers */
80
81 /* Values of urb->status or results of usb_submit_urb():
82 0 Initial, OK
83 -EINPROGRESS during submission until end
84 -ENOENT if urb is unlinked
85 -ETIMEDOUT Transfer timed out, NAK
86 -ENOMEM Memory Overflow
87 -ENODEV Specified USB-device or bus doesn't exist
88 -ENXIO URB already queued
89 -EINVAL a) Invalid transfer type specified (or not supported)
90 b) Invalid interrupt interval (0n256)
91 -EAGAIN a) Specified ISO start frame too early
92 b) (using ISO-ASAP) Too much scheduled for the future wait some time and try again.
93 -EFBIG Too much ISO frames requested (currently uhci900)
94 -EPIPE Specified pipe-handle/Endpoint is already stalled
95 -EMSGSIZE Endpoint message size is zero, do interface/alternate setting
96 -EPROTO a) Bitstuff error
97 b) Unknown USB error
98 -EILSEQ CRC mismatch
99 -ENOSR Buffer error
100 -EREMOTEIO Short packet detected
101 -EXDEV ISO transfer only partially completed look at individual frame status for details
102 -EINVAL ISO madness, if this happens: Log off and go home
103 -EOVERFLOW babble
104 */
105
106 /* check if a status code allows a retry */
auerswald_status_retry(int status)107 static int auerswald_status_retry(int status)
108 {
109 switch (status) {
110 case 0:
111 case -ETIMEDOUT:
112 case -EOVERFLOW:
113 case -EFBIG:
114 case -EAGAIN:
115 case -EPROTO:
116 case -EILSEQ:
117 case -ENOSR:
118 case -EREMOTEIO:
119 return 1; /* do a retry */
120 }
121 return 0; /* no retry possible */
122 }
123
124
125 /* Completion of asynchronous write block */
auerchar_ctrlwrite_complete(struct urb * urb)126 void auerchar_ctrlwrite_complete(struct urb *urb)
127 {
128 struct auerbuf *bp = (struct auerbuf *) urb->context;
129 struct auerswald *cp =
130 ((struct auerswald *) ((char *) (bp->list) -
131 (unsigned
132 long) (&((struct auerswald *) 0)->
133 bufctl)));
134 dbg("auerchar_ctrlwrite_complete called");
135
136 /* reuse the buffer */
137 auerbuf_releasebuf(bp);
138 /* Wake up all processes waiting for a buffer */
139 wake_up(&cp->bufferwait);
140 }
141
142 /* Completion handler for dummy retry packet */
auerswald_ctrlread_wretcomplete(struct urb * urb)143 static void auerswald_ctrlread_wretcomplete(struct urb *urb)
144 {
145 struct auerbuf *bp = (struct auerbuf *) urb->context;
146 struct auerswald *cp;
147 int ret;
148 dbg("auerswald_ctrlread_wretcomplete called");
149 dbg("complete with status: %d", urb->status);
150 cp = ((struct auerswald *) ((char *) (bp->list) -
151 (unsigned
152 long) (&((struct auerswald *) 0)->
153 bufctl)));
154
155 /* check if it is possible to advance */
156 if (!auerswald_status_retry(urb->status) || !cp->usbdev) {
157 /* reuse the buffer */
158 err("control dummy: transmission error %d, can not retry",
159 urb->status);
160 auerbuf_releasebuf(bp);
161 /* Wake up all processes waiting for a buffer */
162 wake_up(&cp->bufferwait);
163 return;
164 }
165
166 /* fill the control message */
167 bp->dr->bRequestType = AUT_RREQ;
168 bp->dr->bRequest = AUV_RBLOCK;
169 bp->dr->wLength = bp->dr->wValue; /* temporary stored */
170 bp->dr->wValue = cpu_to_le16(1); /* Retry Flag */
171 /* bp->dr->wIndex = channel id; remains */
172 FILL_CONTROL_URB(bp->urbp, cp->usbdev,
173 usb_rcvctrlpipe(cp->usbdev, 0),
174 (unsigned char *) bp->dr, bp->bufp,
175 le16_to_cpu(bp->dr->wLength),
176 (usb_complete_t) auerswald_ctrlread_complete, bp);
177
178 /* submit the control msg as next paket */
179 ret = auerchain_submit_urb_list(&cp->controlchain, bp->urbp, 1);
180 if (ret) {
181 dbg("auerswald_ctrlread_complete: nonzero result of auerchain_submit_urb_list %d", ret);
182 bp->urbp->status = ret;
183 auerswald_ctrlread_complete(bp->urbp);
184 }
185 }
186
187 /* completion handler for receiving of control messages */
auerswald_ctrlread_complete(struct urb * urb)188 static void auerswald_ctrlread_complete(struct urb *urb)
189 {
190 unsigned int serviceid;
191 struct auerswald *cp;
192 struct auerscon *scp;
193 struct auerbuf *bp = (struct auerbuf *) urb->context;
194 int ret;
195 dbg("auerswald_ctrlread_complete called");
196
197 cp = ((struct auerswald *) ((char *) (bp->list) -
198 (unsigned
199 long) (&((struct auerswald *) 0)->
200 bufctl)));
201
202 /* check if there is valid data in this urb */
203 if (urb->status) {
204 dbg("complete with non-zero status: %d", urb->status);
205 /* should we do a retry? */
206 if (!auerswald_status_retry(urb->status)
207 || !cp->usbdev || (cp->version < AUV_RETRY)
208 || (bp->retries >= AU_RETRIES)) {
209 /* reuse the buffer */
210 err("control read: transmission error %d, can not retry", urb->status);
211 auerbuf_releasebuf(bp);
212 /* Wake up all processes waiting for a buffer */
213 wake_up(&cp->bufferwait);
214 return;
215 }
216 bp->retries++;
217 dbg("Retry count = %d", bp->retries);
218 /* send a long dummy control-write-message to allow device firmware to react */
219 bp->dr->bRequestType = AUT_WREQ;
220 bp->dr->bRequest = AUV_DUMMY;
221 bp->dr->wValue = bp->dr->wLength; /* temporary storage */
222 // bp->dr->wIndex channel ID remains
223 bp->dr->wLength = cpu_to_le16(32); /* >= 8 bytes */
224 FILL_CONTROL_URB(bp->urbp, cp->usbdev,
225 usb_sndctrlpipe(cp->usbdev, 0),
226 (unsigned char *) bp->dr, bp->bufp, 32,
227 (usb_complete_t)
228 auerswald_ctrlread_wretcomplete, bp);
229
230 /* submit the control msg as next paket */
231 ret =
232 auerchain_submit_urb_list(&cp->controlchain, bp->urbp,
233 1);
234 if (ret) {
235 dbg("auerswald_ctrlread_complete: nonzero result of auerchain_submit_urb_list %d", ret);
236 bp->urbp->status = ret;
237 auerswald_ctrlread_wretcomplete(bp->urbp);
238 }
239 return;
240 }
241
242 /* get the actual bytecount (incl. headerbyte) */
243 bp->len = urb->actual_length;
244 serviceid = bp->bufp[0] & AUH_TYPEMASK;
245 dbg("Paket with serviceid %d and %d bytes received", serviceid,
246 bp->len);
247
248 /* dispatch the paket */
249 scp = cp->services[serviceid];
250 if (scp) {
251 /* look, Ma, a listener! */
252 scp->dispatch(scp, bp);
253 }
254
255 /* release the paket */
256 auerbuf_releasebuf(bp);
257 /* Wake up all processes waiting for a buffer */
258 wake_up(&cp->bufferwait);
259 }
260
261 /*-------------------------------------------------------------------*/
262 /* Handling of Interrupt Endpoint */
263 /* This interrupt Endpoint is used to inform the host about waiting
264 messages from the USB device.
265 */
266 /* int completion handler. */
auerswald_int_complete(struct urb * urb)267 static void auerswald_int_complete(struct urb *urb)
268 {
269 unsigned int channelid;
270 unsigned int bytecount;
271 int ret;
272 struct auerbuf *bp = NULL;
273 struct auerswald *cp = (struct auerswald *) urb->context;
274
275 dbg("auerswald_int_complete called");
276
277 /* do not respond to an error condition */
278 if (urb->status != 0) {
279 dbg("nonzero URB status = %d", urb->status);
280 return;
281 }
282
283 /* check if all needed data was received */
284 if (urb->actual_length < AU_IRQMINSIZE) {
285 dbg("invalid data length received: %d bytes",
286 urb->actual_length);
287 return;
288 }
289
290 /* check the command code */
291 if (cp->intbufp[0] != AU_IRQCMDID) {
292 dbg("invalid command received: %d", cp->intbufp[0]);
293 return;
294 }
295
296 /* check the command type */
297 if (cp->intbufp[1] != AU_BLOCKRDY) {
298 dbg("invalid command type received: %d", cp->intbufp[1]);
299 return;
300 }
301
302 /* now extract the information */
303 channelid = cp->intbufp[2];
304 bytecount = le16_to_cpup(&cp->intbufp[3]);
305
306 /* check the channel id */
307 if (channelid >= AUH_TYPESIZE) {
308 dbg("invalid channel id received: %d", channelid);
309 return;
310 }
311
312 /* check the byte count */
313 if (bytecount > (cp->maxControlLength + AUH_SIZE)) {
314 dbg("invalid byte count received: %d", bytecount);
315 return;
316 }
317 dbg("Service Channel = %d", channelid);
318 dbg("Byte Count = %d", bytecount);
319
320 /* get a buffer for the next data paket */
321 bp = auerbuf_getbuf(&cp->bufctl);
322 /* if no buffer available: skip it */
323 if (!bp) {
324 dbg("auerswald_int_complete: no data buffer available");
325 /* can we do something more?
326 This is a big problem: if this int packet is ignored, the
327 device will wait forever and not signal any more data.
328 The only real solution is: having enought buffers!
329 Or perhaps temporary disabling the int endpoint?
330 */
331 return;
332 }
333
334 /* fill the control message */
335 bp->dr->bRequestType = AUT_RREQ;
336 bp->dr->bRequest = AUV_RBLOCK;
337 bp->dr->wValue = cpu_to_le16(0);
338 bp->dr->wIndex = cpu_to_le16(channelid | AUH_DIRECT | AUH_UNSPLIT);
339 bp->dr->wLength = cpu_to_le16(bytecount);
340 FILL_CONTROL_URB(bp->urbp, cp->usbdev,
341 usb_rcvctrlpipe(cp->usbdev, 0),
342 (unsigned char *) bp->dr, bp->bufp, bytecount,
343 (usb_complete_t) auerswald_ctrlread_complete, bp);
344
345 /* submit the control msg */
346 ret = auerchain_submit_urb(&cp->controlchain, bp->urbp);
347 if (ret) {
348 dbg("auerswald_int_complete: nonzero result of auerchain_submit_urb %d", ret);
349 bp->urbp->status = ret;
350 auerswald_ctrlread_complete(bp->urbp);
351 /* here applies the same problem as above: device locking! */
352 }
353 }
354
355 /* int memory deallocation
356 NOTE: no mutex please!
357 */
auerswald_int_free(struct auerswald * cp)358 static void auerswald_int_free(struct auerswald *cp)
359 {
360 if (cp->inturbp) {
361 usb_free_urb(cp->inturbp);
362 cp->inturbp = NULL;
363 }
364 kfree(cp->intbufp);
365 }
366
367 /* This function is called to activate the interrupt
368 endpoint. This function returns 0 if successfull or an error code.
369 NOTE: no mutex please!
370 */
auerswald_int_open(struct auerswald * cp)371 static int auerswald_int_open(struct auerswald *cp)
372 {
373 int ret;
374 struct usb_endpoint_descriptor *ep;
375 int irqsize;
376 dbg("auerswald_int_open");
377
378 ep = usb_epnum_to_ep_desc(cp->usbdev, USB_DIR_IN | AU_IRQENDP);
379 if (!ep) {
380 ret = -EFAULT;
381 goto intoend;
382 }
383 irqsize = ep->wMaxPacketSize;
384 cp->irqsize = irqsize;
385
386 /* allocate the urb and data buffer */
387 if (!cp->inturbp) {
388 cp->inturbp = usb_alloc_urb(0);
389 if (!cp->inturbp) {
390 ret = -ENOMEM;
391 goto intoend;
392 }
393 }
394 if (!cp->intbufp) {
395 cp->intbufp = (char *) kmalloc(irqsize, GFP_KERNEL);
396 if (!cp->intbufp) {
397 ret = -ENOMEM;
398 goto intoend;
399 }
400 }
401 /* setup urb */
402 FILL_INT_URB(cp->inturbp, cp->usbdev,
403 usb_rcvintpipe(cp->usbdev, AU_IRQENDP), cp->intbufp,
404 irqsize, auerswald_int_complete, cp, ep->bInterval);
405 /* start the urb */
406 cp->inturbp->status = 0; /* needed! */
407 ret = usb_submit_urb(cp->inturbp);
408
409 intoend:
410 if (ret < 0) {
411 /* activation of interrupt endpoint has failed. Now clean up. */
412 dbg("auerswald_int_open: activation of int endpoint failed");
413
414 /* deallocate memory */
415 auerswald_int_free(cp);
416 }
417 return ret;
418 }
419
420 /* This function is called to deactivate the interrupt
421 endpoint. This function returns 0 if successfull or an error code.
422 NOTE: no mutex please!
423 */
auerswald_int_release(struct auerswald * cp)424 static int auerswald_int_release(struct auerswald *cp)
425 {
426 int ret = 0;
427 dbg("auerswald_int_release");
428
429 /* stop the int endpoint */
430 if (cp->inturbp) {
431 ret = usb_unlink_urb(cp->inturbp);
432 if (ret)
433 dbg("nonzero int unlink result received: %d", ret);
434 }
435
436 /* deallocate memory */
437 auerswald_int_free(cp);
438
439 return ret;
440 }
441
442 /* --------------------------------------------------------------------- */
443 /* Helper functions */
444
445 /* Delete an auerswald driver context */
auerswald_delete(struct auerswald * cp)446 void auerswald_delete(struct auerswald *cp)
447 {
448 dbg("auerswald_delete");
449 if (cp == NULL)
450 return;
451
452 /* Wake up all processes waiting for a buffer */
453 wake_up(&cp->bufferwait);
454
455 /* Cleaning up */
456 auerisdn_disconnect(cp);
457 auerswald_int_release(cp);
458 auerchain_free(&cp->controlchain);
459 auerbuf_free_buffers(&cp->bufctl);
460
461 /* release the memory */
462 kfree(cp);
463 }
464
465
466 /* add a new service to the device
467 scp->id must be set!
468 return: 0 if OK, else error code
469 */
auerswald_addservice(struct auerswald * cp,struct auerscon * scp)470 int auerswald_addservice(struct auerswald *cp, struct auerscon *scp)
471 {
472 int ret;
473
474 /* is the device available? */
475 if (!cp->usbdev) {
476 dbg("usbdev == NULL");
477 return -EIO; /*no: can not add a service, sorry */
478 }
479
480 /* is the service available? */
481 if (cp->services[scp->id]) {
482 dbg("service is busy");
483 return -EBUSY;
484 }
485
486 /* device is available, service is free */
487 cp->services[scp->id] = scp;
488
489 /* register service in device */
490 ret = auerchain_control_msg(&cp->controlchain, /* pointer to control chain */
491 cp->usbdev, /* pointer to device */
492 usb_sndctrlpipe(cp->usbdev, 0), /* pipe to control endpoint */
493 AUV_CHANNELCTL, /* USB message request value */
494 AUT_WREQ, /* USB message request type value */
495 0x01, /* open */ /* USB message value */
496 scp->id, /* USB message index value */
497 NULL, /* pointer to the data to send */
498 0, /* length in bytes of the data to send */
499 HZ * 2); /* time to wait for the message to complete before timing out */
500 if (ret < 0) {
501 dbg("auerswald_addservice: auerchain_control_msg returned error code %d", ret);
502 /* undo above actions */
503 cp->services[scp->id] = NULL;
504 return ret;
505 }
506
507 dbg("auerswald_addservice: channel open OK");
508 return 0;
509 }
510
511
512 /* remove a service from the the device
513 scp->id must be set! */
auerswald_removeservice(struct auerswald * cp,struct auerscon * scp)514 void auerswald_removeservice(struct auerswald *cp, struct auerscon *scp)
515 {
516 dbg("auerswald_removeservice called");
517
518 /* check if we have a service allocated */
519 if (scp->id == AUH_UNASSIGNED)
520 return;
521
522 /* If there is a device: close the channel */
523 if (cp->usbdev && !cp->disconnecting) {
524 /* Close the service channel inside the device */
525 int ret = auerchain_control_msg(&cp->controlchain, /* pointer to control chain */
526 cp->usbdev, /* pointer to device */
527 usb_sndctrlpipe(cp->usbdev, 0), /* pipe to control endpoint */
528 AUV_CHANNELCTL, /* USB message request value */
529 AUT_WREQ, /* USB message request type value */
530 0x00, /* close */ /* USB message value */
531 scp->id, /* USB message index value */
532 NULL, /* pointer to the data to send */
533 0, /* length in bytes of the data to send */
534 HZ * 2); /* time to wait for the message to complete before timing out */
535 if (ret < 0) {
536 dbg("auerswald_removeservice: auerchain_control_msg returned error code %d", ret);
537 } else {
538 dbg("auerswald_removeservice: channel close OK");
539 }
540 }
541
542 /* remove the service from the device */
543 cp->services[scp->id] = NULL;
544 scp->id = AUH_UNASSIGNED;
545 }
546
547
548 /*----------------------------------------------------------------------*/
549 /* File operation structure */
550 static struct file_operations auerswald_fops = {
551 owner:THIS_MODULE,
552 llseek:auerchar_llseek,
553 read:auerchar_read,
554 write:auerchar_write,
555 ioctl:auerchar_ioctl,
556 open:auerchar_open,
557 release:auerchar_release,
558 };
559
560 /* --------------------------------------------------------------------- */
561 /* Special USB driver functions */
562
563 /* Probe if this driver wants to serve an USB device
564
565 This entry point is called whenever a new device is attached to the bus.
566 Then the device driver has to create a new instance of its internal data
567 structures for the new device.
568
569 The dev argument specifies the device context, which contains pointers
570 to all USB descriptors. The interface argument specifies the interface
571 number. If a USB driver wants to bind itself to a particular device and
572 interface it has to return a pointer. This pointer normally references
573 the device driver's context structure.
574
575 Probing normally is done by checking the vendor and product identifications
576 or the class and subclass definitions. If they match the interface number
577 is compared with the ones supported by the driver. When probing is done
578 class based it might be necessary to parse some more USB descriptors because
579 the device properties can differ in a wide range.
580 */
auerswald_probe(struct usb_device * usbdev,unsigned int ifnum,const struct usb_device_id * id)581 static void *auerswald_probe(struct usb_device *usbdev, unsigned int ifnum,
582 const struct usb_device_id *id)
583 {
584 struct auerswald *cp = NULL;
585 DECLARE_WAIT_QUEUE_HEAD(wqh);
586 unsigned int dtindex;
587 unsigned int u = 0;
588 char *pbuf;
589 int ret;
590
591 dbg("probe: vendor id 0x%x, device id 0x%x ifnum:%d",
592 usbdev->descriptor.idVendor, usbdev->descriptor.idProduct,
593 ifnum);
594
595 /* See if the device offered us matches that we can accept */
596 if (usbdev->descriptor.idVendor != ID_AUERSWALD)
597 return NULL;
598
599 /* we use only the first -and only- interface */
600 if (ifnum != 0)
601 return NULL;
602
603 /* prevent module unloading while sleeping */
604 MOD_INC_USE_COUNT;
605
606 /* allocate memory for our device and intialize it */
607 cp = kmalloc(sizeof(struct auerswald), GFP_KERNEL);
608 if (cp == NULL) {
609 err("out of memory");
610 goto pfail;
611 }
612
613 /* Initialize device descriptor */
614 memset(cp, 0, sizeof(struct auerswald));
615 init_MUTEX(&cp->mutex);
616 cp->usbdev = usbdev;
617 auerchain_init(&cp->controlchain);
618 auerbuf_init(&cp->bufctl);
619 init_waitqueue_head(&cp->bufferwait);
620 auerisdn_init_dev(cp);
621
622 /* find a free slot in the device table */
623 down(&auerdev_table_mutex);
624 for (dtindex = 0; dtindex < AUER_MAX_DEVICES; ++dtindex) {
625 if (auerdev_table[dtindex] == NULL)
626 break;
627 }
628 if (dtindex >= AUER_MAX_DEVICES) {
629 err("more than %d devices plugged in, can not handle this device", AUER_MAX_DEVICES);
630 up(&auerdev_table_mutex);
631 goto pfail;
632 }
633
634 /* Give the device a name */
635 sprintf(cp->name, AU_PREFIX "%d", dtindex);
636
637 /* Store the index */
638 cp->dtindex = dtindex;
639 auerdev_table[dtindex] = cp;
640 up(&auerdev_table_mutex);
641
642 /* initialize the devfs node for this device and register it */
643 cp->devfs = devfs_register(usb_devfs_handle, cp->name,
644 DEVFS_FL_DEFAULT, USB_MAJOR,
645 AUER_MINOR_BASE + dtindex,
646 S_IFCHR | S_IRUGO | S_IWUGO,
647 &auerswald_fops, NULL);
648
649 /* Get the usb version of the device */
650 cp->version = cp->usbdev->descriptor.bcdDevice;
651 dbg("Version is %X", cp->version);
652
653 /* allow some time to settle the device */
654 sleep_on_timeout(&wqh, HZ / 3);
655
656 /* Try to get a suitable textual description of the device */
657 /* Device name: */
658 ret =
659 usb_string(cp->usbdev, AUSI_DEVICE, cp->dev_desc,
660 AUSI_DLEN - 1);
661 if (ret >= 0) {
662 u += ret;
663 /* Append Serial Number */
664 memcpy(&cp->dev_desc[u], ",Ser# ", 6);
665 u += 6;
666 ret =
667 usb_string(cp->usbdev, AUSI_SERIALNR, &cp->dev_desc[u],
668 AUSI_DLEN - u - 1);
669 if (ret >= 0) {
670 u += ret;
671 /* Append subscriber number */
672 memcpy(&cp->dev_desc[u], ", ", 2);
673 u += 2;
674 ret =
675 usb_string(cp->usbdev, AUSI_MSN,
676 &cp->dev_desc[u],
677 AUSI_DLEN - u - 1);
678 if (ret >= 0) {
679 u += ret;
680 }
681 }
682 }
683 cp->dev_desc[u] = '\0';
684 info("device is a %s", cp->dev_desc);
685
686 /* get the maximum allowed control transfer length */
687 pbuf = (char *) kmalloc(2, GFP_KERNEL); /* use an allocated buffer because of urb target */
688 if (!pbuf) {
689 err("out of memory");
690 goto pfail;
691 }
692 ret = usb_control_msg(cp->usbdev, /* pointer to device */
693 usb_rcvctrlpipe(cp->usbdev, 0), /* pipe to control endpoint */
694 AUV_GETINFO, /* USB message request value */
695 AUT_RREQ, /* USB message request type value */
696 0, /* USB message value */
697 AUDI_MBCTRANS, /* USB message index value */
698 pbuf, /* pointer to the receive buffer */
699 2, /* length of the buffer */
700 HZ * 2); /* time to wait for the message to complete before timing out */
701 if (ret == 2) {
702 cp->maxControlLength = le16_to_cpup(pbuf);
703 kfree(pbuf);
704 dbg("setup: max. allowed control transfersize is %d bytes",
705 cp->maxControlLength);
706 } else {
707 kfree(pbuf);
708 err("setup: getting max. allowed control transfer length failed with error %d", ret);
709 goto pfail;
710 }
711 /* allocate a chain for the control messages */
712 if (auerchain_setup(&cp->controlchain, AUCH_ELEMENTS)) {
713 err("out of memory");
714 goto pfail;
715 }
716
717 /* allocate buffers for control messages */
718 if (auerbuf_setup
719 (&cp->bufctl, AU_RBUFFERS * 2,
720 cp->maxControlLength + AUH_SIZE)) {
721 err("out of memory");
722 goto pfail;
723 }
724
725 /* start the interrupt endpoint */
726 if (auerswald_int_open(cp)) {
727 err("int endpoint failed");
728 goto pfail;
729 }
730
731 /* Try to connect to hisax interface */
732 if (auerisdn_probe(cp)) {
733 err("hisax connect failed");
734 goto pfail;
735 }
736
737 /* all OK */
738 return cp;
739
740 /* Error exit: clean up the memory */
741 pfail:auerswald_delete(cp);
742 MOD_DEC_USE_COUNT;
743 return NULL;
744 }
745
746
747 /* Disconnect driver from a served device
748
749 This function is called whenever a device which was served by this driver
750 is disconnected.
751
752 The argument dev specifies the device context and the driver_context
753 returns a pointer to the previously registered driver_context of the
754 probe function. After returning from the disconnect function the USB
755 framework completly deallocates all data structures associated with
756 this device. So especially the usb_device structure must not be used
757 any longer by the usb driver.
758 */
auerswald_disconnect(struct usb_device * usbdev,void * driver_context)759 static void auerswald_disconnect(struct usb_device *usbdev,
760 void *driver_context)
761 {
762 struct auerswald *cp = (struct auerswald *) driver_context;
763 unsigned int u;
764
765 /* all parallel tasks can react on disconnect ASAP */
766 cp->disconnecting = 1;
767 down(&cp->mutex);
768 info("device /dev/usb/%s now disconnecting", cp->name);
769
770 /* remove from device table */
771 /* Nobody can open() this device any more */
772 down(&auerdev_table_mutex);
773 auerdev_table[cp->dtindex] = NULL;
774 up(&auerdev_table_mutex);
775
776 /* remove our devfs node */
777 /* Nobody can see this device any more */
778 devfs_unregister(cp->devfs);
779
780 /* stop the ISDN connection */
781 auerisdn_disconnect(cp);
782
783 /* Stop the interrupt endpoint 0 */
784 auerswald_int_release(cp);
785
786 /* remove the control chain allocated in auerswald_probe
787 This has the benefit of
788 a) all pending (a)synchronous urbs are unlinked
789 b) all buffers dealing with urbs are reclaimed
790 */
791 auerchain_free(&cp->controlchain);
792
793 if (cp->open_count == 0) {
794 struct auerscon *scp;
795 /* nobody is using this device. So we can clean up now */
796 up(&cp->mutex); /* up() is possible here because no other task
797 can open the device (see above). I don't want
798 to kfree() a locked mutex. */
799 /* disconnect the D channel */
800 scp = cp->services[AUH_DCHANNEL];
801 if (scp)
802 scp->disconnect(scp);
803 auerswald_delete(cp);
804 } else {
805 /* device is used. Remove the pointer to the
806 usb device (it's not valid any more). The last
807 release() will do the clean up */
808 cp->usbdev = NULL;
809 up(&cp->mutex);
810 /* Terminate waiting writers */
811 wake_up(&cp->bufferwait);
812 /* Inform all waiting readers */
813 for (u = 0; u < AUH_TYPESIZE; u++) {
814 struct auerscon *scp = cp->services[u];
815 if (scp)
816 scp->disconnect(scp);
817 }
818 }
819
820 /* The device releases this module */
821 MOD_DEC_USE_COUNT;
822 }
823
824 /* Descriptor for the devices which are served by this driver.
825 NOTE: this struct is parsed by the usbmanager install scripts.
826 Don't change without caution!
827 */
828 static struct usb_device_id auerswald_ids[] = {
829 {USB_DEVICE(ID_AUERSWALD, 0x00C0)}, /* COMpact 2104 USB/DSL */
830 {USB_DEVICE(ID_AUERSWALD, 0x00DB)}, /* COMpact 4410/2206 USB */
831 {USB_DEVICE(ID_AUERSWALD, 0x00DC)}, /* COMpact 4406 DSL */
832 {USB_DEVICE(ID_AUERSWALD, 0x00DD)}, /* COMpact 2204 USB */
833 {USB_DEVICE(ID_AUERSWALD, 0x00F1)}, /* COMfort 2000 System Telephone */
834 {USB_DEVICE(ID_AUERSWALD, 0x00F2)}, /* COMfort 1200 System Telephone */
835 {} /* Terminating entry */
836 };
837
838 /* Standard module device table */
839 MODULE_DEVICE_TABLE(usb, auerswald_ids);
840
841 /* Standard usb driver struct */
842 static struct usb_driver auerswald_driver = {
843 name:"auerswald",
844 probe:auerswald_probe,
845 disconnect:auerswald_disconnect,
846 fops:&auerswald_fops,
847 minor:AUER_MINOR_BASE,
848 id_table:auerswald_ids,
849 };
850
851
852 /* --------------------------------------------------------------------- */
853 /* Module loading/unloading */
854
855 /* Driver initialisation. Called after module loading.
856 NOTE: there is no concurrency at _init
857 */
auerswald_init(void)858 static int __init auerswald_init(void)
859 {
860 int result;
861 dbg("init");
862
863 /* initialize the device table */
864 memset(&auerdev_table, 0, sizeof(auerdev_table));
865 init_MUTEX(&auerdev_table_mutex);
866 auerisdn_init();
867
868 /* register driver at the USB subsystem */
869 /* NOTE: usb_register() may call probe()! */
870 result = usb_register(&auerswald_driver);
871 if (result < 0) {
872 err("driver could not be registered");
873 return -1;
874 }
875 return 0;
876 }
877
878 /* Driver deinit. Called before module removal.
879 NOTE: there is no concurrency at _cleanup
880 */
auerswald_cleanup(void)881 static void __exit auerswald_cleanup(void)
882 {
883 dbg("cleanup");
884 auerisdn_cleanup();
885 usb_deregister(&auerswald_driver);
886 }
887
888 /* --------------------------------------------------------------------- */
889 /* Linux device driver module description */
890
891 MODULE_AUTHOR(DRIVER_AUTHOR);
892 MODULE_DESCRIPTION(DRIVER_DESC);
893 MODULE_LICENSE("GPL");
894
895 module_init(auerswald_init);
896 module_exit(auerswald_cleanup);
897
898 /* --------------------------------------------------------------------- */
899