2 * USB driver for Gigaset 307x base via direct USB connection.
4 * Copyright (c) 2001 by Hansjoerg Lipp <hjlipp@web.de>,
5 * Tilman Schmidt <tilman@imap.cc>,
8 * =====================================================================
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation; either version 2 of
12 * the License, or (at your option) any later version.
13 * =====================================================================
18 #include <linux/errno.h>
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <linux/timer.h>
22 #include <linux/usb.h>
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
26 /* Version Information */
27 #define DRIVER_AUTHOR "Tilman Schmidt <tilman@imap.cc>, Hansjoerg Lipp <hjlipp@web.de>, Stefan Eilers"
28 #define DRIVER_DESC "USB Driver for Gigaset 307x"
31 /* Module parameters */
33 static int startmode
= SM_ISDN
;
34 static int cidmode
= 1;
36 module_param(startmode
, int, S_IRUGO
);
37 module_param(cidmode
, int, S_IRUGO
);
38 MODULE_PARM_DESC(startmode
, "start in isdn4linux mode");
39 MODULE_PARM_DESC(cidmode
, "Call-ID mode");
41 #define GIGASET_MINORS 1
42 #define GIGASET_MINOR 16
43 #define GIGASET_MODULENAME "bas_gigaset"
44 #define GIGASET_DEVNAME "ttyGB"
46 /* length limit according to Siemens 3070usb-protokoll.doc ch. 2.1 */
47 #define IF_WRITEBUF 264
49 /* Values for the Gigaset 307x */
50 #define USB_GIGA_VENDOR_ID 0x0681
51 #define USB_3070_PRODUCT_ID 0x0001
52 #define USB_3075_PRODUCT_ID 0x0002
53 #define USB_SX303_PRODUCT_ID 0x0021
54 #define USB_SX353_PRODUCT_ID 0x0022
56 /* table of devices that work with this driver */
57 static struct usb_device_id gigaset_table
[] = {
58 { USB_DEVICE(USB_GIGA_VENDOR_ID
, USB_3070_PRODUCT_ID
) },
59 { USB_DEVICE(USB_GIGA_VENDOR_ID
, USB_3075_PRODUCT_ID
) },
60 { USB_DEVICE(USB_GIGA_VENDOR_ID
, USB_SX303_PRODUCT_ID
) },
61 { USB_DEVICE(USB_GIGA_VENDOR_ID
, USB_SX353_PRODUCT_ID
) },
62 { } /* Terminating entry */
65 MODULE_DEVICE_TABLE(usb
, gigaset_table
);
67 /*======================= local function prototypes ==========================*/
69 /* function called if a new device belonging to this driver is connected */
70 static int gigaset_probe(struct usb_interface
*interface
,
71 const struct usb_device_id
*id
);
73 /* Function will be called if the device is unplugged */
74 static void gigaset_disconnect(struct usb_interface
*interface
);
76 static int atread_submit(struct cardstate
*, int);
77 static void stopurbs(struct bas_bc_state
*);
78 static int req_submit(struct bc_state
*, int, int, int);
79 static int atwrite_submit(struct cardstate
*, unsigned char *, int);
80 static int start_cbsend(struct cardstate
*);
82 /*============================================================================*/
84 struct bas_cardstate
{
85 struct usb_device
*udev
; /* USB device pointer */
86 struct usb_interface
*interface
; /* interface for this device */
87 unsigned char minor
; /* starting minor number */
89 struct urb
*urb_ctrl
; /* control pipe default URB */
90 struct usb_ctrlrequest dr_ctrl
;
91 struct timer_list timer_ctrl
; /* control request timeout */
94 struct timer_list timer_atrdy
; /* AT command ready timeout */
95 struct urb
*urb_cmd_out
; /* for sending AT commands */
96 struct usb_ctrlrequest dr_cmd_out
;
99 struct urb
*urb_cmd_in
; /* for receiving AT replies */
100 struct usb_ctrlrequest dr_cmd_in
;
101 struct timer_list timer_cmd_in
; /* receive request timeout */
102 unsigned char *rcvbuf
; /* AT reply receive buffer */
104 struct urb
*urb_int_in
; /* URB for interrupt pipe */
105 unsigned char int_in_buf
[3];
107 spinlock_t lock
; /* locks all following */
108 atomic_t basstate
; /* bitmap (BS_*) */
109 int pending
; /* uncompleted base request */
110 int rcvbuf_size
; /* size of AT receive buffer */
111 /* 0: no receive in progress */
112 int retry_cmd_in
; /* receive req retry count */
115 /* status of direct USB connection to 307x base (bits in basstate) */
116 #define BS_ATOPEN 0x001 /* AT channel open */
117 #define BS_B1OPEN 0x002 /* B channel 1 open */
118 #define BS_B2OPEN 0x004 /* B channel 2 open */
119 #define BS_ATREADY 0x008 /* base ready for AT command */
120 #define BS_INIT 0x010 /* base has signalled INIT_OK */
121 #define BS_ATTIMER 0x020 /* waiting for HD_READY_SEND_ATDATA */
122 #define BS_ATRDPEND 0x040 /* urb_cmd_in in use */
123 #define BS_ATWRPEND 0x080 /* urb_cmd_out in use */
126 static struct gigaset_driver
*driver
= NULL
;
127 static struct cardstate
*cardstate
= NULL
;
129 /* usb specific object needed to register this driver with the usb subsystem */
130 static struct usb_driver gigaset_usb_driver
= {
131 .name
= GIGASET_MODULENAME
,
132 .probe
= gigaset_probe
,
133 .disconnect
= gigaset_disconnect
,
134 .id_table
= gigaset_table
,
137 /* get message text for usb_submit_urb return code
139 static char *get_usb_rcmsg(int rc
)
141 static char unkmsg
[28];
147 return "out of memory";
149 return "device not present";
151 return "endpoint not present";
153 return "URB type not supported";
155 return "invalid argument";
157 return "start frame too early or too much scheduled";
159 return "too many isochronous frames requested";
161 return "endpoint stalled";
163 return "invalid packet size";
165 return "would overcommit USB bandwidth";
167 return "device shut down";
169 return "reject flag set";
171 return "device suspended";
173 snprintf(unkmsg
, sizeof(unkmsg
), "unknown error %d", rc
);
178 /* get message text for USB status code
180 static char *get_usb_statmsg(int status
)
182 static char unkmsg
[28];
188 return "unlinked (sync)";
192 return "bit stuffing error, timeout, or unknown USB error";
194 return "CRC mismatch, timeout, or unknown USB error";
198 return "endpoint stalled";
200 return "IN buffer overrun";
202 return "OUT buffer underrun";
204 return "too much data";
206 return "short packet detected";
208 return "device removed";
210 return "partial isochronous transfer";
212 return "invalid argument";
214 return "unlinked (async)";
216 return "device shut down";
218 snprintf(unkmsg
, sizeof(unkmsg
), "unknown status %d", status
);
224 * retrieve string representation of USB pipe type
226 static inline char *usb_pipetype_str(int pipe
)
228 if (usb_pipeisoc(pipe
))
230 if (usb_pipeint(pipe
))
232 if (usb_pipecontrol(pipe
))
234 if (usb_pipebulk(pipe
))
240 * write content of URB to syslog for debugging
242 static inline void dump_urb(enum debuglevel level
, const char *tag
,
245 #ifdef CONFIG_GIGASET_DEBUG
247 gig_dbg(level
, "%s urb(0x%08lx)->{", tag
, (unsigned long) urb
);
250 " dev=0x%08lx, pipe=%s:EP%d/DV%d:%s, "
251 "status=%d, hcpriv=0x%08lx, transfer_flags=0x%x,",
252 (unsigned long) urb
->dev
,
253 usb_pipetype_str(urb
->pipe
),
254 usb_pipeendpoint(urb
->pipe
), usb_pipedevice(urb
->pipe
),
255 usb_pipein(urb
->pipe
) ? "in" : "out",
256 urb
->status
, (unsigned long) urb
->hcpriv
,
257 urb
->transfer_flags
);
259 " transfer_buffer=0x%08lx[%d], actual_length=%d, "
260 "bandwidth=%d, setup_packet=0x%08lx,",
261 (unsigned long) urb
->transfer_buffer
,
262 urb
->transfer_buffer_length
, urb
->actual_length
,
263 urb
->bandwidth
, (unsigned long) urb
->setup_packet
);
265 " start_frame=%d, number_of_packets=%d, interval=%d, "
267 urb
->start_frame
, urb
->number_of_packets
, urb
->interval
,
270 " context=0x%08lx, complete=0x%08lx, "
271 "iso_frame_desc[]={",
272 (unsigned long) urb
->context
,
273 (unsigned long) urb
->complete
);
274 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
275 struct usb_iso_packet_descriptor
*pifd
276 = &urb
->iso_frame_desc
[i
];
278 " {offset=%u, length=%u, actual_length=%u, "
280 pifd
->offset
, pifd
->length
, pifd
->actual_length
,
284 gig_dbg(level
, "}}");
288 /* read/set modem control bits etc. (m10x only) */
289 static int gigaset_set_modem_ctrl(struct cardstate
*cs
, unsigned old_state
,
295 static int gigaset_baud_rate(struct cardstate
*cs
, unsigned cflag
)
300 static int gigaset_set_line_ctrl(struct cardstate
*cs
, unsigned cflag
)
306 * hang up any existing connection because of an unrecoverable error
307 * This function may be called from any context and takes care of scheduling
308 * the necessary actions for execution outside of interrupt context.
309 * cs->lock must not be held.
311 * B channel control structure
313 static inline void error_hangup(struct bc_state
*bcs
)
315 struct cardstate
*cs
= bcs
->cs
;
317 gig_dbg(DEBUG_ANY
, "%s: scheduling HUP for channel %d",
318 __func__
, bcs
->channel
);
320 if (!gigaset_add_event(cs
, &bcs
->at_state
, EV_HUP
, NULL
, 0, NULL
))
321 dev_err(cs
->dev
, "event queue full\n");
323 gigaset_schedule_event(cs
);
327 * reset Gigaset device because of an unrecoverable error
328 * This function may be called from any context, and takes care of
329 * scheduling the necessary actions for execution outside of interrupt context.
330 * cs->lock must not be held.
332 * controller state structure
334 static inline void error_reset(struct cardstate
*cs
)
336 /* close AT command channel to recover (ignore errors) */
337 req_submit(cs
->bcs
, HD_CLOSE_ATCHANNEL
, 0, BAS_TIMEOUT
);
339 //FIXME try to recover without bothering the user
341 "unrecoverable error - please disconnect Gigaset base to reset\n");
345 * check for completion of pending control request
347 * ucs hardware specific controller state structure
349 static void check_pending(struct bas_cardstate
*ucs
)
353 spin_lock_irqsave(&ucs
->lock
, flags
);
354 switch (ucs
->pending
) {
357 case HD_OPEN_ATCHANNEL
:
358 if (atomic_read(&ucs
->basstate
) & BS_ATOPEN
)
361 case HD_OPEN_B1CHANNEL
:
362 if (atomic_read(&ucs
->basstate
) & BS_B1OPEN
)
365 case HD_OPEN_B2CHANNEL
:
366 if (atomic_read(&ucs
->basstate
) & BS_B2OPEN
)
369 case HD_CLOSE_ATCHANNEL
:
370 if (!(atomic_read(&ucs
->basstate
) & BS_ATOPEN
))
373 case HD_CLOSE_B1CHANNEL
:
374 if (!(atomic_read(&ucs
->basstate
) & BS_B1OPEN
))
377 case HD_CLOSE_B2CHANNEL
:
378 if (!(atomic_read(&ucs
->basstate
) & BS_B2OPEN
))
381 case HD_DEVICE_INIT_ACK
: /* no reply expected */
384 /* HD_READ_ATMESSAGE, HD_WRITE_ATMESSAGE, HD_RESET_INTERRUPTPIPE
385 * are handled separately and should never end up here
388 dev_warn(&ucs
->interface
->dev
,
389 "unknown pending request 0x%02x cleared\n",
395 del_timer(&ucs
->timer_ctrl
);
397 spin_unlock_irqrestore(&ucs
->lock
, flags
);
401 * timeout routine for command input request
403 * controller state structure
405 static void cmd_in_timeout(unsigned long data
)
407 struct cardstate
*cs
= (struct cardstate
*) data
;
408 struct bas_cardstate
*ucs
= cs
->hw
.bas
;
411 if (!ucs
->rcvbuf_size
) {
412 gig_dbg(DEBUG_USBREQ
, "%s: no receive in progress", __func__
);
416 if (ucs
->retry_cmd_in
++ < BAS_RETRY
) {
417 dev_notice(cs
->dev
, "control read: timeout, retry %d\n",
419 rc
= atread_submit(cs
, BAS_TIMEOUT
);
420 if (rc
>= 0 || rc
== -ENODEV
)
421 /* resubmitted or disconnected */
422 /* - bypass regular exit block */
426 "control read: timeout, giving up after %d tries\n",
431 ucs
->rcvbuf_size
= 0;
435 /* set/clear bits in base connection state, return previous state
437 inline static int update_basstate(struct bas_cardstate
*ucs
,
443 spin_lock_irqsave(&ucs
->lock
, flags
);
444 state
= atomic_read(&ucs
->basstate
);
445 atomic_set(&ucs
->basstate
, (state
& ~clear
) | set
);
446 spin_unlock_irqrestore(&ucs
->lock
, flags
);
450 /* read_ctrl_callback
451 * USB completion handler for control pipe input
452 * called by the USB subsystem in interrupt context
454 * urb USB request block
455 * urb->context = inbuf structure for controller state
457 static void read_ctrl_callback(struct urb
*urb
)
459 struct inbuf_t
*inbuf
= urb
->context
;
460 struct cardstate
*cs
= inbuf
->cs
;
461 struct bas_cardstate
*ucs
= cs
->hw
.bas
;
466 update_basstate(ucs
, 0, BS_ATRDPEND
);
468 if (!ucs
->rcvbuf_size
) {
469 dev_warn(cs
->dev
, "%s: no receive in progress\n", __func__
);
473 del_timer(&ucs
->timer_cmd_in
);
475 switch (urb
->status
) {
476 case 0: /* normal completion */
477 numbytes
= urb
->actual_length
;
478 if (unlikely(numbytes
!= ucs
->rcvbuf_size
)) {
480 "control read: received %d chars, expected %d\n",
481 numbytes
, ucs
->rcvbuf_size
);
482 if (numbytes
> ucs
->rcvbuf_size
)
483 numbytes
= ucs
->rcvbuf_size
;
486 /* copy received bytes to inbuf */
487 have_data
= gigaset_fill_inbuf(inbuf
, ucs
->rcvbuf
, numbytes
);
489 if (unlikely(numbytes
< ucs
->rcvbuf_size
)) {
490 /* incomplete - resubmit for remaining bytes */
491 ucs
->rcvbuf_size
-= numbytes
;
492 ucs
->retry_cmd_in
= 0;
493 rc
= atread_submit(cs
, BAS_TIMEOUT
);
494 if (rc
>= 0 || rc
== -ENODEV
)
495 /* resubmitted or disconnected */
496 /* - bypass regular exit block */
502 case -ENOENT
: /* cancelled */
503 case -ECONNRESET
: /* cancelled (async) */
504 case -EINPROGRESS
: /* pending */
505 case -ENODEV
: /* device removed */
506 case -ESHUTDOWN
: /* device shut down */
507 /* no action necessary */
508 gig_dbg(DEBUG_USBREQ
, "%s: %s",
509 __func__
, get_usb_statmsg(urb
->status
));
512 default: /* severe trouble */
513 dev_warn(cs
->dev
, "control read: %s\n",
514 get_usb_statmsg(urb
->status
));
515 if (ucs
->retry_cmd_in
++ < BAS_RETRY
) {
516 dev_notice(cs
->dev
, "control read: retry %d\n",
518 rc
= atread_submit(cs
, BAS_TIMEOUT
);
519 if (rc
>= 0 || rc
== -ENODEV
)
520 /* resubmitted or disconnected */
521 /* - bypass regular exit block */
525 "control read: giving up after %d tries\n",
533 ucs
->rcvbuf_size
= 0;
535 gig_dbg(DEBUG_INTR
, "%s-->BH", __func__
);
536 gigaset_schedule_event(cs
);
541 * submit an HD_READ_ATMESSAGE command URB and optionally start a timeout
543 * cs controller state structure
544 * timeout timeout in 1/10 sec., 0: none
547 * -EBUSY if another request is pending
548 * any URB submission error code
550 static int atread_submit(struct cardstate
*cs
, int timeout
)
552 struct bas_cardstate
*ucs
= cs
->hw
.bas
;
555 gig_dbg(DEBUG_USBREQ
, "-------> HD_READ_ATMESSAGE (%d)",
558 if (update_basstate(ucs
, BS_ATRDPEND
, 0) & BS_ATRDPEND
) {
560 "could not submit HD_READ_ATMESSAGE: URB busy\n");
564 ucs
->dr_cmd_in
.bRequestType
= IN_VENDOR_REQ
;
565 ucs
->dr_cmd_in
.bRequest
= HD_READ_ATMESSAGE
;
566 ucs
->dr_cmd_in
.wValue
= 0;
567 ucs
->dr_cmd_in
.wIndex
= 0;
568 ucs
->dr_cmd_in
.wLength
= cpu_to_le16(ucs
->rcvbuf_size
);
569 usb_fill_control_urb(ucs
->urb_cmd_in
, ucs
->udev
,
570 usb_rcvctrlpipe(ucs
->udev
, 0),
571 (unsigned char*) & ucs
->dr_cmd_in
,
572 ucs
->rcvbuf
, ucs
->rcvbuf_size
,
573 read_ctrl_callback
, cs
->inbuf
);
575 if ((ret
= usb_submit_urb(ucs
->urb_cmd_in
, SLAB_ATOMIC
)) != 0) {
576 update_basstate(ucs
, 0, BS_ATRDPEND
);
577 dev_err(cs
->dev
, "could not submit HD_READ_ATMESSAGE: %s\n",
583 gig_dbg(DEBUG_USBREQ
, "setting timeout of %d/10 secs", timeout
);
584 ucs
->timer_cmd_in
.expires
= jiffies
+ timeout
* HZ
/ 10;
585 ucs
->timer_cmd_in
.data
= (unsigned long) cs
;
586 ucs
->timer_cmd_in
.function
= cmd_in_timeout
;
587 add_timer(&ucs
->timer_cmd_in
);
593 * USB completion handler for interrupt pipe input
594 * called by the USB subsystem in interrupt context
596 * urb USB request block
597 * urb->context = controller state structure
599 static void read_int_callback(struct urb
*urb
)
601 struct cardstate
*cs
= urb
->context
;
602 struct bas_cardstate
*ucs
= cs
->hw
.bas
;
603 struct bc_state
*bcs
;
609 switch (urb
->status
) {
610 case 0: /* success */
612 case -ENOENT
: /* cancelled */
613 case -ECONNRESET
: /* cancelled (async) */
614 case -EINPROGRESS
: /* pending */
615 /* ignore silently */
616 gig_dbg(DEBUG_USBREQ
, "%s: %s",
617 __func__
, get_usb_statmsg(urb
->status
));
619 case -ENODEV
: /* device removed */
620 case -ESHUTDOWN
: /* device shut down */
621 //FIXME use this as disconnect indicator?
622 gig_dbg(DEBUG_USBREQ
, "%s: device disconnected", __func__
);
624 default: /* severe trouble */
625 dev_warn(cs
->dev
, "interrupt read: %s\n",
626 get_usb_statmsg(urb
->status
));
627 //FIXME corrective action? resubmission always ok?
631 /* drop incomplete packets even if the missing bytes wouldn't matter */
632 if (unlikely(urb
->actual_length
< 3)) {
633 dev_warn(cs
->dev
, "incomplete interrupt packet (%d bytes)\n",
638 l
= (unsigned) ucs
->int_in_buf
[1] +
639 (((unsigned) ucs
->int_in_buf
[2]) << 8);
641 gig_dbg(DEBUG_USBREQ
, "<-------%d: 0x%02x (%u [0x%02x 0x%02x])",
642 urb
->actual_length
, (int)ucs
->int_in_buf
[0], l
,
643 (int)ucs
->int_in_buf
[1], (int)ucs
->int_in_buf
[2]);
647 switch (ucs
->int_in_buf
[0]) {
648 case HD_DEVICE_INIT_OK
:
649 update_basstate(ucs
, BS_INIT
, 0);
652 case HD_READY_SEND_ATDATA
:
653 del_timer(&ucs
->timer_atrdy
);
654 update_basstate(ucs
, BS_ATREADY
, BS_ATTIMER
);
658 case HD_OPEN_B2CHANNEL_ACK
:
660 case HD_OPEN_B1CHANNEL_ACK
:
661 bcs
= cs
->bcs
+ channel
;
662 update_basstate(ucs
, BS_B1OPEN
<< channel
, 0);
663 gigaset_bchannel_up(bcs
);
666 case HD_OPEN_ATCHANNEL_ACK
:
667 update_basstate(ucs
, BS_ATOPEN
, 0);
671 case HD_CLOSE_B2CHANNEL_ACK
:
673 case HD_CLOSE_B1CHANNEL_ACK
:
674 bcs
= cs
->bcs
+ channel
;
675 update_basstate(ucs
, 0, BS_B1OPEN
<< channel
);
676 stopurbs(bcs
->hw
.bas
);
677 gigaset_bchannel_down(bcs
);
680 case HD_CLOSE_ATCHANNEL_ACK
:
681 update_basstate(ucs
, 0, BS_ATOPEN
);
684 case HD_B2_FLOW_CONTROL
:
686 case HD_B1_FLOW_CONTROL
:
687 bcs
= cs
->bcs
+ channel
;
688 atomic_add((l
- BAS_NORMFRAME
) * BAS_CORRFRAMES
,
689 &bcs
->hw
.bas
->corrbytes
);
691 "Flow control (channel %d, sub %d): 0x%02x => %d",
692 channel
, bcs
->hw
.bas
->numsub
, l
,
693 atomic_read(&bcs
->hw
.bas
->corrbytes
));
696 case HD_RECEIVEATDATA_ACK
: /* AT response ready to be received */
699 "HD_RECEIVEATDATA_ACK with length 0 ignored\n");
702 spin_lock_irqsave(&cs
->lock
, flags
);
703 if (ucs
->rcvbuf_size
) {
704 /* throw away previous buffer - we have no queue */
706 "receive AT data overrun, %d bytes lost\n",
709 ucs
->rcvbuf_size
= 0;
711 if ((ucs
->rcvbuf
= kmalloc(l
, GFP_ATOMIC
)) == NULL
) {
712 spin_unlock_irqrestore(&cs
->lock
, flags
);
713 dev_err(cs
->dev
, "out of memory receiving AT data\n");
717 ucs
->rcvbuf_size
= l
;
718 ucs
->retry_cmd_in
= 0;
719 if ((rc
= atread_submit(cs
, BAS_TIMEOUT
)) < 0) {
722 ucs
->rcvbuf_size
= 0;
724 //FIXME corrective action?
725 spin_unlock_irqrestore(&cs
->lock
, flags
);
730 spin_unlock_irqrestore(&cs
->lock
, flags
);
733 case HD_RESET_INTERRUPT_PIPE_ACK
:
734 gig_dbg(DEBUG_USBREQ
, "HD_RESET_INTERRUPT_PIPE_ACK");
738 gig_dbg(DEBUG_USBREQ
, "HD_SUSPEND_END");
743 "unknown Gigaset signal 0x%02x (%u) ignored\n",
744 (int) ucs
->int_in_buf
[0], l
);
750 rc
= usb_submit_urb(urb
, SLAB_ATOMIC
);
751 if (unlikely(rc
!= 0 && rc
!= -ENODEV
)) {
752 dev_err(cs
->dev
, "could not resubmit interrupt URB: %s\n",
759 * USB completion handler for B channel isochronous input
760 * called by the USB subsystem in interrupt context
762 * urb USB request block of completed request
763 * urb->context = bc_state structure
765 static void read_iso_callback(struct urb
*urb
)
767 struct bc_state
*bcs
;
768 struct bas_bc_state
*ubc
;
772 /* status codes not worth bothering the tasklet with */
773 if (unlikely(urb
->status
== -ENOENT
||
774 urb
->status
== -ECONNRESET
||
775 urb
->status
== -EINPROGRESS
||
776 urb
->status
== -ENODEV
||
777 urb
->status
== -ESHUTDOWN
)) {
778 gig_dbg(DEBUG_ISO
, "%s: %s",
779 __func__
, get_usb_statmsg(urb
->status
));
786 spin_lock_irqsave(&ubc
->isoinlock
, flags
);
787 if (likely(ubc
->isoindone
== NULL
)) {
788 /* pass URB to tasklet */
789 ubc
->isoindone
= urb
;
790 tasklet_schedule(&ubc
->rcvd_tasklet
);
792 /* tasklet still busy, drop data and resubmit URB */
793 ubc
->loststatus
= urb
->status
;
794 for (i
= 0; i
< BAS_NUMFRAMES
; i
++) {
795 ubc
->isoinlost
+= urb
->iso_frame_desc
[i
].actual_length
;
796 if (unlikely(urb
->iso_frame_desc
[i
].status
!= 0 &&
797 urb
->iso_frame_desc
[i
].status
!=
799 ubc
->loststatus
= urb
->iso_frame_desc
[i
].status
;
800 urb
->iso_frame_desc
[i
].status
= 0;
801 urb
->iso_frame_desc
[i
].actual_length
= 0;
803 if (likely(atomic_read(&ubc
->running
))) {
804 /* urb->dev is clobbered by USB subsystem */
805 urb
->dev
= bcs
->cs
->hw
.bas
->udev
;
806 urb
->transfer_flags
= URB_ISO_ASAP
;
807 urb
->number_of_packets
= BAS_NUMFRAMES
;
808 gig_dbg(DEBUG_ISO
, "%s: isoc read overrun/resubmit",
810 rc
= usb_submit_urb(urb
, SLAB_ATOMIC
);
811 if (unlikely(rc
!= 0 && rc
!= -ENODEV
)) {
812 dev_err(bcs
->cs
->dev
,
813 "could not resubmit isochronous read "
814 "URB: %s\n", get_usb_rcmsg(rc
));
815 dump_urb(DEBUG_ISO
, "isoc read", urb
);
820 spin_unlock_irqrestore(&ubc
->isoinlock
, flags
);
823 /* write_iso_callback
824 * USB completion handler for B channel isochronous output
825 * called by the USB subsystem in interrupt context
827 * urb USB request block of completed request
828 * urb->context = isow_urbctx_t structure
830 static void write_iso_callback(struct urb
*urb
)
832 struct isow_urbctx_t
*ucx
;
833 struct bas_bc_state
*ubc
;
836 /* status codes not worth bothering the tasklet with */
837 if (unlikely(urb
->status
== -ENOENT
||
838 urb
->status
== -ECONNRESET
||
839 urb
->status
== -EINPROGRESS
||
840 urb
->status
== -ENODEV
||
841 urb
->status
== -ESHUTDOWN
)) {
842 gig_dbg(DEBUG_ISO
, "%s: %s",
843 __func__
, get_usb_statmsg(urb
->status
));
847 /* pass URB context to tasklet */
849 ubc
= ucx
->bcs
->hw
.bas
;
851 spin_lock_irqsave(&ubc
->isooutlock
, flags
);
852 ubc
->isooutovfl
= ubc
->isooutdone
;
853 ubc
->isooutdone
= ucx
;
854 spin_unlock_irqrestore(&ubc
->isooutlock
, flags
);
855 tasklet_schedule(&ubc
->sent_tasklet
);
859 * prepare and submit USB request blocks for isochronous input and output
861 * B channel control structure
864 * < 0 on error (no URBs submitted)
866 static int starturbs(struct bc_state
*bcs
)
868 struct bas_bc_state
*ubc
= bcs
->hw
.bas
;
873 /* initialize L2 reception */
874 if (bcs
->proto2
== ISDN_PROTO_L2_HDLC
)
875 bcs
->inputstate
|= INS_flag_hunt
;
877 /* submit all isochronous input URBs */
878 atomic_set(&ubc
->running
, 1);
879 for (k
= 0; k
< BAS_INURBS
; k
++) {
880 urb
= ubc
->isoinurbs
[k
];
886 urb
->dev
= bcs
->cs
->hw
.bas
->udev
;
887 urb
->pipe
= usb_rcvisocpipe(urb
->dev
, 3 + 2 * bcs
->channel
);
888 urb
->transfer_flags
= URB_ISO_ASAP
;
889 urb
->transfer_buffer
= ubc
->isoinbuf
+ k
* BAS_INBUFSIZE
;
890 urb
->transfer_buffer_length
= BAS_INBUFSIZE
;
891 urb
->number_of_packets
= BAS_NUMFRAMES
;
892 urb
->interval
= BAS_FRAMETIME
;
893 urb
->complete
= read_iso_callback
;
895 for (j
= 0; j
< BAS_NUMFRAMES
; j
++) {
896 urb
->iso_frame_desc
[j
].offset
= j
* BAS_MAXFRAME
;
897 urb
->iso_frame_desc
[j
].length
= BAS_MAXFRAME
;
898 urb
->iso_frame_desc
[j
].status
= 0;
899 urb
->iso_frame_desc
[j
].actual_length
= 0;
902 dump_urb(DEBUG_ISO
, "Initial isoc read", urb
);
903 if ((rc
= usb_submit_urb(urb
, SLAB_ATOMIC
)) != 0)
907 /* initialize L2 transmission */
908 gigaset_isowbuf_init(ubc
->isooutbuf
, PPP_FLAG
);
910 /* set up isochronous output URBs for flag idling */
911 for (k
= 0; k
< BAS_OUTURBS
; ++k
) {
912 urb
= ubc
->isoouturbs
[k
].urb
;
917 urb
->dev
= bcs
->cs
->hw
.bas
->udev
;
918 urb
->pipe
= usb_sndisocpipe(urb
->dev
, 4 + 2 * bcs
->channel
);
919 urb
->transfer_flags
= URB_ISO_ASAP
;
920 urb
->transfer_buffer
= ubc
->isooutbuf
->data
;
921 urb
->transfer_buffer_length
= sizeof(ubc
->isooutbuf
->data
);
922 urb
->number_of_packets
= BAS_NUMFRAMES
;
923 urb
->interval
= BAS_FRAMETIME
;
924 urb
->complete
= write_iso_callback
;
925 urb
->context
= &ubc
->isoouturbs
[k
];
926 for (j
= 0; j
< BAS_NUMFRAMES
; ++j
) {
927 urb
->iso_frame_desc
[j
].offset
= BAS_OUTBUFSIZE
;
928 urb
->iso_frame_desc
[j
].length
= BAS_NORMFRAME
;
929 urb
->iso_frame_desc
[j
].status
= 0;
930 urb
->iso_frame_desc
[j
].actual_length
= 0;
932 ubc
->isoouturbs
[k
].limit
= -1;
935 /* submit two URBs, keep third one */
936 for (k
= 0; k
< 2; ++k
) {
937 dump_urb(DEBUG_ISO
, "Initial isoc write", urb
);
938 rc
= usb_submit_urb(ubc
->isoouturbs
[k
].urb
, SLAB_ATOMIC
);
942 dump_urb(DEBUG_ISO
, "Initial isoc write (free)", urb
);
943 ubc
->isooutfree
= &ubc
->isoouturbs
[2];
944 ubc
->isooutdone
= ubc
->isooutovfl
= NULL
;
952 * cancel the USB request blocks for isochronous input and output
953 * errors are silently ignored
955 * B channel control structure
957 static void stopurbs(struct bas_bc_state
*ubc
)
961 atomic_set(&ubc
->running
, 0);
963 for (k
= 0; k
< BAS_INURBS
; ++k
) {
964 rc
= usb_unlink_urb(ubc
->isoinurbs
[k
]);
966 "%s: isoc input URB %d unlinked, result = %s",
967 __func__
, k
, get_usb_rcmsg(rc
));
970 for (k
= 0; k
< BAS_OUTURBS
; ++k
) {
971 rc
= usb_unlink_urb(ubc
->isoouturbs
[k
].urb
);
973 "%s: isoc output URB %d unlinked, result = %s",
974 __func__
, k
, get_usb_rcmsg(rc
));
978 /* Isochronous Write - Bottom Half */
979 /* =============================== */
981 /* submit_iso_write_urb
982 * fill and submit the next isochronous write URB
984 * ucx context structure containing URB
986 * number of frames submitted in URB
987 * 0 if URB not submitted because no data available (isooutbuf busy)
988 * error code < 0 on error
990 static int submit_iso_write_urb(struct isow_urbctx_t
*ucx
)
992 struct urb
*urb
= ucx
->urb
;
993 struct bas_bc_state
*ubc
= ucx
->bcs
->hw
.bas
;
994 struct usb_iso_packet_descriptor
*ifd
;
995 int corrbytes
, nframe
, rc
;
997 /* urb->dev is clobbered by USB subsystem */
998 urb
->dev
= ucx
->bcs
->cs
->hw
.bas
->udev
;
999 urb
->transfer_flags
= URB_ISO_ASAP
;
1000 urb
->transfer_buffer
= ubc
->isooutbuf
->data
;
1001 urb
->transfer_buffer_length
= sizeof(ubc
->isooutbuf
->data
);
1003 for (nframe
= 0; nframe
< BAS_NUMFRAMES
; nframe
++) {
1004 ifd
= &urb
->iso_frame_desc
[nframe
];
1006 /* compute frame length according to flow control */
1007 ifd
->length
= BAS_NORMFRAME
;
1008 if ((corrbytes
= atomic_read(&ubc
->corrbytes
)) != 0) {
1009 gig_dbg(DEBUG_ISO
, "%s: corrbytes=%d",
1010 __func__
, corrbytes
);
1011 if (corrbytes
> BAS_HIGHFRAME
- BAS_NORMFRAME
)
1012 corrbytes
= BAS_HIGHFRAME
- BAS_NORMFRAME
;
1013 else if (corrbytes
< BAS_LOWFRAME
- BAS_NORMFRAME
)
1014 corrbytes
= BAS_LOWFRAME
- BAS_NORMFRAME
;
1015 ifd
->length
+= corrbytes
;
1016 atomic_add(-corrbytes
, &ubc
->corrbytes
);
1019 /* retrieve block of data to send */
1020 ifd
->offset
= gigaset_isowbuf_getbytes(ubc
->isooutbuf
,
1022 if (ifd
->offset
< 0) {
1023 if (ifd
->offset
== -EBUSY
) {
1025 "%s: buffer busy at frame %d",
1027 /* tasklet will be restarted from
1028 gigaset_send_skb() */
1030 dev_err(ucx
->bcs
->cs
->dev
,
1031 "%s: buffer error %d at frame %d\n",
1032 __func__
, ifd
->offset
, nframe
);
1037 ucx
->limit
= atomic_read(&ubc
->isooutbuf
->nextread
);
1039 ifd
->actual_length
= 0;
1041 if (unlikely(nframe
== 0))
1042 return 0; /* no data to send */
1043 urb
->number_of_packets
= nframe
;
1045 rc
= usb_submit_urb(urb
, SLAB_ATOMIC
);
1048 /* device removed - give up silently */
1049 gig_dbg(DEBUG_ISO
, "%s: disconnected", __func__
);
1051 dev_err(ucx
->bcs
->cs
->dev
,
1052 "could not submit isochronous write URB: %s\n",
1060 /* write_iso_tasklet
1061 * tasklet scheduled when an isochronous output URB from the Gigaset device
1064 * data B channel state structure
1066 static void write_iso_tasklet(unsigned long data
)
1068 struct bc_state
*bcs
= (struct bc_state
*) data
;
1069 struct bas_bc_state
*ubc
= bcs
->hw
.bas
;
1070 struct cardstate
*cs
= bcs
->cs
;
1071 struct isow_urbctx_t
*done
, *next
, *ovfl
;
1073 struct usb_iso_packet_descriptor
*ifd
;
1075 unsigned long flags
;
1077 struct sk_buff
*skb
;
1081 /* loop while completed URBs arrive in time */
1083 if (unlikely(!(atomic_read(&ubc
->running
)))) {
1084 gig_dbg(DEBUG_ISO
, "%s: not running", __func__
);
1088 /* retrieve completed URBs */
1089 spin_lock_irqsave(&ubc
->isooutlock
, flags
);
1090 done
= ubc
->isooutdone
;
1091 ubc
->isooutdone
= NULL
;
1092 ovfl
= ubc
->isooutovfl
;
1093 ubc
->isooutovfl
= NULL
;
1094 spin_unlock_irqrestore(&ubc
->isooutlock
, flags
);
1096 dev_err(cs
->dev
, "isochronous write buffer underrun\n");
1103 /* submit free URB if available */
1104 spin_lock_irqsave(&ubc
->isooutlock
, flags
);
1105 next
= ubc
->isooutfree
;
1106 ubc
->isooutfree
= NULL
;
1107 spin_unlock_irqrestore(&ubc
->isooutlock
, flags
);
1109 rc
= submit_iso_write_urb(next
);
1110 if (unlikely(rc
<= 0 && rc
!= -ENODEV
)) {
1111 /* could not submit URB, put it back */
1112 spin_lock_irqsave(&ubc
->isooutlock
, flags
);
1113 if (ubc
->isooutfree
== NULL
) {
1114 ubc
->isooutfree
= next
;
1117 spin_unlock_irqrestore(&ubc
->isooutlock
, flags
);
1119 /* couldn't put it back */
1121 "losing isochronous write URB\n");
1127 /* process completed URB */
1129 switch (urb
->status
) {
1130 case -EXDEV
: /* partial completion */
1131 gig_dbg(DEBUG_ISO
, "%s: URB partially completed",
1133 /* fall through - what's the difference anyway? */
1134 case 0: /* normal completion */
1135 /* inspect individual frames
1136 * assumptions (for lack of documentation):
1137 * - actual_length bytes of first frame in error are
1139 * - all following frames are not sent at all
1141 offset
= done
->limit
; /* default (no error) */
1142 for (i
= 0; i
< BAS_NUMFRAMES
; i
++) {
1143 ifd
= &urb
->iso_frame_desc
[i
];
1145 ifd
->actual_length
!= ifd
->length
) {
1147 "isochronous write: frame %d: %s, "
1148 "only %d of %d bytes sent\n",
1149 i
, get_usb_statmsg(ifd
->status
),
1150 ifd
->actual_length
, ifd
->length
);
1151 offset
= (ifd
->offset
+
1157 #ifdef CONFIG_GIGASET_DEBUG
1158 /* check assumption on remaining frames */
1159 for (; i
< BAS_NUMFRAMES
; i
++) {
1160 ifd
= &urb
->iso_frame_desc
[i
];
1161 if (ifd
->status
!= -EINPROGRESS
1162 || ifd
->actual_length
!= 0) {
1164 "isochronous write: frame %d: %s, "
1165 "%d of %d bytes sent\n",
1166 i
, get_usb_statmsg(ifd
->status
),
1167 ifd
->actual_length
, ifd
->length
);
1168 offset
= (ifd
->offset
+
1176 case -EPIPE
: /* stall - probably underrun */
1177 dev_err(cs
->dev
, "isochronous write stalled\n");
1180 default: /* severe trouble */
1181 dev_warn(cs
->dev
, "isochronous write: %s\n",
1182 get_usb_statmsg(urb
->status
));
1185 /* mark the write buffer area covered by this URB as free */
1186 if (done
->limit
>= 0)
1187 atomic_set(&ubc
->isooutbuf
->read
, done
->limit
);
1189 /* mark URB as free */
1190 spin_lock_irqsave(&ubc
->isooutlock
, flags
);
1191 next
= ubc
->isooutfree
;
1192 ubc
->isooutfree
= done
;
1193 spin_unlock_irqrestore(&ubc
->isooutlock
, flags
);
1195 /* only one URB still active - resubmit one */
1196 rc
= submit_iso_write_urb(next
);
1197 if (unlikely(rc
<= 0 && rc
!= -ENODEV
)) {
1198 /* couldn't submit */
1204 /* process queued SKBs */
1205 while ((skb
= skb_dequeue(&bcs
->squeue
))) {
1206 /* copy to output buffer, doing L2 encapsulation */
1208 if (gigaset_isoc_buildframe(bcs
, skb
->data
, len
) == -EAGAIN
) {
1209 /* insufficient buffer space, push back onto queue */
1210 skb_queue_head(&bcs
->squeue
, skb
);
1211 gig_dbg(DEBUG_ISO
, "%s: skb requeued, qlen=%d",
1212 __func__
, skb_queue_len(&bcs
->squeue
));
1216 gigaset_skb_sent(bcs
, skb
);
1217 dev_kfree_skb_any(skb
);
1221 /* Isochronous Read - Bottom Half */
1222 /* ============================== */
1225 * tasklet scheduled when an isochronous input URB from the Gigaset device
1228 * data B channel state structure
1230 static void read_iso_tasklet(unsigned long data
)
1232 struct bc_state
*bcs
= (struct bc_state
*) data
;
1233 struct bas_bc_state
*ubc
= bcs
->hw
.bas
;
1234 struct cardstate
*cs
= bcs
->cs
;
1237 unsigned long flags
;
1238 int totleft
, numbytes
, offset
, frame
, rc
;
1240 /* loop while more completed URBs arrive in the meantime */
1243 spin_lock_irqsave(&ubc
->isoinlock
, flags
);
1244 if (!(urb
= ubc
->isoindone
)) {
1245 spin_unlock_irqrestore(&ubc
->isoinlock
, flags
);
1248 ubc
->isoindone
= NULL
;
1249 if (unlikely(ubc
->loststatus
!= -EINPROGRESS
)) {
1251 "isochronous read overrun, "
1252 "dropped URB with status: %s, %d bytes lost\n",
1253 get_usb_statmsg(ubc
->loststatus
),
1255 ubc
->loststatus
= -EINPROGRESS
;
1257 spin_unlock_irqrestore(&ubc
->isoinlock
, flags
);
1259 if (unlikely(!(atomic_read(&ubc
->running
)))) {
1261 "%s: channel not running, "
1262 "dropped URB with status: %s",
1263 __func__
, get_usb_statmsg(urb
->status
));
1267 switch (urb
->status
) {
1268 case 0: /* normal completion */
1270 case -EXDEV
: /* inspect individual frames
1271 (we do that anyway) */
1272 gig_dbg(DEBUG_ISO
, "%s: URB partially completed",
1278 gig_dbg(DEBUG_ISO
, "%s: %s",
1279 __func__
, get_usb_statmsg(urb
->status
));
1280 continue; /* -> skip */
1282 dev_err(cs
->dev
, "isochronous read stalled\n");
1284 continue; /* -> skip */
1285 default: /* severe trouble */
1286 dev_warn(cs
->dev
, "isochronous read: %s\n",
1287 get_usb_statmsg(urb
->status
));
1291 rcvbuf
= urb
->transfer_buffer
;
1292 totleft
= urb
->actual_length
;
1293 for (frame
= 0; totleft
> 0 && frame
< BAS_NUMFRAMES
; frame
++) {
1294 if (unlikely(urb
->iso_frame_desc
[frame
].status
)) {
1296 "isochronous read: frame %d: %s\n",
1299 urb
->iso_frame_desc
[frame
].status
));
1302 numbytes
= urb
->iso_frame_desc
[frame
].actual_length
;
1303 if (unlikely(numbytes
> BAS_MAXFRAME
)) {
1305 "isochronous read: frame %d: "
1306 "numbytes (%d) > BAS_MAXFRAME\n",
1310 if (unlikely(numbytes
> totleft
)) {
1312 "isochronous read: frame %d: "
1313 "numbytes (%d) > totleft (%d)\n",
1314 frame
, numbytes
, totleft
);
1317 offset
= urb
->iso_frame_desc
[frame
].offset
;
1318 if (unlikely(offset
+ numbytes
> BAS_INBUFSIZE
)) {
1320 "isochronous read: frame %d: "
1321 "offset (%d) + numbytes (%d) "
1322 "> BAS_INBUFSIZE\n",
1323 frame
, offset
, numbytes
);
1326 gigaset_isoc_receive(rcvbuf
+ offset
, numbytes
, bcs
);
1327 totleft
-= numbytes
;
1329 if (unlikely(totleft
> 0))
1331 "isochronous read: %d data bytes missing\n",
1335 /* URB processed, resubmit */
1336 for (frame
= 0; frame
< BAS_NUMFRAMES
; frame
++) {
1337 urb
->iso_frame_desc
[frame
].status
= 0;
1338 urb
->iso_frame_desc
[frame
].actual_length
= 0;
1340 /* urb->dev is clobbered by USB subsystem */
1341 urb
->dev
= bcs
->cs
->hw
.bas
->udev
;
1342 urb
->transfer_flags
= URB_ISO_ASAP
;
1343 urb
->number_of_packets
= BAS_NUMFRAMES
;
1344 rc
= usb_submit_urb(urb
, SLAB_ATOMIC
);
1345 if (unlikely(rc
!= 0 && rc
!= -ENODEV
)) {
1347 "could not resubmit isochronous read URB: %s\n",
1349 dump_urb(DEBUG_ISO
, "resubmit iso read", urb
);
1355 /* Channel Operations */
1356 /* ================== */
1359 * timeout routine for control output request
1361 * B channel control structure
1363 static void req_timeout(unsigned long data
)
1365 struct bc_state
*bcs
= (struct bc_state
*) data
;
1366 struct bas_cardstate
*ucs
= bcs
->cs
->hw
.bas
;
1368 unsigned long flags
;
1372 spin_lock_irqsave(&ucs
->lock
, flags
);
1373 pending
= ucs
->pending
;
1375 spin_unlock_irqrestore(&ucs
->lock
, flags
);
1378 case 0: /* no pending request */
1379 gig_dbg(DEBUG_USBREQ
, "%s: no request pending", __func__
);
1382 case HD_OPEN_ATCHANNEL
:
1383 dev_err(bcs
->cs
->dev
, "timeout opening AT channel\n");
1384 error_reset(bcs
->cs
);
1387 case HD_OPEN_B2CHANNEL
:
1388 case HD_OPEN_B1CHANNEL
:
1389 dev_err(bcs
->cs
->dev
, "timeout opening channel %d\n",
1394 case HD_CLOSE_ATCHANNEL
:
1395 dev_err(bcs
->cs
->dev
, "timeout closing AT channel\n");
1398 case HD_CLOSE_B2CHANNEL
:
1399 case HD_CLOSE_B1CHANNEL
:
1400 dev_err(bcs
->cs
->dev
, "timeout closing channel %d\n",
1402 error_reset(bcs
->cs
);
1406 dev_warn(bcs
->cs
->dev
, "request 0x%02x timed out, clearing\n",
1411 /* write_ctrl_callback
1412 * USB completion handler for control pipe output
1413 * called by the USB subsystem in interrupt context
1415 * urb USB request block of completed request
1416 * urb->context = hardware specific controller state structure
1418 static void write_ctrl_callback(struct urb
*urb
)
1420 struct bas_cardstate
*ucs
= urb
->context
;
1422 unsigned long flags
;
1425 switch (urb
->status
) {
1426 case 0: /* normal completion */
1427 spin_lock_irqsave(&ucs
->lock
, flags
);
1428 switch (ucs
->pending
) {
1429 case HD_DEVICE_INIT_ACK
: /* no reply expected */
1430 del_timer(&ucs
->timer_ctrl
);
1434 spin_unlock_irqrestore(&ucs
->lock
, flags
);
1437 case -ENOENT
: /* cancelled */
1438 case -ECONNRESET
: /* cancelled (async) */
1439 case -EINPROGRESS
: /* pending */
1440 case -ENODEV
: /* device removed */
1441 case -ESHUTDOWN
: /* device shut down */
1442 /* ignore silently */
1443 gig_dbg(DEBUG_USBREQ
, "%s: %s",
1444 __func__
, get_usb_statmsg(urb
->status
));
1447 default: /* any failure */
1448 if (++ucs
->retry_ctrl
> BAS_RETRY
) {
1449 dev_err(&ucs
->interface
->dev
,
1450 "control request 0x%02x failed: %s\n",
1451 ucs
->dr_ctrl
.bRequest
,
1452 get_usb_statmsg(urb
->status
));
1453 break; /* give up */
1455 dev_notice(&ucs
->interface
->dev
,
1456 "control request 0x%02x: %s, retry %d\n",
1457 ucs
->dr_ctrl
.bRequest
, get_usb_statmsg(urb
->status
),
1459 /* urb->dev is clobbered by USB subsystem */
1460 urb
->dev
= ucs
->udev
;
1461 rc
= usb_submit_urb(urb
, SLAB_ATOMIC
);
1463 dev_err(&ucs
->interface
->dev
,
1464 "could not resubmit request 0x%02x: %s\n",
1465 ucs
->dr_ctrl
.bRequest
, get_usb_rcmsg(rc
));
1472 /* failed, clear pending request */
1473 spin_lock_irqsave(&ucs
->lock
, flags
);
1474 del_timer(&ucs
->timer_ctrl
);
1476 spin_unlock_irqrestore(&ucs
->lock
, flags
);
1480 * submit a control output request without message buffer to the Gigaset base
1481 * and optionally start a timeout
1483 * bcs B channel control structure
1484 * req control request code (HD_*)
1485 * val control request parameter value (set to 0 if unused)
1486 * timeout timeout in seconds (0: no timeout)
1489 * -EBUSY if another request is pending
1490 * any URB submission error code
1492 static int req_submit(struct bc_state
*bcs
, int req
, int val
, int timeout
)
1494 struct bas_cardstate
*ucs
= bcs
->cs
->hw
.bas
;
1496 unsigned long flags
;
1498 gig_dbg(DEBUG_USBREQ
, "-------> 0x%02x (%d)", req
, val
);
1500 spin_lock_irqsave(&ucs
->lock
, flags
);
1502 spin_unlock_irqrestore(&ucs
->lock
, flags
);
1503 dev_err(bcs
->cs
->dev
,
1504 "submission of request 0x%02x failed: "
1505 "request 0x%02x still pending\n",
1510 ucs
->dr_ctrl
.bRequestType
= OUT_VENDOR_REQ
;
1511 ucs
->dr_ctrl
.bRequest
= req
;
1512 ucs
->dr_ctrl
.wValue
= cpu_to_le16(val
);
1513 ucs
->dr_ctrl
.wIndex
= 0;
1514 ucs
->dr_ctrl
.wLength
= 0;
1515 usb_fill_control_urb(ucs
->urb_ctrl
, ucs
->udev
,
1516 usb_sndctrlpipe(ucs
->udev
, 0),
1517 (unsigned char*) &ucs
->dr_ctrl
, NULL
, 0,
1518 write_ctrl_callback
, ucs
);
1519 ucs
->retry_ctrl
= 0;
1520 ret
= usb_submit_urb(ucs
->urb_ctrl
, SLAB_ATOMIC
);
1521 if (unlikely(ret
)) {
1522 dev_err(bcs
->cs
->dev
, "could not submit request 0x%02x: %s\n",
1523 req
, get_usb_rcmsg(ret
));
1524 spin_unlock_irqrestore(&ucs
->lock
, flags
);
1530 gig_dbg(DEBUG_USBREQ
, "setting timeout of %d/10 secs", timeout
);
1531 ucs
->timer_ctrl
.expires
= jiffies
+ timeout
* HZ
/ 10;
1532 ucs
->timer_ctrl
.data
= (unsigned long) bcs
;
1533 ucs
->timer_ctrl
.function
= req_timeout
;
1534 add_timer(&ucs
->timer_ctrl
);
1537 spin_unlock_irqrestore(&ucs
->lock
, flags
);
1541 /* gigaset_init_bchannel
1542 * called by common.c to connect a B channel
1543 * initialize isochronous I/O and tell the Gigaset base to open the channel
1545 * B channel control structure
1547 * 0 on success, error code < 0 on error
1549 static int gigaset_init_bchannel(struct bc_state
*bcs
)
1552 unsigned long flags
;
1554 spin_lock_irqsave(&bcs
->cs
->lock
, flags
);
1555 if (unlikely(!bcs
->cs
->connected
)) {
1556 gig_dbg(DEBUG_USBREQ
, "%s: not connected", __func__
);
1557 spin_unlock_irqrestore(&bcs
->cs
->lock
, flags
);
1561 if ((ret
= starturbs(bcs
)) < 0) {
1562 dev_err(bcs
->cs
->dev
,
1563 "could not start isochronous I/O for channel B%d: %s\n",
1565 ret
== -EFAULT
? "null URB" : get_usb_rcmsg(ret
));
1568 spin_unlock_irqrestore(&bcs
->cs
->lock
, flags
);
1572 req
= bcs
->channel
? HD_OPEN_B2CHANNEL
: HD_OPEN_B1CHANNEL
;
1573 if ((ret
= req_submit(bcs
, req
, 0, BAS_TIMEOUT
)) < 0) {
1574 dev_err(bcs
->cs
->dev
, "could not open channel B%d\n",
1576 stopurbs(bcs
->hw
.bas
);
1581 spin_unlock_irqrestore(&bcs
->cs
->lock
, flags
);
1585 /* gigaset_close_bchannel
1586 * called by common.c to disconnect a B channel
1587 * tell the Gigaset base to close the channel
1588 * stopping isochronous I/O and LL notification will be done when the
1589 * acknowledgement for the close arrives
1591 * B channel control structure
1593 * 0 on success, error code < 0 on error
1595 static int gigaset_close_bchannel(struct bc_state
*bcs
)
1598 unsigned long flags
;
1600 spin_lock_irqsave(&bcs
->cs
->lock
, flags
);
1601 if (unlikely(!bcs
->cs
->connected
)) {
1602 spin_unlock_irqrestore(&bcs
->cs
->lock
, flags
);
1603 gig_dbg(DEBUG_USBREQ
, "%s: not connected", __func__
);
1607 if (!(atomic_read(&bcs
->cs
->hw
.bas
->basstate
) &
1608 (bcs
->channel
? BS_B2OPEN
: BS_B1OPEN
))) {
1609 /* channel not running: just signal common.c */
1610 spin_unlock_irqrestore(&bcs
->cs
->lock
, flags
);
1611 gigaset_bchannel_down(bcs
);
1615 /* channel running: tell device to close it */
1616 req
= bcs
->channel
? HD_CLOSE_B2CHANNEL
: HD_CLOSE_B1CHANNEL
;
1617 if ((ret
= req_submit(bcs
, req
, 0, BAS_TIMEOUT
)) < 0)
1618 dev_err(bcs
->cs
->dev
, "closing channel B%d failed\n",
1621 spin_unlock_irqrestore(&bcs
->cs
->lock
, flags
);
1625 /* Device Operations */
1626 /* ================= */
1629 * unqueue first command buffer from queue, waking any sleepers
1630 * must be called with cs->cmdlock held
1632 * cs controller state structure
1634 static void complete_cb(struct cardstate
*cs
)
1636 struct cmdbuf_t
*cb
= cs
->cmdbuf
;
1638 /* unqueue completed buffer */
1639 cs
->cmdbytes
-= cs
->curlen
;
1640 gig_dbg(DEBUG_TRANSCMD
|DEBUG_LOCKCMD
,
1641 "write_command: sent %u bytes, %u left",
1642 cs
->curlen
, cs
->cmdbytes
);
1643 if ((cs
->cmdbuf
= cb
->next
) != NULL
) {
1644 cs
->cmdbuf
->prev
= NULL
;
1645 cs
->curlen
= cs
->cmdbuf
->len
;
1647 cs
->lastcmdbuf
= NULL
;
1651 if (cb
->wake_tasklet
)
1652 tasklet_schedule(cb
->wake_tasklet
);
1657 /* write_command_callback
1658 * USB completion handler for AT command transmission
1659 * called by the USB subsystem in interrupt context
1661 * urb USB request block of completed request
1662 * urb->context = controller state structure
1664 static void write_command_callback(struct urb
*urb
)
1666 struct cardstate
*cs
= urb
->context
;
1667 struct bas_cardstate
*ucs
= cs
->hw
.bas
;
1668 unsigned long flags
;
1670 update_basstate(ucs
, 0, BS_ATWRPEND
);
1673 switch (urb
->status
) {
1674 case 0: /* normal completion */
1676 case -ENOENT
: /* cancelled */
1677 case -ECONNRESET
: /* cancelled (async) */
1678 case -EINPROGRESS
: /* pending */
1679 case -ENODEV
: /* device removed */
1680 case -ESHUTDOWN
: /* device shut down */
1681 /* ignore silently */
1682 gig_dbg(DEBUG_USBREQ
, "%s: %s",
1683 __func__
, get_usb_statmsg(urb
->status
));
1685 default: /* any failure */
1686 if (++ucs
->retry_cmd_out
> BAS_RETRY
) {
1688 "command write: %s, "
1689 "giving up after %d retries\n",
1690 get_usb_statmsg(urb
->status
),
1691 ucs
->retry_cmd_out
);
1694 if (cs
->cmdbuf
== NULL
) {
1696 "command write: %s, "
1697 "cannot retry - cmdbuf gone\n",
1698 get_usb_statmsg(urb
->status
));
1701 dev_notice(cs
->dev
, "command write: %s, retry %d\n",
1702 get_usb_statmsg(urb
->status
), ucs
->retry_cmd_out
);
1703 if (atwrite_submit(cs
, cs
->cmdbuf
->buf
, cs
->cmdbuf
->len
) >= 0)
1704 /* resubmitted - bypass regular exit block */
1706 /* command send failed, assume base still waiting */
1707 update_basstate(ucs
, BS_ATREADY
, 0);
1710 spin_lock_irqsave(&cs
->cmdlock
, flags
);
1711 if (cs
->cmdbuf
!= NULL
)
1713 spin_unlock_irqrestore(&cs
->cmdlock
, flags
);
1717 * timeout routine for AT command transmission
1719 * controller state structure
1721 static void atrdy_timeout(unsigned long data
)
1723 struct cardstate
*cs
= (struct cardstate
*) data
;
1724 struct bas_cardstate
*ucs
= cs
->hw
.bas
;
1726 dev_warn(cs
->dev
, "timeout waiting for HD_READY_SEND_ATDATA\n");
1728 /* fake the missing signal - what else can I do? */
1729 update_basstate(ucs
, BS_ATREADY
, BS_ATTIMER
);
1734 * submit an HD_WRITE_ATMESSAGE command URB
1736 * cs controller state structure
1737 * buf buffer containing command to send
1738 * len length of command to send
1741 * -EBUSY if another request is pending
1742 * any URB submission error code
1744 static int atwrite_submit(struct cardstate
*cs
, unsigned char *buf
, int len
)
1746 struct bas_cardstate
*ucs
= cs
->hw
.bas
;
1749 gig_dbg(DEBUG_USBREQ
, "-------> HD_WRITE_ATMESSAGE (%d)", len
);
1751 if (update_basstate(ucs
, BS_ATWRPEND
, 0) & BS_ATWRPEND
) {
1753 "could not submit HD_WRITE_ATMESSAGE: URB busy\n");
1757 ucs
->dr_cmd_out
.bRequestType
= OUT_VENDOR_REQ
;
1758 ucs
->dr_cmd_out
.bRequest
= HD_WRITE_ATMESSAGE
;
1759 ucs
->dr_cmd_out
.wValue
= 0;
1760 ucs
->dr_cmd_out
.wIndex
= 0;
1761 ucs
->dr_cmd_out
.wLength
= cpu_to_le16(len
);
1762 usb_fill_control_urb(ucs
->urb_cmd_out
, ucs
->udev
,
1763 usb_sndctrlpipe(ucs
->udev
, 0),
1764 (unsigned char*) &ucs
->dr_cmd_out
, buf
, len
,
1765 write_command_callback
, cs
);
1766 rc
= usb_submit_urb(ucs
->urb_cmd_out
, SLAB_ATOMIC
);
1768 update_basstate(ucs
, 0, BS_ATWRPEND
);
1769 dev_err(cs
->dev
, "could not submit HD_WRITE_ATMESSAGE: %s\n",
1774 /* submitted successfully, start timeout if necessary */
1775 if (!(update_basstate(ucs
, BS_ATTIMER
, BS_ATREADY
) & BS_ATTIMER
)) {
1776 gig_dbg(DEBUG_OUTPUT
, "setting ATREADY timeout of %d/10 secs",
1778 ucs
->timer_atrdy
.expires
= jiffies
+ ATRDY_TIMEOUT
* HZ
/ 10;
1779 ucs
->timer_atrdy
.data
= (unsigned long) cs
;
1780 ucs
->timer_atrdy
.function
= atrdy_timeout
;
1781 add_timer(&ucs
->timer_atrdy
);
1787 * start transmission of AT command queue if necessary
1789 * cs controller state structure
1792 * error code < 0 on error
1794 static int start_cbsend(struct cardstate
*cs
)
1796 struct cmdbuf_t
*cb
;
1797 struct bas_cardstate
*ucs
= cs
->hw
.bas
;
1798 unsigned long flags
;
1802 /* check if AT channel is open */
1803 if (!(atomic_read(&ucs
->basstate
) & BS_ATOPEN
)) {
1804 gig_dbg(DEBUG_TRANSCMD
|DEBUG_LOCKCMD
, "AT channel not open");
1805 rc
= req_submit(cs
->bcs
, HD_OPEN_ATCHANNEL
, 0, BAS_TIMEOUT
);
1807 /* flush command queue */
1808 spin_lock_irqsave(&cs
->cmdlock
, flags
);
1809 while (cs
->cmdbuf
!= NULL
)
1811 spin_unlock_irqrestore(&cs
->cmdlock
, flags
);
1816 /* try to send first command in queue */
1817 spin_lock_irqsave(&cs
->cmdlock
, flags
);
1819 while ((cb
= cs
->cmdbuf
) != NULL
&&
1820 atomic_read(&ucs
->basstate
) & BS_ATREADY
) {
1821 ucs
->retry_cmd_out
= 0;
1822 rc
= atwrite_submit(cs
, cb
->buf
, cb
->len
);
1829 spin_unlock_irqrestore(&cs
->cmdlock
, flags
);
1833 /* gigaset_write_cmd
1834 * This function is called by the device independent part of the driver
1835 * to transmit an AT command string to the Gigaset device.
1836 * It encapsulates the device specific method for transmission over the
1837 * direct USB connection to the base.
1838 * The command string is added to the queue of commands to send, and
1839 * USB transmission is started if necessary.
1841 * cs controller state structure
1842 * buf command string to send
1843 * len number of bytes to send (max. IF_WRITEBUF)
1844 * wake_tasklet tasklet to run when transmission is completed
1847 * number of bytes queued on success
1848 * error code < 0 on error
1850 static int gigaset_write_cmd(struct cardstate
*cs
,
1851 const unsigned char *buf
, int len
,
1852 struct tasklet_struct
*wake_tasklet
)
1854 struct cmdbuf_t
*cb
;
1855 unsigned long flags
;
1858 gigaset_dbg_buffer(atomic_read(&cs
->mstate
) != MS_LOCKED
?
1859 DEBUG_TRANSCMD
: DEBUG_LOCKCMD
,
1860 "CMD Transmit", len
, buf
);
1863 return 0; /* nothing to do */
1865 if (len
> IF_WRITEBUF
)
1867 if (!(cb
= kmalloc(sizeof(struct cmdbuf_t
) + len
, GFP_ATOMIC
))) {
1868 dev_err(cs
->dev
, "%s: out of memory\n", __func__
);
1872 memcpy(cb
->buf
, buf
, len
);
1876 cb
->wake_tasklet
= wake_tasklet
;
1878 spin_lock_irqsave(&cs
->cmdlock
, flags
);
1879 cb
->prev
= cs
->lastcmdbuf
;
1881 cs
->lastcmdbuf
->next
= cb
;
1886 cs
->cmdbytes
+= len
;
1887 cs
->lastcmdbuf
= cb
;
1888 spin_unlock_irqrestore(&cs
->cmdlock
, flags
);
1890 spin_lock_irqsave(&cs
->lock
, flags
);
1891 if (unlikely(!cs
->connected
)) {
1892 spin_unlock_irqrestore(&cs
->lock
, flags
);
1893 gig_dbg(DEBUG_USBREQ
, "%s: not connected", __func__
);
1896 status
= start_cbsend(cs
);
1897 spin_unlock_irqrestore(&cs
->lock
, flags
);
1898 return status
< 0 ? status
: len
;
1901 /* gigaset_write_room
1902 * tty_driver.write_room interface routine
1903 * return number of characters the driver will accept to be written via
1906 * controller state structure
1908 * number of characters
1910 static int gigaset_write_room(struct cardstate
*cs
)
1915 /* gigaset_chars_in_buffer
1916 * tty_driver.chars_in_buffer interface routine
1917 * return number of characters waiting to be sent
1919 * controller state structure
1921 * number of characters
1923 static int gigaset_chars_in_buffer(struct cardstate
*cs
)
1925 unsigned long flags
;
1928 spin_lock_irqsave(&cs
->cmdlock
, flags
);
1929 bytes
= cs
->cmdbytes
;
1930 spin_unlock_irqrestore(&cs
->cmdlock
, flags
);
1936 * implementation of ioctl(GIGASET_BRKCHARS)
1938 * controller state structure
1940 * -EINVAL (unimplemented function)
1942 static int gigaset_brkchars(struct cardstate
*cs
, const unsigned char buf
[6])
1948 /* Device Initialization/Shutdown */
1949 /* ============================== */
1951 /* Free hardware dependent part of the B channel structure
1953 * bcs B channel structure
1957 static int gigaset_freebcshw(struct bc_state
*bcs
)
1959 struct bas_bc_state
*ubc
= bcs
->hw
.bas
;
1965 /* kill URBs and tasklets before freeing - better safe than sorry */
1966 atomic_set(&ubc
->running
, 0);
1967 for (i
= 0; i
< BAS_OUTURBS
; ++i
)
1968 if (ubc
->isoouturbs
[i
].urb
) {
1969 gig_dbg(DEBUG_INIT
, "%s: killing iso out URB %d",
1971 usb_kill_urb(ubc
->isoouturbs
[i
].urb
);
1972 usb_free_urb(ubc
->isoouturbs
[i
].urb
);
1974 for (i
= 0; i
< BAS_INURBS
; ++i
)
1975 if (ubc
->isoinurbs
[i
]) {
1976 gig_dbg(DEBUG_INIT
, "%s: killing iso in URB %d",
1978 usb_kill_urb(ubc
->isoinurbs
[i
]);
1979 usb_free_urb(ubc
->isoinurbs
[i
]);
1981 tasklet_kill(&ubc
->sent_tasklet
);
1982 tasklet_kill(&ubc
->rcvd_tasklet
);
1983 kfree(ubc
->isooutbuf
);
1989 /* Initialize hardware dependent part of the B channel structure
1991 * bcs B channel structure
1995 static int gigaset_initbcshw(struct bc_state
*bcs
)
1998 struct bas_bc_state
*ubc
;
2000 bcs
->hw
.bas
= ubc
= kmalloc(sizeof(struct bas_bc_state
), GFP_KERNEL
);
2002 err("could not allocate bas_bc_state");
2006 atomic_set(&ubc
->running
, 0);
2007 atomic_set(&ubc
->corrbytes
, 0);
2008 spin_lock_init(&ubc
->isooutlock
);
2009 for (i
= 0; i
< BAS_OUTURBS
; ++i
) {
2010 ubc
->isoouturbs
[i
].urb
= NULL
;
2011 ubc
->isoouturbs
[i
].bcs
= bcs
;
2013 ubc
->isooutdone
= ubc
->isooutfree
= ubc
->isooutovfl
= NULL
;
2015 if (!(ubc
->isooutbuf
= kmalloc(sizeof(struct isowbuf_t
), GFP_KERNEL
))) {
2016 err("could not allocate isochronous output buffer");
2021 tasklet_init(&ubc
->sent_tasklet
,
2022 &write_iso_tasklet
, (unsigned long) bcs
);
2024 spin_lock_init(&ubc
->isoinlock
);
2025 for (i
= 0; i
< BAS_INURBS
; ++i
)
2026 ubc
->isoinurbs
[i
] = NULL
;
2027 ubc
->isoindone
= NULL
;
2028 ubc
->loststatus
= -EINPROGRESS
;
2042 tasklet_init(&ubc
->rcvd_tasklet
,
2043 &read_iso_tasklet
, (unsigned long) bcs
);
2047 static void gigaset_reinitbcshw(struct bc_state
*bcs
)
2049 struct bas_bc_state
*ubc
= bcs
->hw
.bas
;
2051 atomic_set(&bcs
->hw
.bas
->running
, 0);
2052 atomic_set(&bcs
->hw
.bas
->corrbytes
, 0);
2053 bcs
->hw
.bas
->numsub
= 0;
2054 spin_lock_init(&ubc
->isooutlock
);
2055 spin_lock_init(&ubc
->isoinlock
);
2056 ubc
->loststatus
= -EINPROGRESS
;
2059 static void gigaset_freecshw(struct cardstate
*cs
)
2061 /* timers, URBs and rcvbuf are disposed of in disconnect */
2066 static int gigaset_initcshw(struct cardstate
*cs
)
2068 struct bas_cardstate
*ucs
;
2070 cs
->hw
.bas
= ucs
= kmalloc(sizeof *ucs
, GFP_KERNEL
);
2074 ucs
->urb_cmd_in
= NULL
;
2075 ucs
->urb_cmd_out
= NULL
;
2077 ucs
->rcvbuf_size
= 0;
2079 spin_lock_init(&ucs
->lock
);
2082 atomic_set(&ucs
->basstate
, 0);
2083 init_timer(&ucs
->timer_ctrl
);
2084 init_timer(&ucs
->timer_atrdy
);
2085 init_timer(&ucs
->timer_cmd_in
);
2091 * unlink and deallocate all URBs unconditionally
2092 * caller must make sure that no commands are still in progress
2094 * cs controller state structure
2096 static void freeurbs(struct cardstate
*cs
)
2098 struct bas_cardstate
*ucs
= cs
->hw
.bas
;
2099 struct bas_bc_state
*ubc
;
2102 for (j
= 0; j
< 2; ++j
) {
2103 ubc
= cs
->bcs
[j
].hw
.bas
;
2104 for (i
= 0; i
< BAS_OUTURBS
; ++i
)
2105 if (ubc
->isoouturbs
[i
].urb
) {
2106 usb_kill_urb(ubc
->isoouturbs
[i
].urb
);
2108 "%s: isoc output URB %d/%d unlinked",
2110 usb_free_urb(ubc
->isoouturbs
[i
].urb
);
2111 ubc
->isoouturbs
[i
].urb
= NULL
;
2113 for (i
= 0; i
< BAS_INURBS
; ++i
)
2114 if (ubc
->isoinurbs
[i
]) {
2115 usb_kill_urb(ubc
->isoinurbs
[i
]);
2117 "%s: isoc input URB %d/%d unlinked",
2119 usb_free_urb(ubc
->isoinurbs
[i
]);
2120 ubc
->isoinurbs
[i
] = NULL
;
2123 if (ucs
->urb_int_in
) {
2124 usb_kill_urb(ucs
->urb_int_in
);
2125 gig_dbg(DEBUG_INIT
, "%s: interrupt input URB unlinked",
2127 usb_free_urb(ucs
->urb_int_in
);
2128 ucs
->urb_int_in
= NULL
;
2130 if (ucs
->urb_cmd_out
) {
2131 usb_kill_urb(ucs
->urb_cmd_out
);
2132 gig_dbg(DEBUG_INIT
, "%s: command output URB unlinked",
2134 usb_free_urb(ucs
->urb_cmd_out
);
2135 ucs
->urb_cmd_out
= NULL
;
2137 if (ucs
->urb_cmd_in
) {
2138 usb_kill_urb(ucs
->urb_cmd_in
);
2139 gig_dbg(DEBUG_INIT
, "%s: command input URB unlinked",
2141 usb_free_urb(ucs
->urb_cmd_in
);
2142 ucs
->urb_cmd_in
= NULL
;
2144 if (ucs
->urb_ctrl
) {
2145 usb_kill_urb(ucs
->urb_ctrl
);
2146 gig_dbg(DEBUG_INIT
, "%s: control output URB unlinked",
2148 usb_free_urb(ucs
->urb_ctrl
);
2149 ucs
->urb_ctrl
= NULL
;
2154 * This function is called when a new USB device is connected.
2155 * It checks whether the new device is handled by this driver.
2157 static int gigaset_probe(struct usb_interface
*interface
,
2158 const struct usb_device_id
*id
)
2160 struct usb_host_interface
*hostif
;
2161 struct usb_device
*udev
= interface_to_usbdev(interface
);
2162 struct cardstate
*cs
= NULL
;
2163 struct bas_cardstate
*ucs
= NULL
;
2164 struct bas_bc_state
*ubc
;
2165 struct usb_endpoint_descriptor
*endpoint
;
2170 "%s: Check if device matches .. (Vendor: 0x%x, Product: 0x%x)",
2171 __func__
, le16_to_cpu(udev
->descriptor
.idVendor
),
2172 le16_to_cpu(udev
->descriptor
.idProduct
));
2174 /* set required alternate setting */
2175 hostif
= interface
->cur_altsetting
;
2176 if (hostif
->desc
.bAlternateSetting
!= 3) {
2178 "%s: wrong alternate setting %d - trying to switch",
2179 __func__
, hostif
->desc
.bAlternateSetting
);
2180 if (usb_set_interface(udev
, hostif
->desc
.bInterfaceNumber
, 3) < 0) {
2181 dev_warn(&udev
->dev
, "usb_set_interface failed, "
2182 "device %d interface %d altsetting %d\n",
2183 udev
->devnum
, hostif
->desc
.bInterfaceNumber
,
2184 hostif
->desc
.bAlternateSetting
);
2187 hostif
= interface
->cur_altsetting
;
2190 /* Reject application specific interfaces
2192 if (hostif
->desc
.bInterfaceClass
!= 255) {
2193 dev_warn(&udev
->dev
, "%s: bInterfaceClass == %d\n",
2194 __func__
, hostif
->desc
.bInterfaceClass
);
2198 dev_info(&udev
->dev
,
2199 "%s: Device matched (Vendor: 0x%x, Product: 0x%x)\n",
2200 __func__
, le16_to_cpu(udev
->descriptor
.idVendor
),
2201 le16_to_cpu(udev
->descriptor
.idProduct
));
2203 cs
= gigaset_getunassignedcs(driver
);
2205 dev_err(&udev
->dev
, "no free cardstate\n");
2210 /* save off device structure ptrs for later use */
2213 ucs
->interface
= interface
;
2214 cs
->dev
= &interface
->dev
;
2217 * - one for the interrupt pipe
2218 * - three for the different uses of the default control pipe
2219 * - three for each isochronous pipe
2221 if (!(ucs
->urb_int_in
= usb_alloc_urb(0, SLAB_KERNEL
)) ||
2222 !(ucs
->urb_cmd_in
= usb_alloc_urb(0, SLAB_KERNEL
)) ||
2223 !(ucs
->urb_cmd_out
= usb_alloc_urb(0, SLAB_KERNEL
)) ||
2224 !(ucs
->urb_ctrl
= usb_alloc_urb(0, SLAB_KERNEL
)))
2227 for (j
= 0; j
< 2; ++j
) {
2228 ubc
= cs
->bcs
[j
].hw
.bas
;
2229 for (i
= 0; i
< BAS_OUTURBS
; ++i
)
2230 if (!(ubc
->isoouturbs
[i
].urb
=
2231 usb_alloc_urb(BAS_NUMFRAMES
, SLAB_KERNEL
)))
2233 for (i
= 0; i
< BAS_INURBS
; ++i
)
2234 if (!(ubc
->isoinurbs
[i
] =
2235 usb_alloc_urb(BAS_NUMFRAMES
, SLAB_KERNEL
)))
2240 ucs
->rcvbuf_size
= 0;
2242 /* Fill the interrupt urb and send it to the core */
2243 endpoint
= &hostif
->endpoint
[0].desc
;
2244 usb_fill_int_urb(ucs
->urb_int_in
, udev
,
2245 usb_rcvintpipe(udev
,
2246 (endpoint
->bEndpointAddress
) & 0x0f),
2247 ucs
->int_in_buf
, 3, read_int_callback
, cs
,
2248 endpoint
->bInterval
);
2249 if ((rc
= usb_submit_urb(ucs
->urb_int_in
, SLAB_KERNEL
)) != 0) {
2250 dev_err(cs
->dev
, "could not submit interrupt URB: %s\n",
2255 /* tell the device that the driver is ready */
2256 if ((rc
= req_submit(cs
->bcs
, HD_DEVICE_INIT_ACK
, 0, 0)) != 0)
2259 /* tell common part that the device is ready */
2260 if (startmode
== SM_LOCKED
)
2261 atomic_set(&cs
->mstate
, MS_LOCKED
);
2263 /* save address of controller structure */
2264 usb_set_intfdata(interface
, cs
);
2266 if (!gigaset_start(cs
))
2272 dev_err(cs
->dev
, "could not allocate URBs\n");
2275 usb_set_intfdata(interface
, NULL
);
2276 gigaset_unassign(cs
);
2280 /* gigaset_disconnect
2281 * This function is called when the Gigaset base is unplugged.
2283 static void gigaset_disconnect(struct usb_interface
*interface
)
2285 struct cardstate
*cs
;
2286 struct bas_cardstate
*ucs
;
2289 cs
= usb_get_intfdata(interface
);
2293 dev_info(cs
->dev
, "disconnecting Gigaset base\n");
2295 /* mark base as not ready, all channels disconnected */
2296 atomic_set(&ucs
->basstate
, 0);
2298 /* tell LL all channels are down */
2299 //FIXME shouldn't gigaset_stop() do this?
2300 for (j
= 0; j
< 2; ++j
)
2301 gigaset_bchannel_down(cs
->bcs
+ j
);
2303 /* stop driver (common part) */
2306 /* stop timers and URBs, free ressources */
2307 del_timer_sync(&ucs
->timer_ctrl
);
2308 del_timer_sync(&ucs
->timer_atrdy
);
2309 del_timer_sync(&ucs
->timer_cmd_in
);
2311 usb_set_intfdata(interface
, NULL
);
2314 ucs
->rcvbuf_size
= 0;
2315 usb_put_dev(ucs
->udev
);
2316 ucs
->interface
= NULL
;
2319 gigaset_unassign(cs
);
2322 static struct gigaset_ops gigops
= {
2325 gigaset_chars_in_buffer
,
2327 gigaset_init_bchannel
,
2328 gigaset_close_bchannel
,
2331 gigaset_reinitbcshw
,
2334 gigaset_set_modem_ctrl
,
2336 gigaset_set_line_ctrl
,
2337 gigaset_isoc_send_skb
,
2342 * This function is called after the kernel module is loaded.
2344 static int __init
bas_gigaset_init(void)
2348 /* allocate memory for our driver state and intialize it */
2349 if ((driver
= gigaset_initdriver(GIGASET_MINOR
, GIGASET_MINORS
,
2350 GIGASET_MODULENAME
, GIGASET_DEVNAME
,
2351 &gigops
, THIS_MODULE
)) == NULL
)
2354 /* allocate memory for our device state and intialize it */
2355 cardstate
= gigaset_initcs(driver
, 2, 0, 0, cidmode
,
2356 GIGASET_MODULENAME
);
2360 /* register this driver with the USB subsystem */
2361 result
= usb_register(&gigaset_usb_driver
);
2363 err("usb_register failed (error %d)", -result
);
2367 info(DRIVER_AUTHOR
);
2371 error
: if (cardstate
)
2372 gigaset_freecs(cardstate
);
2375 gigaset_freedriver(driver
);
2381 * This function is called before the kernel module is unloaded.
2383 static void __exit
bas_gigaset_exit(void)
2385 struct bas_cardstate
*ucs
= cardstate
->hw
.bas
;
2387 gigaset_blockdriver(driver
); /* => probe will fail
2388 * => no gigaset_start any more
2391 gigaset_shutdown(cardstate
);
2392 /* from now on, no isdn callback should be possible */
2394 /* close all still open channels */
2395 if (atomic_read(&ucs
->basstate
) & BS_B1OPEN
) {
2396 gig_dbg(DEBUG_INIT
, "closing B1 channel");
2397 usb_control_msg(ucs
->udev
, usb_sndctrlpipe(ucs
->udev
, 0),
2398 HD_CLOSE_B1CHANNEL
, OUT_VENDOR_REQ
, 0, 0,
2399 NULL
, 0, BAS_TIMEOUT
);
2401 if (atomic_read(&ucs
->basstate
) & BS_B2OPEN
) {
2402 gig_dbg(DEBUG_INIT
, "closing B2 channel");
2403 usb_control_msg(ucs
->udev
, usb_sndctrlpipe(ucs
->udev
, 0),
2404 HD_CLOSE_B2CHANNEL
, OUT_VENDOR_REQ
, 0, 0,
2405 NULL
, 0, BAS_TIMEOUT
);
2407 if (atomic_read(&ucs
->basstate
) & BS_ATOPEN
) {
2408 gig_dbg(DEBUG_INIT
, "closing AT channel");
2409 usb_control_msg(ucs
->udev
, usb_sndctrlpipe(ucs
->udev
, 0),
2410 HD_CLOSE_ATCHANNEL
, OUT_VENDOR_REQ
, 0, 0,
2411 NULL
, 0, BAS_TIMEOUT
);
2413 atomic_set(&ucs
->basstate
, 0);
2415 /* deregister this driver with the USB subsystem */
2416 usb_deregister(&gigaset_usb_driver
);
2417 /* this will call the disconnect-callback */
2418 /* from now on, no disconnect/probe callback should be running */
2420 gigaset_freecs(cardstate
);
2422 gigaset_freedriver(driver
);
2427 module_init(bas_gigaset_init
);
2428 module_exit(bas_gigaset_exit
);
2430 MODULE_AUTHOR(DRIVER_AUTHOR
);
2431 MODULE_DESCRIPTION(DRIVER_DESC
);
2432 MODULE_LICENSE("GPL");