]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/isdn/gigaset/bas-gigaset.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
regulator: arizona-ldo1: Factor out generic initialization
[mirror_ubuntu-bionic-kernel.git] / drivers / isdn / gigaset / bas-gigaset.c
1 /*
2 * USB driver for Gigaset 307x base via direct USB connection.
3 *
4 * Copyright (c) 2001 by Hansjoerg Lipp <hjlipp@web.de>,
5 * Tilman Schmidt <tilman@imap.cc>,
6 * Stefan Eilers.
7 *
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 * =====================================================================
14 */
15
16 #include "gigaset.h"
17 #include <linux/usb.h>
18 #include <linux/module.h>
19 #include <linux/moduleparam.h>
20
21 /* Version Information */
22 #define DRIVER_AUTHOR "Tilman Schmidt <tilman@imap.cc>, Hansjoerg Lipp <hjlipp@web.de>, Stefan Eilers"
23 #define DRIVER_DESC "USB Driver for Gigaset 307x"
24
25
26 /* Module parameters */
27
28 static int startmode = SM_ISDN;
29 static int cidmode = 1;
30
31 module_param(startmode, int, S_IRUGO);
32 module_param(cidmode, int, S_IRUGO);
33 MODULE_PARM_DESC(startmode, "start in isdn4linux mode");
34 MODULE_PARM_DESC(cidmode, "Call-ID mode");
35
36 #define GIGASET_MINORS 1
37 #define GIGASET_MINOR 16
38 #define GIGASET_MODULENAME "bas_gigaset"
39 #define GIGASET_DEVNAME "ttyGB"
40
41 /* length limit according to Siemens 3070usb-protokoll.doc ch. 2.1 */
42 #define IF_WRITEBUF 264
43
44 /* interrupt pipe message size according to ibid. ch. 2.2 */
45 #define IP_MSGSIZE 3
46
47 /* Values for the Gigaset 307x */
48 #define USB_GIGA_VENDOR_ID 0x0681
49 #define USB_3070_PRODUCT_ID 0x0001
50 #define USB_3075_PRODUCT_ID 0x0002
51 #define USB_SX303_PRODUCT_ID 0x0021
52 #define USB_SX353_PRODUCT_ID 0x0022
53
54 /* table of devices that work with this driver */
55 static const struct usb_device_id gigaset_table[] = {
56 { USB_DEVICE(USB_GIGA_VENDOR_ID, USB_3070_PRODUCT_ID) },
57 { USB_DEVICE(USB_GIGA_VENDOR_ID, USB_3075_PRODUCT_ID) },
58 { USB_DEVICE(USB_GIGA_VENDOR_ID, USB_SX303_PRODUCT_ID) },
59 { USB_DEVICE(USB_GIGA_VENDOR_ID, USB_SX353_PRODUCT_ID) },
60 { } /* Terminating entry */
61 };
62
63 MODULE_DEVICE_TABLE(usb, gigaset_table);
64
65 /*======================= local function prototypes ==========================*/
66
67 /* function called if a new device belonging to this driver is connected */
68 static int gigaset_probe(struct usb_interface *interface,
69 const struct usb_device_id *id);
70
71 /* Function will be called if the device is unplugged */
72 static void gigaset_disconnect(struct usb_interface *interface);
73
74 /* functions called before/after suspend */
75 static int gigaset_suspend(struct usb_interface *intf, pm_message_t message);
76 static int gigaset_resume(struct usb_interface *intf);
77
78 /* functions called before/after device reset */
79 static int gigaset_pre_reset(struct usb_interface *intf);
80 static int gigaset_post_reset(struct usb_interface *intf);
81
82 static int atread_submit(struct cardstate *, int);
83 static void stopurbs(struct bas_bc_state *);
84 static int req_submit(struct bc_state *, int, int, int);
85 static int atwrite_submit(struct cardstate *, unsigned char *, int);
86 static int start_cbsend(struct cardstate *);
87
88 /*============================================================================*/
89
90 struct bas_cardstate {
91 struct usb_device *udev; /* USB device pointer */
92 struct usb_interface *interface; /* interface for this device */
93 unsigned char minor; /* starting minor number */
94
95 struct urb *urb_ctrl; /* control pipe default URB */
96 struct usb_ctrlrequest dr_ctrl;
97 struct timer_list timer_ctrl; /* control request timeout */
98 int retry_ctrl;
99
100 struct timer_list timer_atrdy; /* AT command ready timeout */
101 struct urb *urb_cmd_out; /* for sending AT commands */
102 struct usb_ctrlrequest dr_cmd_out;
103 int retry_cmd_out;
104
105 struct urb *urb_cmd_in; /* for receiving AT replies */
106 struct usb_ctrlrequest dr_cmd_in;
107 struct timer_list timer_cmd_in; /* receive request timeout */
108 unsigned char *rcvbuf; /* AT reply receive buffer */
109
110 struct urb *urb_int_in; /* URB for interrupt pipe */
111 unsigned char *int_in_buf;
112 struct work_struct int_in_wq; /* for usb_clear_halt() */
113 struct timer_list timer_int_in; /* int read retry delay */
114 int retry_int_in;
115
116 spinlock_t lock; /* locks all following */
117 int basstate; /* bitmap (BS_*) */
118 int pending; /* uncompleted base request */
119 wait_queue_head_t waitqueue;
120 int rcvbuf_size; /* size of AT receive buffer */
121 /* 0: no receive in progress */
122 int retry_cmd_in; /* receive req retry count */
123 };
124
125 /* status of direct USB connection to 307x base (bits in basstate) */
126 #define BS_ATOPEN 0x001 /* AT channel open */
127 #define BS_B1OPEN 0x002 /* B channel 1 open */
128 #define BS_B2OPEN 0x004 /* B channel 2 open */
129 #define BS_ATREADY 0x008 /* base ready for AT command */
130 #define BS_INIT 0x010 /* base has signalled INIT_OK */
131 #define BS_ATTIMER 0x020 /* waiting for HD_READY_SEND_ATDATA */
132 #define BS_ATRDPEND 0x040 /* urb_cmd_in in use */
133 #define BS_ATWRPEND 0x080 /* urb_cmd_out in use */
134 #define BS_SUSPEND 0x100 /* USB port suspended */
135 #define BS_RESETTING 0x200 /* waiting for HD_RESET_INTERRUPT_PIPE_ACK */
136
137
138 static struct gigaset_driver *driver;
139
140 /* usb specific object needed to register this driver with the usb subsystem */
141 static struct usb_driver gigaset_usb_driver = {
142 .name = GIGASET_MODULENAME,
143 .probe = gigaset_probe,
144 .disconnect = gigaset_disconnect,
145 .id_table = gigaset_table,
146 .suspend = gigaset_suspend,
147 .resume = gigaset_resume,
148 .reset_resume = gigaset_post_reset,
149 .pre_reset = gigaset_pre_reset,
150 .post_reset = gigaset_post_reset,
151 .disable_hub_initiated_lpm = 1,
152 };
153
154 /* get message text for usb_submit_urb return code
155 */
156 static char *get_usb_rcmsg(int rc)
157 {
158 static char unkmsg[28];
159
160 switch (rc) {
161 case 0:
162 return "success";
163 case -ENOMEM:
164 return "out of memory";
165 case -ENODEV:
166 return "device not present";
167 case -ENOENT:
168 return "endpoint not present";
169 case -ENXIO:
170 return "URB type not supported";
171 case -EINVAL:
172 return "invalid argument";
173 case -EAGAIN:
174 return "start frame too early or too much scheduled";
175 case -EFBIG:
176 return "too many isoc frames requested";
177 case -EPIPE:
178 return "endpoint stalled";
179 case -EMSGSIZE:
180 return "invalid packet size";
181 case -ENOSPC:
182 return "would overcommit USB bandwidth";
183 case -ESHUTDOWN:
184 return "device shut down";
185 case -EPERM:
186 return "reject flag set";
187 case -EHOSTUNREACH:
188 return "device suspended";
189 default:
190 snprintf(unkmsg, sizeof(unkmsg), "unknown error %d", rc);
191 return unkmsg;
192 }
193 }
194
195 /* get message text for USB status code
196 */
197 static char *get_usb_statmsg(int status)
198 {
199 static char unkmsg[28];
200
201 switch (status) {
202 case 0:
203 return "success";
204 case -ENOENT:
205 return "unlinked (sync)";
206 case -EINPROGRESS:
207 return "URB still pending";
208 case -EPROTO:
209 return "bitstuff error, timeout, or unknown USB error";
210 case -EILSEQ:
211 return "CRC mismatch, timeout, or unknown USB error";
212 case -ETIME:
213 return "USB response timeout";
214 case -EPIPE:
215 return "endpoint stalled";
216 case -ECOMM:
217 return "IN buffer overrun";
218 case -ENOSR:
219 return "OUT buffer underrun";
220 case -EOVERFLOW:
221 return "endpoint babble";
222 case -EREMOTEIO:
223 return "short packet";
224 case -ENODEV:
225 return "device removed";
226 case -EXDEV:
227 return "partial isoc transfer";
228 case -EINVAL:
229 return "ISO madness";
230 case -ECONNRESET:
231 return "unlinked (async)";
232 case -ESHUTDOWN:
233 return "device shut down";
234 default:
235 snprintf(unkmsg, sizeof(unkmsg), "unknown status %d", status);
236 return unkmsg;
237 }
238 }
239
240 /* usb_pipetype_str
241 * retrieve string representation of USB pipe type
242 */
243 static inline char *usb_pipetype_str(int pipe)
244 {
245 if (usb_pipeisoc(pipe))
246 return "Isoc";
247 if (usb_pipeint(pipe))
248 return "Int";
249 if (usb_pipecontrol(pipe))
250 return "Ctrl";
251 if (usb_pipebulk(pipe))
252 return "Bulk";
253 return "?";
254 }
255
256 /* dump_urb
257 * write content of URB to syslog for debugging
258 */
259 static inline void dump_urb(enum debuglevel level, const char *tag,
260 struct urb *urb)
261 {
262 #ifdef CONFIG_GIGASET_DEBUG
263 int i;
264 gig_dbg(level, "%s urb(0x%08lx)->{", tag, (unsigned long) urb);
265 if (urb) {
266 gig_dbg(level,
267 " dev=0x%08lx, pipe=%s:EP%d/DV%d:%s, "
268 "hcpriv=0x%08lx, transfer_flags=0x%x,",
269 (unsigned long) urb->dev,
270 usb_pipetype_str(urb->pipe),
271 usb_pipeendpoint(urb->pipe), usb_pipedevice(urb->pipe),
272 usb_pipein(urb->pipe) ? "in" : "out",
273 (unsigned long) urb->hcpriv,
274 urb->transfer_flags);
275 gig_dbg(level,
276 " transfer_buffer=0x%08lx[%d], actual_length=%d, "
277 "setup_packet=0x%08lx,",
278 (unsigned long) urb->transfer_buffer,
279 urb->transfer_buffer_length, urb->actual_length,
280 (unsigned long) urb->setup_packet);
281 gig_dbg(level,
282 " start_frame=%d, number_of_packets=%d, interval=%d, "
283 "error_count=%d,",
284 urb->start_frame, urb->number_of_packets, urb->interval,
285 urb->error_count);
286 gig_dbg(level,
287 " context=0x%08lx, complete=0x%08lx, "
288 "iso_frame_desc[]={",
289 (unsigned long) urb->context,
290 (unsigned long) urb->complete);
291 for (i = 0; i < urb->number_of_packets; i++) {
292 struct usb_iso_packet_descriptor *pifd
293 = &urb->iso_frame_desc[i];
294 gig_dbg(level,
295 " {offset=%u, length=%u, actual_length=%u, "
296 "status=%u}",
297 pifd->offset, pifd->length, pifd->actual_length,
298 pifd->status);
299 }
300 }
301 gig_dbg(level, "}}");
302 #endif
303 }
304
305 /* read/set modem control bits etc. (m10x only) */
306 static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
307 unsigned new_state)
308 {
309 return -EINVAL;
310 }
311
312 static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag)
313 {
314 return -EINVAL;
315 }
316
317 static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
318 {
319 return -EINVAL;
320 }
321
322 /* set/clear bits in base connection state, return previous state
323 */
324 static inline int update_basstate(struct bas_cardstate *ucs,
325 int set, int clear)
326 {
327 unsigned long flags;
328 int state;
329
330 spin_lock_irqsave(&ucs->lock, flags);
331 state = ucs->basstate;
332 ucs->basstate = (state & ~clear) | set;
333 spin_unlock_irqrestore(&ucs->lock, flags);
334 return state;
335 }
336
337 /* error_hangup
338 * hang up any existing connection because of an unrecoverable error
339 * This function may be called from any context and takes care of scheduling
340 * the necessary actions for execution outside of interrupt context.
341 * cs->lock must not be held.
342 * argument:
343 * B channel control structure
344 */
345 static inline void error_hangup(struct bc_state *bcs)
346 {
347 struct cardstate *cs = bcs->cs;
348
349 gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL);
350 gigaset_schedule_event(cs);
351 }
352
353 /* error_reset
354 * reset Gigaset device because of an unrecoverable error
355 * This function may be called from any context, and takes care of
356 * scheduling the necessary actions for execution outside of interrupt context.
357 * cs->hw.bas->lock must not be held.
358 * argument:
359 * controller state structure
360 */
361 static inline void error_reset(struct cardstate *cs)
362 {
363 /* reset interrupt pipe to recover (ignore errors) */
364 update_basstate(cs->hw.bas, BS_RESETTING, 0);
365 if (req_submit(cs->bcs, HD_RESET_INTERRUPT_PIPE, 0, BAS_TIMEOUT))
366 /* submission failed, escalate to USB port reset */
367 usb_queue_reset_device(cs->hw.bas->interface);
368 }
369
370 /* check_pending
371 * check for completion of pending control request
372 * parameter:
373 * ucs hardware specific controller state structure
374 */
375 static void check_pending(struct bas_cardstate *ucs)
376 {
377 unsigned long flags;
378
379 spin_lock_irqsave(&ucs->lock, flags);
380 switch (ucs->pending) {
381 case 0:
382 break;
383 case HD_OPEN_ATCHANNEL:
384 if (ucs->basstate & BS_ATOPEN)
385 ucs->pending = 0;
386 break;
387 case HD_OPEN_B1CHANNEL:
388 if (ucs->basstate & BS_B1OPEN)
389 ucs->pending = 0;
390 break;
391 case HD_OPEN_B2CHANNEL:
392 if (ucs->basstate & BS_B2OPEN)
393 ucs->pending = 0;
394 break;
395 case HD_CLOSE_ATCHANNEL:
396 if (!(ucs->basstate & BS_ATOPEN))
397 ucs->pending = 0;
398 break;
399 case HD_CLOSE_B1CHANNEL:
400 if (!(ucs->basstate & BS_B1OPEN))
401 ucs->pending = 0;
402 break;
403 case HD_CLOSE_B2CHANNEL:
404 if (!(ucs->basstate & BS_B2OPEN))
405 ucs->pending = 0;
406 break;
407 case HD_DEVICE_INIT_ACK: /* no reply expected */
408 ucs->pending = 0;
409 break;
410 case HD_RESET_INTERRUPT_PIPE:
411 if (!(ucs->basstate & BS_RESETTING))
412 ucs->pending = 0;
413 break;
414 /*
415 * HD_READ_ATMESSAGE and HD_WRITE_ATMESSAGE are handled separately
416 * and should never end up here
417 */
418 default:
419 dev_warn(&ucs->interface->dev,
420 "unknown pending request 0x%02x cleared\n",
421 ucs->pending);
422 ucs->pending = 0;
423 }
424
425 if (!ucs->pending)
426 del_timer(&ucs->timer_ctrl);
427
428 spin_unlock_irqrestore(&ucs->lock, flags);
429 }
430
431 /* cmd_in_timeout
432 * timeout routine for command input request
433 * argument:
434 * controller state structure
435 */
436 static void cmd_in_timeout(unsigned long data)
437 {
438 struct cardstate *cs = (struct cardstate *) data;
439 struct bas_cardstate *ucs = cs->hw.bas;
440 int rc;
441
442 if (!ucs->rcvbuf_size) {
443 gig_dbg(DEBUG_USBREQ, "%s: no receive in progress", __func__);
444 return;
445 }
446
447 if (ucs->retry_cmd_in++ >= BAS_RETRY) {
448 dev_err(cs->dev,
449 "control read: timeout, giving up after %d tries\n",
450 ucs->retry_cmd_in);
451 kfree(ucs->rcvbuf);
452 ucs->rcvbuf = NULL;
453 ucs->rcvbuf_size = 0;
454 error_reset(cs);
455 return;
456 }
457
458 gig_dbg(DEBUG_USBREQ, "%s: timeout, retry %d",
459 __func__, ucs->retry_cmd_in);
460 rc = atread_submit(cs, BAS_TIMEOUT);
461 if (rc < 0) {
462 kfree(ucs->rcvbuf);
463 ucs->rcvbuf = NULL;
464 ucs->rcvbuf_size = 0;
465 if (rc != -ENODEV)
466 error_reset(cs);
467 }
468 }
469
470 /* read_ctrl_callback
471 * USB completion handler for control pipe input
472 * called by the USB subsystem in interrupt context
473 * parameter:
474 * urb USB request block
475 * urb->context = inbuf structure for controller state
476 */
477 static void read_ctrl_callback(struct urb *urb)
478 {
479 struct inbuf_t *inbuf = urb->context;
480 struct cardstate *cs = inbuf->cs;
481 struct bas_cardstate *ucs = cs->hw.bas;
482 int status = urb->status;
483 unsigned numbytes;
484 int rc;
485
486 update_basstate(ucs, 0, BS_ATRDPEND);
487 wake_up(&ucs->waitqueue);
488 del_timer(&ucs->timer_cmd_in);
489
490 switch (status) {
491 case 0: /* normal completion */
492 numbytes = urb->actual_length;
493 if (unlikely(numbytes != ucs->rcvbuf_size)) {
494 dev_warn(cs->dev,
495 "control read: received %d chars, expected %d\n",
496 numbytes, ucs->rcvbuf_size);
497 if (numbytes > ucs->rcvbuf_size)
498 numbytes = ucs->rcvbuf_size;
499 }
500
501 /* copy received bytes to inbuf, notify event layer */
502 if (gigaset_fill_inbuf(inbuf, ucs->rcvbuf, numbytes)) {
503 gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
504 gigaset_schedule_event(cs);
505 }
506 break;
507
508 case -ENOENT: /* cancelled */
509 case -ECONNRESET: /* cancelled (async) */
510 case -EINPROGRESS: /* pending */
511 case -ENODEV: /* device removed */
512 case -ESHUTDOWN: /* device shut down */
513 /* no further action necessary */
514 gig_dbg(DEBUG_USBREQ, "%s: %s",
515 __func__, get_usb_statmsg(status));
516 break;
517
518 default: /* other errors: retry */
519 if (ucs->retry_cmd_in++ < BAS_RETRY) {
520 gig_dbg(DEBUG_USBREQ, "%s: %s, retry %d", __func__,
521 get_usb_statmsg(status), ucs->retry_cmd_in);
522 rc = atread_submit(cs, BAS_TIMEOUT);
523 if (rc >= 0)
524 /* successfully resubmitted, skip freeing */
525 return;
526 if (rc == -ENODEV)
527 /* disconnect, no further action necessary */
528 break;
529 }
530 dev_err(cs->dev, "control read: %s, giving up after %d tries\n",
531 get_usb_statmsg(status), ucs->retry_cmd_in);
532 error_reset(cs);
533 }
534
535 /* read finished, free buffer */
536 kfree(ucs->rcvbuf);
537 ucs->rcvbuf = NULL;
538 ucs->rcvbuf_size = 0;
539 }
540
541 /* atread_submit
542 * submit an HD_READ_ATMESSAGE command URB and optionally start a timeout
543 * parameters:
544 * cs controller state structure
545 * timeout timeout in 1/10 sec., 0: none
546 * return value:
547 * 0 on success
548 * -EBUSY if another request is pending
549 * any URB submission error code
550 */
551 static int atread_submit(struct cardstate *cs, int timeout)
552 {
553 struct bas_cardstate *ucs = cs->hw.bas;
554 int basstate;
555 int ret;
556
557 gig_dbg(DEBUG_USBREQ, "-------> HD_READ_ATMESSAGE (%d)",
558 ucs->rcvbuf_size);
559
560 basstate = update_basstate(ucs, BS_ATRDPEND, 0);
561 if (basstate & BS_ATRDPEND) {
562 dev_err(cs->dev,
563 "could not submit HD_READ_ATMESSAGE: URB busy\n");
564 return -EBUSY;
565 }
566
567 if (basstate & BS_SUSPEND) {
568 dev_notice(cs->dev,
569 "HD_READ_ATMESSAGE not submitted, "
570 "suspend in progress\n");
571 update_basstate(ucs, 0, BS_ATRDPEND);
572 /* treat like disconnect */
573 return -ENODEV;
574 }
575
576 ucs->dr_cmd_in.bRequestType = IN_VENDOR_REQ;
577 ucs->dr_cmd_in.bRequest = HD_READ_ATMESSAGE;
578 ucs->dr_cmd_in.wValue = 0;
579 ucs->dr_cmd_in.wIndex = 0;
580 ucs->dr_cmd_in.wLength = cpu_to_le16(ucs->rcvbuf_size);
581 usb_fill_control_urb(ucs->urb_cmd_in, ucs->udev,
582 usb_rcvctrlpipe(ucs->udev, 0),
583 (unsigned char *) &ucs->dr_cmd_in,
584 ucs->rcvbuf, ucs->rcvbuf_size,
585 read_ctrl_callback, cs->inbuf);
586
587 ret = usb_submit_urb(ucs->urb_cmd_in, GFP_ATOMIC);
588 if (ret != 0) {
589 update_basstate(ucs, 0, BS_ATRDPEND);
590 dev_err(cs->dev, "could not submit HD_READ_ATMESSAGE: %s\n",
591 get_usb_rcmsg(ret));
592 return ret;
593 }
594
595 if (timeout > 0) {
596 gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
597 mod_timer(&ucs->timer_cmd_in, jiffies + timeout * HZ / 10);
598 }
599 return 0;
600 }
601
602 /* int_in_work
603 * workqueue routine to clear halt on interrupt in endpoint
604 */
605
606 static void int_in_work(struct work_struct *work)
607 {
608 struct bas_cardstate *ucs =
609 container_of(work, struct bas_cardstate, int_in_wq);
610 struct urb *urb = ucs->urb_int_in;
611 struct cardstate *cs = urb->context;
612 int rc;
613
614 /* clear halt condition */
615 rc = usb_clear_halt(ucs->udev, urb->pipe);
616 gig_dbg(DEBUG_USBREQ, "clear_halt: %s", get_usb_rcmsg(rc));
617 if (rc == 0)
618 /* success, resubmit interrupt read URB */
619 rc = usb_submit_urb(urb, GFP_ATOMIC);
620
621 switch (rc) {
622 case 0: /* success */
623 case -ENODEV: /* device gone */
624 case -EINVAL: /* URB already resubmitted, or terminal badness */
625 break;
626 default: /* failure: try to recover by resetting the device */
627 dev_err(cs->dev, "clear halt failed: %s\n", get_usb_rcmsg(rc));
628 rc = usb_lock_device_for_reset(ucs->udev, ucs->interface);
629 if (rc == 0) {
630 rc = usb_reset_device(ucs->udev);
631 usb_unlock_device(ucs->udev);
632 }
633 }
634 ucs->retry_int_in = 0;
635 }
636
637 /* int_in_resubmit
638 * timer routine for interrupt read delayed resubmit
639 * argument:
640 * controller state structure
641 */
642 static void int_in_resubmit(unsigned long data)
643 {
644 struct cardstate *cs = (struct cardstate *) data;
645 struct bas_cardstate *ucs = cs->hw.bas;
646 int rc;
647
648 if (ucs->retry_int_in++ >= BAS_RETRY) {
649 dev_err(cs->dev, "interrupt read: giving up after %d tries\n",
650 ucs->retry_int_in);
651 usb_queue_reset_device(ucs->interface);
652 return;
653 }
654
655 gig_dbg(DEBUG_USBREQ, "%s: retry %d", __func__, ucs->retry_int_in);
656 rc = usb_submit_urb(ucs->urb_int_in, GFP_ATOMIC);
657 if (rc != 0 && rc != -ENODEV) {
658 dev_err(cs->dev, "could not resubmit interrupt URB: %s\n",
659 get_usb_rcmsg(rc));
660 usb_queue_reset_device(ucs->interface);
661 }
662 }
663
664 /* read_int_callback
665 * USB completion handler for interrupt pipe input
666 * called by the USB subsystem in interrupt context
667 * parameter:
668 * urb USB request block
669 * urb->context = controller state structure
670 */
671 static void read_int_callback(struct urb *urb)
672 {
673 struct cardstate *cs = urb->context;
674 struct bas_cardstate *ucs = cs->hw.bas;
675 struct bc_state *bcs;
676 int status = urb->status;
677 unsigned long flags;
678 int rc;
679 unsigned l;
680 int channel;
681
682 switch (status) {
683 case 0: /* success */
684 ucs->retry_int_in = 0;
685 break;
686 case -EPIPE: /* endpoint stalled */
687 schedule_work(&ucs->int_in_wq);
688 /* fall through */
689 case -ENOENT: /* cancelled */
690 case -ECONNRESET: /* cancelled (async) */
691 case -EINPROGRESS: /* pending */
692 case -ENODEV: /* device removed */
693 case -ESHUTDOWN: /* device shut down */
694 /* no further action necessary */
695 gig_dbg(DEBUG_USBREQ, "%s: %s",
696 __func__, get_usb_statmsg(status));
697 return;
698 case -EPROTO: /* protocol error or unplug */
699 case -EILSEQ:
700 case -ETIME:
701 /* resubmit after delay */
702 gig_dbg(DEBUG_USBREQ, "%s: %s",
703 __func__, get_usb_statmsg(status));
704 mod_timer(&ucs->timer_int_in, jiffies + HZ / 10);
705 return;
706 default: /* other errors: just resubmit */
707 dev_warn(cs->dev, "interrupt read: %s\n",
708 get_usb_statmsg(status));
709 goto resubmit;
710 }
711
712 /* drop incomplete packets even if the missing bytes wouldn't matter */
713 if (unlikely(urb->actual_length < IP_MSGSIZE)) {
714 dev_warn(cs->dev, "incomplete interrupt packet (%d bytes)\n",
715 urb->actual_length);
716 goto resubmit;
717 }
718
719 l = (unsigned) ucs->int_in_buf[1] +
720 (((unsigned) ucs->int_in_buf[2]) << 8);
721
722 gig_dbg(DEBUG_USBREQ, "<-------%d: 0x%02x (%u [0x%02x 0x%02x])",
723 urb->actual_length, (int)ucs->int_in_buf[0], l,
724 (int)ucs->int_in_buf[1], (int)ucs->int_in_buf[2]);
725
726 channel = 0;
727
728 switch (ucs->int_in_buf[0]) {
729 case HD_DEVICE_INIT_OK:
730 update_basstate(ucs, BS_INIT, 0);
731 break;
732
733 case HD_READY_SEND_ATDATA:
734 del_timer(&ucs->timer_atrdy);
735 update_basstate(ucs, BS_ATREADY, BS_ATTIMER);
736 start_cbsend(cs);
737 break;
738
739 case HD_OPEN_B2CHANNEL_ACK:
740 ++channel;
741 case HD_OPEN_B1CHANNEL_ACK:
742 bcs = cs->bcs + channel;
743 update_basstate(ucs, BS_B1OPEN << channel, 0);
744 gigaset_bchannel_up(bcs);
745 break;
746
747 case HD_OPEN_ATCHANNEL_ACK:
748 update_basstate(ucs, BS_ATOPEN, 0);
749 start_cbsend(cs);
750 break;
751
752 case HD_CLOSE_B2CHANNEL_ACK:
753 ++channel;
754 case HD_CLOSE_B1CHANNEL_ACK:
755 bcs = cs->bcs + channel;
756 update_basstate(ucs, 0, BS_B1OPEN << channel);
757 stopurbs(bcs->hw.bas);
758 gigaset_bchannel_down(bcs);
759 break;
760
761 case HD_CLOSE_ATCHANNEL_ACK:
762 update_basstate(ucs, 0, BS_ATOPEN);
763 break;
764
765 case HD_B2_FLOW_CONTROL:
766 ++channel;
767 case HD_B1_FLOW_CONTROL:
768 bcs = cs->bcs + channel;
769 atomic_add((l - BAS_NORMFRAME) * BAS_CORRFRAMES,
770 &bcs->hw.bas->corrbytes);
771 gig_dbg(DEBUG_ISO,
772 "Flow control (channel %d, sub %d): 0x%02x => %d",
773 channel, bcs->hw.bas->numsub, l,
774 atomic_read(&bcs->hw.bas->corrbytes));
775 break;
776
777 case HD_RECEIVEATDATA_ACK: /* AT response ready to be received */
778 if (!l) {
779 dev_warn(cs->dev,
780 "HD_RECEIVEATDATA_ACK with length 0 ignored\n");
781 break;
782 }
783 spin_lock_irqsave(&cs->lock, flags);
784 if (ucs->basstate & BS_ATRDPEND) {
785 spin_unlock_irqrestore(&cs->lock, flags);
786 dev_warn(cs->dev,
787 "HD_RECEIVEATDATA_ACK(%d) during HD_READ_ATMESSAGE(%d) ignored\n",
788 l, ucs->rcvbuf_size);
789 break;
790 }
791 if (ucs->rcvbuf_size) {
792 /* throw away previous buffer - we have no queue */
793 dev_err(cs->dev,
794 "receive AT data overrun, %d bytes lost\n",
795 ucs->rcvbuf_size);
796 kfree(ucs->rcvbuf);
797 ucs->rcvbuf_size = 0;
798 }
799 ucs->rcvbuf = kmalloc(l, GFP_ATOMIC);
800 if (ucs->rcvbuf == NULL) {
801 spin_unlock_irqrestore(&cs->lock, flags);
802 dev_err(cs->dev, "out of memory receiving AT data\n");
803 break;
804 }
805 ucs->rcvbuf_size = l;
806 ucs->retry_cmd_in = 0;
807 rc = atread_submit(cs, BAS_TIMEOUT);
808 if (rc < 0) {
809 kfree(ucs->rcvbuf);
810 ucs->rcvbuf = NULL;
811 ucs->rcvbuf_size = 0;
812 }
813 spin_unlock_irqrestore(&cs->lock, flags);
814 if (rc < 0 && rc != -ENODEV)
815 error_reset(cs);
816 break;
817
818 case HD_RESET_INTERRUPT_PIPE_ACK:
819 update_basstate(ucs, 0, BS_RESETTING);
820 dev_notice(cs->dev, "interrupt pipe reset\n");
821 break;
822
823 case HD_SUSPEND_END:
824 gig_dbg(DEBUG_USBREQ, "HD_SUSPEND_END");
825 break;
826
827 default:
828 dev_warn(cs->dev,
829 "unknown Gigaset signal 0x%02x (%u) ignored\n",
830 (int) ucs->int_in_buf[0], l);
831 }
832
833 check_pending(ucs);
834 wake_up(&ucs->waitqueue);
835
836 resubmit:
837 rc = usb_submit_urb(urb, GFP_ATOMIC);
838 if (unlikely(rc != 0 && rc != -ENODEV)) {
839 dev_err(cs->dev, "could not resubmit interrupt URB: %s\n",
840 get_usb_rcmsg(rc));
841 error_reset(cs);
842 }
843 }
844
845 /* read_iso_callback
846 * USB completion handler for B channel isochronous input
847 * called by the USB subsystem in interrupt context
848 * parameter:
849 * urb USB request block of completed request
850 * urb->context = bc_state structure
851 */
852 static void read_iso_callback(struct urb *urb)
853 {
854 struct bc_state *bcs;
855 struct bas_bc_state *ubc;
856 int status = urb->status;
857 unsigned long flags;
858 int i, rc;
859
860 /* status codes not worth bothering the tasklet with */
861 if (unlikely(status == -ENOENT ||
862 status == -ECONNRESET ||
863 status == -EINPROGRESS ||
864 status == -ENODEV ||
865 status == -ESHUTDOWN)) {
866 gig_dbg(DEBUG_ISO, "%s: %s",
867 __func__, get_usb_statmsg(status));
868 return;
869 }
870
871 bcs = urb->context;
872 ubc = bcs->hw.bas;
873
874 spin_lock_irqsave(&ubc->isoinlock, flags);
875 if (likely(ubc->isoindone == NULL)) {
876 /* pass URB to tasklet */
877 ubc->isoindone = urb;
878 ubc->isoinstatus = status;
879 tasklet_hi_schedule(&ubc->rcvd_tasklet);
880 } else {
881 /* tasklet still busy, drop data and resubmit URB */
882 gig_dbg(DEBUG_ISO, "%s: overrun", __func__);
883 ubc->loststatus = status;
884 for (i = 0; i < BAS_NUMFRAMES; i++) {
885 ubc->isoinlost += urb->iso_frame_desc[i].actual_length;
886 if (unlikely(urb->iso_frame_desc[i].status != 0 &&
887 urb->iso_frame_desc[i].status != -EINPROGRESS))
888 ubc->loststatus = urb->iso_frame_desc[i].status;
889 urb->iso_frame_desc[i].status = 0;
890 urb->iso_frame_desc[i].actual_length = 0;
891 }
892 if (likely(ubc->running)) {
893 /* urb->dev is clobbered by USB subsystem */
894 urb->dev = bcs->cs->hw.bas->udev;
895 urb->transfer_flags = URB_ISO_ASAP;
896 urb->number_of_packets = BAS_NUMFRAMES;
897 rc = usb_submit_urb(urb, GFP_ATOMIC);
898 if (unlikely(rc != 0 && rc != -ENODEV)) {
899 dev_err(bcs->cs->dev,
900 "could not resubmit isoc read URB: %s\n",
901 get_usb_rcmsg(rc));
902 dump_urb(DEBUG_ISO, "isoc read", urb);
903 error_hangup(bcs);
904 }
905 }
906 }
907 spin_unlock_irqrestore(&ubc->isoinlock, flags);
908 }
909
910 /* write_iso_callback
911 * USB completion handler for B channel isochronous output
912 * called by the USB subsystem in interrupt context
913 * parameter:
914 * urb USB request block of completed request
915 * urb->context = isow_urbctx_t structure
916 */
917 static void write_iso_callback(struct urb *urb)
918 {
919 struct isow_urbctx_t *ucx;
920 struct bas_bc_state *ubc;
921 int status = urb->status;
922 unsigned long flags;
923
924 /* status codes not worth bothering the tasklet with */
925 if (unlikely(status == -ENOENT ||
926 status == -ECONNRESET ||
927 status == -EINPROGRESS ||
928 status == -ENODEV ||
929 status == -ESHUTDOWN)) {
930 gig_dbg(DEBUG_ISO, "%s: %s",
931 __func__, get_usb_statmsg(status));
932 return;
933 }
934
935 /* pass URB context to tasklet */
936 ucx = urb->context;
937 ubc = ucx->bcs->hw.bas;
938 ucx->status = status;
939
940 spin_lock_irqsave(&ubc->isooutlock, flags);
941 ubc->isooutovfl = ubc->isooutdone;
942 ubc->isooutdone = ucx;
943 spin_unlock_irqrestore(&ubc->isooutlock, flags);
944 tasklet_hi_schedule(&ubc->sent_tasklet);
945 }
946
947 /* starturbs
948 * prepare and submit USB request blocks for isochronous input and output
949 * argument:
950 * B channel control structure
951 * return value:
952 * 0 on success
953 * < 0 on error (no URBs submitted)
954 */
955 static int starturbs(struct bc_state *bcs)
956 {
957 struct bas_bc_state *ubc = bcs->hw.bas;
958 struct urb *urb;
959 int j, k;
960 int rc;
961
962 /* initialize L2 reception */
963 if (bcs->proto2 == L2_HDLC)
964 bcs->inputstate |= INS_flag_hunt;
965
966 /* submit all isochronous input URBs */
967 ubc->running = 1;
968 for (k = 0; k < BAS_INURBS; k++) {
969 urb = ubc->isoinurbs[k];
970 if (!urb) {
971 rc = -EFAULT;
972 goto error;
973 }
974
975 urb->dev = bcs->cs->hw.bas->udev;
976 urb->pipe = usb_rcvisocpipe(urb->dev, 3 + 2 * bcs->channel);
977 urb->transfer_flags = URB_ISO_ASAP;
978 urb->transfer_buffer = ubc->isoinbuf + k * BAS_INBUFSIZE;
979 urb->transfer_buffer_length = BAS_INBUFSIZE;
980 urb->number_of_packets = BAS_NUMFRAMES;
981 urb->interval = BAS_FRAMETIME;
982 urb->complete = read_iso_callback;
983 urb->context = bcs;
984 for (j = 0; j < BAS_NUMFRAMES; j++) {
985 urb->iso_frame_desc[j].offset = j * BAS_MAXFRAME;
986 urb->iso_frame_desc[j].length = BAS_MAXFRAME;
987 urb->iso_frame_desc[j].status = 0;
988 urb->iso_frame_desc[j].actual_length = 0;
989 }
990
991 dump_urb(DEBUG_ISO, "Initial isoc read", urb);
992 rc = usb_submit_urb(urb, GFP_ATOMIC);
993 if (rc != 0)
994 goto error;
995 }
996
997 /* initialize L2 transmission */
998 gigaset_isowbuf_init(ubc->isooutbuf, PPP_FLAG);
999
1000 /* set up isochronous output URBs for flag idling */
1001 for (k = 0; k < BAS_OUTURBS; ++k) {
1002 urb = ubc->isoouturbs[k].urb;
1003 if (!urb) {
1004 rc = -EFAULT;
1005 goto error;
1006 }
1007 urb->dev = bcs->cs->hw.bas->udev;
1008 urb->pipe = usb_sndisocpipe(urb->dev, 4 + 2 * bcs->channel);
1009 urb->transfer_flags = URB_ISO_ASAP;
1010 urb->transfer_buffer = ubc->isooutbuf->data;
1011 urb->transfer_buffer_length = sizeof(ubc->isooutbuf->data);
1012 urb->number_of_packets = BAS_NUMFRAMES;
1013 urb->interval = BAS_FRAMETIME;
1014 urb->complete = write_iso_callback;
1015 urb->context = &ubc->isoouturbs[k];
1016 for (j = 0; j < BAS_NUMFRAMES; ++j) {
1017 urb->iso_frame_desc[j].offset = BAS_OUTBUFSIZE;
1018 urb->iso_frame_desc[j].length = BAS_NORMFRAME;
1019 urb->iso_frame_desc[j].status = 0;
1020 urb->iso_frame_desc[j].actual_length = 0;
1021 }
1022 ubc->isoouturbs[k].limit = -1;
1023 }
1024
1025 /* keep one URB free, submit the others */
1026 for (k = 0; k < BAS_OUTURBS - 1; ++k) {
1027 dump_urb(DEBUG_ISO, "Initial isoc write", urb);
1028 rc = usb_submit_urb(ubc->isoouturbs[k].urb, GFP_ATOMIC);
1029 if (rc != 0)
1030 goto error;
1031 }
1032 dump_urb(DEBUG_ISO, "Initial isoc write (free)", urb);
1033 ubc->isooutfree = &ubc->isoouturbs[BAS_OUTURBS - 1];
1034 ubc->isooutdone = ubc->isooutovfl = NULL;
1035 return 0;
1036 error:
1037 stopurbs(ubc);
1038 return rc;
1039 }
1040
1041 /* stopurbs
1042 * cancel the USB request blocks for isochronous input and output
1043 * errors are silently ignored
1044 * argument:
1045 * B channel control structure
1046 */
1047 static void stopurbs(struct bas_bc_state *ubc)
1048 {
1049 int k, rc;
1050
1051 ubc->running = 0;
1052
1053 for (k = 0; k < BAS_INURBS; ++k) {
1054 rc = usb_unlink_urb(ubc->isoinurbs[k]);
1055 gig_dbg(DEBUG_ISO,
1056 "%s: isoc input URB %d unlinked, result = %s",
1057 __func__, k, get_usb_rcmsg(rc));
1058 }
1059
1060 for (k = 0; k < BAS_OUTURBS; ++k) {
1061 rc = usb_unlink_urb(ubc->isoouturbs[k].urb);
1062 gig_dbg(DEBUG_ISO,
1063 "%s: isoc output URB %d unlinked, result = %s",
1064 __func__, k, get_usb_rcmsg(rc));
1065 }
1066 }
1067
1068 /* Isochronous Write - Bottom Half */
1069 /* =============================== */
1070
1071 /* submit_iso_write_urb
1072 * fill and submit the next isochronous write URB
1073 * parameters:
1074 * ucx context structure containing URB
1075 * return value:
1076 * number of frames submitted in URB
1077 * 0 if URB not submitted because no data available (isooutbuf busy)
1078 * error code < 0 on error
1079 */
1080 static int submit_iso_write_urb(struct isow_urbctx_t *ucx)
1081 {
1082 struct urb *urb = ucx->urb;
1083 struct bas_bc_state *ubc = ucx->bcs->hw.bas;
1084 struct usb_iso_packet_descriptor *ifd;
1085 int corrbytes, nframe, rc;
1086
1087 /* urb->dev is clobbered by USB subsystem */
1088 urb->dev = ucx->bcs->cs->hw.bas->udev;
1089 urb->transfer_flags = URB_ISO_ASAP;
1090 urb->transfer_buffer = ubc->isooutbuf->data;
1091 urb->transfer_buffer_length = sizeof(ubc->isooutbuf->data);
1092
1093 for (nframe = 0; nframe < BAS_NUMFRAMES; nframe++) {
1094 ifd = &urb->iso_frame_desc[nframe];
1095
1096 /* compute frame length according to flow control */
1097 ifd->length = BAS_NORMFRAME;
1098 corrbytes = atomic_read(&ubc->corrbytes);
1099 if (corrbytes != 0) {
1100 gig_dbg(DEBUG_ISO, "%s: corrbytes=%d",
1101 __func__, corrbytes);
1102 if (corrbytes > BAS_HIGHFRAME - BAS_NORMFRAME)
1103 corrbytes = BAS_HIGHFRAME - BAS_NORMFRAME;
1104 else if (corrbytes < BAS_LOWFRAME - BAS_NORMFRAME)
1105 corrbytes = BAS_LOWFRAME - BAS_NORMFRAME;
1106 ifd->length += corrbytes;
1107 atomic_add(-corrbytes, &ubc->corrbytes);
1108 }
1109
1110 /* retrieve block of data to send */
1111 rc = gigaset_isowbuf_getbytes(ubc->isooutbuf, ifd->length);
1112 if (rc < 0) {
1113 if (rc == -EBUSY) {
1114 gig_dbg(DEBUG_ISO,
1115 "%s: buffer busy at frame %d",
1116 __func__, nframe);
1117 /* tasklet will be restarted from
1118 gigaset_isoc_send_skb() */
1119 } else {
1120 dev_err(ucx->bcs->cs->dev,
1121 "%s: buffer error %d at frame %d\n",
1122 __func__, rc, nframe);
1123 return rc;
1124 }
1125 break;
1126 }
1127 ifd->offset = rc;
1128 ucx->limit = ubc->isooutbuf->nextread;
1129 ifd->status = 0;
1130 ifd->actual_length = 0;
1131 }
1132 if (unlikely(nframe == 0))
1133 return 0; /* no data to send */
1134 urb->number_of_packets = nframe;
1135
1136 rc = usb_submit_urb(urb, GFP_ATOMIC);
1137 if (unlikely(rc)) {
1138 if (rc == -ENODEV)
1139 /* device removed - give up silently */
1140 gig_dbg(DEBUG_ISO, "%s: disconnected", __func__);
1141 else
1142 dev_err(ucx->bcs->cs->dev,
1143 "could not submit isoc write URB: %s\n",
1144 get_usb_rcmsg(rc));
1145 return rc;
1146 }
1147 ++ubc->numsub;
1148 return nframe;
1149 }
1150
1151 /* write_iso_tasklet
1152 * tasklet scheduled when an isochronous output URB from the Gigaset device
1153 * has completed
1154 * parameter:
1155 * data B channel state structure
1156 */
1157 static void write_iso_tasklet(unsigned long data)
1158 {
1159 struct bc_state *bcs = (struct bc_state *) data;
1160 struct bas_bc_state *ubc = bcs->hw.bas;
1161 struct cardstate *cs = bcs->cs;
1162 struct isow_urbctx_t *done, *next, *ovfl;
1163 struct urb *urb;
1164 int status;
1165 struct usb_iso_packet_descriptor *ifd;
1166 unsigned long flags;
1167 int i;
1168 struct sk_buff *skb;
1169 int len;
1170 int rc;
1171
1172 /* loop while completed URBs arrive in time */
1173 for (;;) {
1174 if (unlikely(!(ubc->running))) {
1175 gig_dbg(DEBUG_ISO, "%s: not running", __func__);
1176 return;
1177 }
1178
1179 /* retrieve completed URBs */
1180 spin_lock_irqsave(&ubc->isooutlock, flags);
1181 done = ubc->isooutdone;
1182 ubc->isooutdone = NULL;
1183 ovfl = ubc->isooutovfl;
1184 ubc->isooutovfl = NULL;
1185 spin_unlock_irqrestore(&ubc->isooutlock, flags);
1186 if (ovfl) {
1187 dev_err(cs->dev, "isoc write underrun\n");
1188 error_hangup(bcs);
1189 break;
1190 }
1191 if (!done)
1192 break;
1193
1194 /* submit free URB if available */
1195 spin_lock_irqsave(&ubc->isooutlock, flags);
1196 next = ubc->isooutfree;
1197 ubc->isooutfree = NULL;
1198 spin_unlock_irqrestore(&ubc->isooutlock, flags);
1199 if (next) {
1200 rc = submit_iso_write_urb(next);
1201 if (unlikely(rc <= 0 && rc != -ENODEV)) {
1202 /* could not submit URB, put it back */
1203 spin_lock_irqsave(&ubc->isooutlock, flags);
1204 if (ubc->isooutfree == NULL) {
1205 ubc->isooutfree = next;
1206 next = NULL;
1207 }
1208 spin_unlock_irqrestore(&ubc->isooutlock, flags);
1209 if (next) {
1210 /* couldn't put it back */
1211 dev_err(cs->dev,
1212 "losing isoc write URB\n");
1213 error_hangup(bcs);
1214 }
1215 }
1216 }
1217
1218 /* process completed URB */
1219 urb = done->urb;
1220 status = done->status;
1221 switch (status) {
1222 case -EXDEV: /* partial completion */
1223 gig_dbg(DEBUG_ISO, "%s: URB partially completed",
1224 __func__);
1225 /* fall through - what's the difference anyway? */
1226 case 0: /* normal completion */
1227 /* inspect individual frames
1228 * assumptions (for lack of documentation):
1229 * - actual_length bytes of first frame in error are
1230 * successfully sent
1231 * - all following frames are not sent at all
1232 */
1233 for (i = 0; i < BAS_NUMFRAMES; i++) {
1234 ifd = &urb->iso_frame_desc[i];
1235 if (ifd->status ||
1236 ifd->actual_length != ifd->length) {
1237 dev_warn(cs->dev,
1238 "isoc write: frame %d[%d/%d]: %s\n",
1239 i, ifd->actual_length,
1240 ifd->length,
1241 get_usb_statmsg(ifd->status));
1242 break;
1243 }
1244 }
1245 break;
1246 case -EPIPE: /* stall - probably underrun */
1247 dev_err(cs->dev, "isoc write: stalled\n");
1248 error_hangup(bcs);
1249 break;
1250 default: /* other errors */
1251 dev_warn(cs->dev, "isoc write: %s\n",
1252 get_usb_statmsg(status));
1253 }
1254
1255 /* mark the write buffer area covered by this URB as free */
1256 if (done->limit >= 0)
1257 ubc->isooutbuf->read = done->limit;
1258
1259 /* mark URB as free */
1260 spin_lock_irqsave(&ubc->isooutlock, flags);
1261 next = ubc->isooutfree;
1262 ubc->isooutfree = done;
1263 spin_unlock_irqrestore(&ubc->isooutlock, flags);
1264 if (next) {
1265 /* only one URB still active - resubmit one */
1266 rc = submit_iso_write_urb(next);
1267 if (unlikely(rc <= 0 && rc != -ENODEV)) {
1268 /* couldn't submit */
1269 error_hangup(bcs);
1270 }
1271 }
1272 }
1273
1274 /* process queued SKBs */
1275 while ((skb = skb_dequeue(&bcs->squeue))) {
1276 /* copy to output buffer, doing L2 encapsulation */
1277 len = skb->len;
1278 if (gigaset_isoc_buildframe(bcs, skb->data, len) == -EAGAIN) {
1279 /* insufficient buffer space, push back onto queue */
1280 skb_queue_head(&bcs->squeue, skb);
1281 gig_dbg(DEBUG_ISO, "%s: skb requeued, qlen=%d",
1282 __func__, skb_queue_len(&bcs->squeue));
1283 break;
1284 }
1285 skb_pull(skb, len);
1286 gigaset_skb_sent(bcs, skb);
1287 dev_kfree_skb_any(skb);
1288 }
1289 }
1290
1291 /* Isochronous Read - Bottom Half */
1292 /* ============================== */
1293
1294 /* read_iso_tasklet
1295 * tasklet scheduled when an isochronous input URB from the Gigaset device
1296 * has completed
1297 * parameter:
1298 * data B channel state structure
1299 */
1300 static void read_iso_tasklet(unsigned long data)
1301 {
1302 struct bc_state *bcs = (struct bc_state *) data;
1303 struct bas_bc_state *ubc = bcs->hw.bas;
1304 struct cardstate *cs = bcs->cs;
1305 struct urb *urb;
1306 int status;
1307 struct usb_iso_packet_descriptor *ifd;
1308 char *rcvbuf;
1309 unsigned long flags;
1310 int totleft, numbytes, offset, frame, rc;
1311
1312 /* loop while more completed URBs arrive in the meantime */
1313 for (;;) {
1314 /* retrieve URB */
1315 spin_lock_irqsave(&ubc->isoinlock, flags);
1316 urb = ubc->isoindone;
1317 if (!urb) {
1318 spin_unlock_irqrestore(&ubc->isoinlock, flags);
1319 return;
1320 }
1321 status = ubc->isoinstatus;
1322 ubc->isoindone = NULL;
1323 if (unlikely(ubc->loststatus != -EINPROGRESS)) {
1324 dev_warn(cs->dev,
1325 "isoc read overrun, URB dropped (status: %s, %d bytes)\n",
1326 get_usb_statmsg(ubc->loststatus),
1327 ubc->isoinlost);
1328 ubc->loststatus = -EINPROGRESS;
1329 }
1330 spin_unlock_irqrestore(&ubc->isoinlock, flags);
1331
1332 if (unlikely(!(ubc->running))) {
1333 gig_dbg(DEBUG_ISO,
1334 "%s: channel not running, "
1335 "dropped URB with status: %s",
1336 __func__, get_usb_statmsg(status));
1337 return;
1338 }
1339
1340 switch (status) {
1341 case 0: /* normal completion */
1342 break;
1343 case -EXDEV: /* inspect individual frames
1344 (we do that anyway) */
1345 gig_dbg(DEBUG_ISO, "%s: URB partially completed",
1346 __func__);
1347 break;
1348 case -ENOENT:
1349 case -ECONNRESET:
1350 case -EINPROGRESS:
1351 gig_dbg(DEBUG_ISO, "%s: %s",
1352 __func__, get_usb_statmsg(status));
1353 continue; /* -> skip */
1354 case -EPIPE:
1355 dev_err(cs->dev, "isoc read: stalled\n");
1356 error_hangup(bcs);
1357 continue; /* -> skip */
1358 default: /* other error */
1359 dev_warn(cs->dev, "isoc read: %s\n",
1360 get_usb_statmsg(status));
1361 goto error;
1362 }
1363
1364 rcvbuf = urb->transfer_buffer;
1365 totleft = urb->actual_length;
1366 for (frame = 0; totleft > 0 && frame < BAS_NUMFRAMES; frame++) {
1367 ifd = &urb->iso_frame_desc[frame];
1368 numbytes = ifd->actual_length;
1369 switch (ifd->status) {
1370 case 0: /* success */
1371 break;
1372 case -EPROTO: /* protocol error or unplug */
1373 case -EILSEQ:
1374 case -ETIME:
1375 /* probably just disconnected, ignore */
1376 gig_dbg(DEBUG_ISO,
1377 "isoc read: frame %d[%d]: %s\n",
1378 frame, numbytes,
1379 get_usb_statmsg(ifd->status));
1380 break;
1381 default: /* other error */
1382 /* report, assume transferred bytes are ok */
1383 dev_warn(cs->dev,
1384 "isoc read: frame %d[%d]: %s\n",
1385 frame, numbytes,
1386 get_usb_statmsg(ifd->status));
1387 }
1388 if (unlikely(numbytes > BAS_MAXFRAME))
1389 dev_warn(cs->dev,
1390 "isoc read: frame %d[%d]: %s\n",
1391 frame, numbytes,
1392 "exceeds max frame size");
1393 if (unlikely(numbytes > totleft)) {
1394 dev_warn(cs->dev,
1395 "isoc read: frame %d[%d]: %s\n",
1396 frame, numbytes,
1397 "exceeds total transfer length");
1398 numbytes = totleft;
1399 }
1400 offset = ifd->offset;
1401 if (unlikely(offset + numbytes > BAS_INBUFSIZE)) {
1402 dev_warn(cs->dev,
1403 "isoc read: frame %d[%d]: %s\n",
1404 frame, numbytes,
1405 "exceeds end of buffer");
1406 numbytes = BAS_INBUFSIZE - offset;
1407 }
1408 gigaset_isoc_receive(rcvbuf + offset, numbytes, bcs);
1409 totleft -= numbytes;
1410 }
1411 if (unlikely(totleft > 0))
1412 dev_warn(cs->dev, "isoc read: %d data bytes missing\n",
1413 totleft);
1414
1415 error:
1416 /* URB processed, resubmit */
1417 for (frame = 0; frame < BAS_NUMFRAMES; frame++) {
1418 urb->iso_frame_desc[frame].status = 0;
1419 urb->iso_frame_desc[frame].actual_length = 0;
1420 }
1421 /* urb->dev is clobbered by USB subsystem */
1422 urb->dev = bcs->cs->hw.bas->udev;
1423 urb->transfer_flags = URB_ISO_ASAP;
1424 urb->number_of_packets = BAS_NUMFRAMES;
1425 rc = usb_submit_urb(urb, GFP_ATOMIC);
1426 if (unlikely(rc != 0 && rc != -ENODEV)) {
1427 dev_err(cs->dev,
1428 "could not resubmit isoc read URB: %s\n",
1429 get_usb_rcmsg(rc));
1430 dump_urb(DEBUG_ISO, "resubmit isoc read", urb);
1431 error_hangup(bcs);
1432 }
1433 }
1434 }
1435
1436 /* Channel Operations */
1437 /* ================== */
1438
1439 /* req_timeout
1440 * timeout routine for control output request
1441 * argument:
1442 * controller state structure
1443 */
1444 static void req_timeout(unsigned long data)
1445 {
1446 struct cardstate *cs = (struct cardstate *) data;
1447 struct bas_cardstate *ucs = cs->hw.bas;
1448 int pending;
1449 unsigned long flags;
1450
1451 check_pending(ucs);
1452
1453 spin_lock_irqsave(&ucs->lock, flags);
1454 pending = ucs->pending;
1455 ucs->pending = 0;
1456 spin_unlock_irqrestore(&ucs->lock, flags);
1457
1458 switch (pending) {
1459 case 0: /* no pending request */
1460 gig_dbg(DEBUG_USBREQ, "%s: no request pending", __func__);
1461 break;
1462
1463 case HD_OPEN_ATCHANNEL:
1464 dev_err(cs->dev, "timeout opening AT channel\n");
1465 error_reset(cs);
1466 break;
1467
1468 case HD_OPEN_B1CHANNEL:
1469 dev_err(cs->dev, "timeout opening channel 1\n");
1470 error_hangup(&cs->bcs[0]);
1471 break;
1472
1473 case HD_OPEN_B2CHANNEL:
1474 dev_err(cs->dev, "timeout opening channel 2\n");
1475 error_hangup(&cs->bcs[1]);
1476 break;
1477
1478 case HD_CLOSE_ATCHANNEL:
1479 dev_err(cs->dev, "timeout closing AT channel\n");
1480 error_reset(cs);
1481 break;
1482
1483 case HD_CLOSE_B1CHANNEL:
1484 dev_err(cs->dev, "timeout closing channel 1\n");
1485 error_reset(cs);
1486 break;
1487
1488 case HD_CLOSE_B2CHANNEL:
1489 dev_err(cs->dev, "timeout closing channel 2\n");
1490 error_reset(cs);
1491 break;
1492
1493 case HD_RESET_INTERRUPT_PIPE:
1494 /* error recovery escalation */
1495 dev_err(cs->dev,
1496 "reset interrupt pipe timeout, attempting USB reset\n");
1497 usb_queue_reset_device(ucs->interface);
1498 break;
1499
1500 default:
1501 dev_warn(cs->dev, "request 0x%02x timed out, clearing\n",
1502 pending);
1503 }
1504
1505 wake_up(&ucs->waitqueue);
1506 }
1507
1508 /* write_ctrl_callback
1509 * USB completion handler for control pipe output
1510 * called by the USB subsystem in interrupt context
1511 * parameter:
1512 * urb USB request block of completed request
1513 * urb->context = hardware specific controller state structure
1514 */
1515 static void write_ctrl_callback(struct urb *urb)
1516 {
1517 struct bas_cardstate *ucs = urb->context;
1518 int status = urb->status;
1519 int rc;
1520 unsigned long flags;
1521
1522 /* check status */
1523 switch (status) {
1524 case 0: /* normal completion */
1525 spin_lock_irqsave(&ucs->lock, flags);
1526 switch (ucs->pending) {
1527 case HD_DEVICE_INIT_ACK: /* no reply expected */
1528 del_timer(&ucs->timer_ctrl);
1529 ucs->pending = 0;
1530 break;
1531 }
1532 spin_unlock_irqrestore(&ucs->lock, flags);
1533 return;
1534
1535 case -ENOENT: /* cancelled */
1536 case -ECONNRESET: /* cancelled (async) */
1537 case -EINPROGRESS: /* pending */
1538 case -ENODEV: /* device removed */
1539 case -ESHUTDOWN: /* device shut down */
1540 /* ignore silently */
1541 gig_dbg(DEBUG_USBREQ, "%s: %s",
1542 __func__, get_usb_statmsg(status));
1543 break;
1544
1545 default: /* any failure */
1546 /* don't retry if suspend requested */
1547 if (++ucs->retry_ctrl > BAS_RETRY ||
1548 (ucs->basstate & BS_SUSPEND)) {
1549 dev_err(&ucs->interface->dev,
1550 "control request 0x%02x failed: %s\n",
1551 ucs->dr_ctrl.bRequest,
1552 get_usb_statmsg(status));
1553 break; /* give up */
1554 }
1555 dev_notice(&ucs->interface->dev,
1556 "control request 0x%02x: %s, retry %d\n",
1557 ucs->dr_ctrl.bRequest, get_usb_statmsg(status),
1558 ucs->retry_ctrl);
1559 /* urb->dev is clobbered by USB subsystem */
1560 urb->dev = ucs->udev;
1561 rc = usb_submit_urb(urb, GFP_ATOMIC);
1562 if (unlikely(rc)) {
1563 dev_err(&ucs->interface->dev,
1564 "could not resubmit request 0x%02x: %s\n",
1565 ucs->dr_ctrl.bRequest, get_usb_rcmsg(rc));
1566 break;
1567 }
1568 /* resubmitted */
1569 return;
1570 }
1571
1572 /* failed, clear pending request */
1573 spin_lock_irqsave(&ucs->lock, flags);
1574 del_timer(&ucs->timer_ctrl);
1575 ucs->pending = 0;
1576 spin_unlock_irqrestore(&ucs->lock, flags);
1577 wake_up(&ucs->waitqueue);
1578 }
1579
1580 /* req_submit
1581 * submit a control output request without message buffer to the Gigaset base
1582 * and optionally start a timeout
1583 * parameters:
1584 * bcs B channel control structure
1585 * req control request code (HD_*)
1586 * val control request parameter value (set to 0 if unused)
1587 * timeout timeout in seconds (0: no timeout)
1588 * return value:
1589 * 0 on success
1590 * -EBUSY if another request is pending
1591 * any URB submission error code
1592 */
1593 static int req_submit(struct bc_state *bcs, int req, int val, int timeout)
1594 {
1595 struct bas_cardstate *ucs = bcs->cs->hw.bas;
1596 int ret;
1597 unsigned long flags;
1598
1599 gig_dbg(DEBUG_USBREQ, "-------> 0x%02x (%d)", req, val);
1600
1601 spin_lock_irqsave(&ucs->lock, flags);
1602 if (ucs->pending) {
1603 spin_unlock_irqrestore(&ucs->lock, flags);
1604 dev_err(bcs->cs->dev,
1605 "submission of request 0x%02x failed: "
1606 "request 0x%02x still pending\n",
1607 req, ucs->pending);
1608 return -EBUSY;
1609 }
1610
1611 ucs->dr_ctrl.bRequestType = OUT_VENDOR_REQ;
1612 ucs->dr_ctrl.bRequest = req;
1613 ucs->dr_ctrl.wValue = cpu_to_le16(val);
1614 ucs->dr_ctrl.wIndex = 0;
1615 ucs->dr_ctrl.wLength = 0;
1616 usb_fill_control_urb(ucs->urb_ctrl, ucs->udev,
1617 usb_sndctrlpipe(ucs->udev, 0),
1618 (unsigned char *) &ucs->dr_ctrl, NULL, 0,
1619 write_ctrl_callback, ucs);
1620 ucs->retry_ctrl = 0;
1621 ret = usb_submit_urb(ucs->urb_ctrl, GFP_ATOMIC);
1622 if (unlikely(ret)) {
1623 dev_err(bcs->cs->dev, "could not submit request 0x%02x: %s\n",
1624 req, get_usb_rcmsg(ret));
1625 spin_unlock_irqrestore(&ucs->lock, flags);
1626 return ret;
1627 }
1628 ucs->pending = req;
1629
1630 if (timeout > 0) {
1631 gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
1632 mod_timer(&ucs->timer_ctrl, jiffies + timeout * HZ / 10);
1633 }
1634
1635 spin_unlock_irqrestore(&ucs->lock, flags);
1636 return 0;
1637 }
1638
1639 /* gigaset_init_bchannel
1640 * called by common.c to connect a B channel
1641 * initialize isochronous I/O and tell the Gigaset base to open the channel
1642 * argument:
1643 * B channel control structure
1644 * return value:
1645 * 0 on success, error code < 0 on error
1646 */
1647 static int gigaset_init_bchannel(struct bc_state *bcs)
1648 {
1649 struct cardstate *cs = bcs->cs;
1650 int req, ret;
1651 unsigned long flags;
1652
1653 spin_lock_irqsave(&cs->lock, flags);
1654 if (unlikely(!cs->connected)) {
1655 gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__);
1656 spin_unlock_irqrestore(&cs->lock, flags);
1657 return -ENODEV;
1658 }
1659
1660 if (cs->hw.bas->basstate & BS_SUSPEND) {
1661 dev_notice(cs->dev,
1662 "not starting isoc I/O, suspend in progress\n");
1663 spin_unlock_irqrestore(&cs->lock, flags);
1664 return -EHOSTUNREACH;
1665 }
1666
1667 ret = starturbs(bcs);
1668 if (ret < 0) {
1669 spin_unlock_irqrestore(&cs->lock, flags);
1670 dev_err(cs->dev,
1671 "could not start isoc I/O for channel B%d: %s\n",
1672 bcs->channel + 1,
1673 ret == -EFAULT ? "null URB" : get_usb_rcmsg(ret));
1674 if (ret != -ENODEV)
1675 error_hangup(bcs);
1676 return ret;
1677 }
1678
1679 req = bcs->channel ? HD_OPEN_B2CHANNEL : HD_OPEN_B1CHANNEL;
1680 ret = req_submit(bcs, req, 0, BAS_TIMEOUT);
1681 if (ret < 0) {
1682 dev_err(cs->dev, "could not open channel B%d\n",
1683 bcs->channel + 1);
1684 stopurbs(bcs->hw.bas);
1685 }
1686
1687 spin_unlock_irqrestore(&cs->lock, flags);
1688 if (ret < 0 && ret != -ENODEV)
1689 error_hangup(bcs);
1690 return ret;
1691 }
1692
1693 /* gigaset_close_bchannel
1694 * called by common.c to disconnect a B channel
1695 * tell the Gigaset base to close the channel
1696 * stopping isochronous I/O and LL notification will be done when the
1697 * acknowledgement for the close arrives
1698 * argument:
1699 * B channel control structure
1700 * return value:
1701 * 0 on success, error code < 0 on error
1702 */
1703 static int gigaset_close_bchannel(struct bc_state *bcs)
1704 {
1705 struct cardstate *cs = bcs->cs;
1706 int req, ret;
1707 unsigned long flags;
1708
1709 spin_lock_irqsave(&cs->lock, flags);
1710 if (unlikely(!cs->connected)) {
1711 spin_unlock_irqrestore(&cs->lock, flags);
1712 gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__);
1713 return -ENODEV;
1714 }
1715
1716 if (!(cs->hw.bas->basstate & (bcs->channel ? BS_B2OPEN : BS_B1OPEN))) {
1717 /* channel not running: just signal common.c */
1718 spin_unlock_irqrestore(&cs->lock, flags);
1719 gigaset_bchannel_down(bcs);
1720 return 0;
1721 }
1722
1723 /* channel running: tell device to close it */
1724 req = bcs->channel ? HD_CLOSE_B2CHANNEL : HD_CLOSE_B1CHANNEL;
1725 ret = req_submit(bcs, req, 0, BAS_TIMEOUT);
1726 if (ret < 0)
1727 dev_err(cs->dev, "closing channel B%d failed\n",
1728 bcs->channel + 1);
1729
1730 spin_unlock_irqrestore(&cs->lock, flags);
1731 return ret;
1732 }
1733
1734 /* Device Operations */
1735 /* ================= */
1736
1737 /* complete_cb
1738 * unqueue first command buffer from queue, waking any sleepers
1739 * must be called with cs->cmdlock held
1740 * parameter:
1741 * cs controller state structure
1742 */
1743 static void complete_cb(struct cardstate *cs)
1744 {
1745 struct cmdbuf_t *cb = cs->cmdbuf;
1746
1747 /* unqueue completed buffer */
1748 cs->cmdbytes -= cs->curlen;
1749 gig_dbg(DEBUG_OUTPUT, "write_command: sent %u bytes, %u left",
1750 cs->curlen, cs->cmdbytes);
1751 if (cb->next != NULL) {
1752 cs->cmdbuf = cb->next;
1753 cs->cmdbuf->prev = NULL;
1754 cs->curlen = cs->cmdbuf->len;
1755 } else {
1756 cs->cmdbuf = NULL;
1757 cs->lastcmdbuf = NULL;
1758 cs->curlen = 0;
1759 }
1760
1761 if (cb->wake_tasklet)
1762 tasklet_schedule(cb->wake_tasklet);
1763
1764 kfree(cb);
1765 }
1766
1767 /* write_command_callback
1768 * USB completion handler for AT command transmission
1769 * called by the USB subsystem in interrupt context
1770 * parameter:
1771 * urb USB request block of completed request
1772 * urb->context = controller state structure
1773 */
1774 static void write_command_callback(struct urb *urb)
1775 {
1776 struct cardstate *cs = urb->context;
1777 struct bas_cardstate *ucs = cs->hw.bas;
1778 int status = urb->status;
1779 unsigned long flags;
1780
1781 update_basstate(ucs, 0, BS_ATWRPEND);
1782 wake_up(&ucs->waitqueue);
1783
1784 /* check status */
1785 switch (status) {
1786 case 0: /* normal completion */
1787 break;
1788 case -ENOENT: /* cancelled */
1789 case -ECONNRESET: /* cancelled (async) */
1790 case -EINPROGRESS: /* pending */
1791 case -ENODEV: /* device removed */
1792 case -ESHUTDOWN: /* device shut down */
1793 /* ignore silently */
1794 gig_dbg(DEBUG_USBREQ, "%s: %s",
1795 __func__, get_usb_statmsg(status));
1796 return;
1797 default: /* any failure */
1798 if (++ucs->retry_cmd_out > BAS_RETRY) {
1799 dev_warn(cs->dev,
1800 "command write: %s, "
1801 "giving up after %d retries\n",
1802 get_usb_statmsg(status),
1803 ucs->retry_cmd_out);
1804 break;
1805 }
1806 if (ucs->basstate & BS_SUSPEND) {
1807 dev_warn(cs->dev,
1808 "command write: %s, "
1809 "won't retry - suspend requested\n",
1810 get_usb_statmsg(status));
1811 break;
1812 }
1813 if (cs->cmdbuf == NULL) {
1814 dev_warn(cs->dev,
1815 "command write: %s, "
1816 "cannot retry - cmdbuf gone\n",
1817 get_usb_statmsg(status));
1818 break;
1819 }
1820 dev_notice(cs->dev, "command write: %s, retry %d\n",
1821 get_usb_statmsg(status), ucs->retry_cmd_out);
1822 if (atwrite_submit(cs, cs->cmdbuf->buf, cs->cmdbuf->len) >= 0)
1823 /* resubmitted - bypass regular exit block */
1824 return;
1825 /* command send failed, assume base still waiting */
1826 update_basstate(ucs, BS_ATREADY, 0);
1827 }
1828
1829 spin_lock_irqsave(&cs->cmdlock, flags);
1830 if (cs->cmdbuf != NULL)
1831 complete_cb(cs);
1832 spin_unlock_irqrestore(&cs->cmdlock, flags);
1833 }
1834
1835 /* atrdy_timeout
1836 * timeout routine for AT command transmission
1837 * argument:
1838 * controller state structure
1839 */
1840 static void atrdy_timeout(unsigned long data)
1841 {
1842 struct cardstate *cs = (struct cardstate *) data;
1843 struct bas_cardstate *ucs = cs->hw.bas;
1844
1845 dev_warn(cs->dev, "timeout waiting for HD_READY_SEND_ATDATA\n");
1846
1847 /* fake the missing signal - what else can I do? */
1848 update_basstate(ucs, BS_ATREADY, BS_ATTIMER);
1849 start_cbsend(cs);
1850 }
1851
1852 /* atwrite_submit
1853 * submit an HD_WRITE_ATMESSAGE command URB
1854 * parameters:
1855 * cs controller state structure
1856 * buf buffer containing command to send
1857 * len length of command to send
1858 * return value:
1859 * 0 on success
1860 * -EBUSY if another request is pending
1861 * any URB submission error code
1862 */
1863 static int atwrite_submit(struct cardstate *cs, unsigned char *buf, int len)
1864 {
1865 struct bas_cardstate *ucs = cs->hw.bas;
1866 int rc;
1867
1868 gig_dbg(DEBUG_USBREQ, "-------> HD_WRITE_ATMESSAGE (%d)", len);
1869
1870 if (update_basstate(ucs, BS_ATWRPEND, 0) & BS_ATWRPEND) {
1871 dev_err(cs->dev,
1872 "could not submit HD_WRITE_ATMESSAGE: URB busy\n");
1873 return -EBUSY;
1874 }
1875
1876 ucs->dr_cmd_out.bRequestType = OUT_VENDOR_REQ;
1877 ucs->dr_cmd_out.bRequest = HD_WRITE_ATMESSAGE;
1878 ucs->dr_cmd_out.wValue = 0;
1879 ucs->dr_cmd_out.wIndex = 0;
1880 ucs->dr_cmd_out.wLength = cpu_to_le16(len);
1881 usb_fill_control_urb(ucs->urb_cmd_out, ucs->udev,
1882 usb_sndctrlpipe(ucs->udev, 0),
1883 (unsigned char *) &ucs->dr_cmd_out, buf, len,
1884 write_command_callback, cs);
1885 rc = usb_submit_urb(ucs->urb_cmd_out, GFP_ATOMIC);
1886 if (unlikely(rc)) {
1887 update_basstate(ucs, 0, BS_ATWRPEND);
1888 dev_err(cs->dev, "could not submit HD_WRITE_ATMESSAGE: %s\n",
1889 get_usb_rcmsg(rc));
1890 return rc;
1891 }
1892
1893 /* submitted successfully, start timeout if necessary */
1894 if (!(update_basstate(ucs, BS_ATTIMER, BS_ATREADY) & BS_ATTIMER)) {
1895 gig_dbg(DEBUG_OUTPUT, "setting ATREADY timeout of %d/10 secs",
1896 ATRDY_TIMEOUT);
1897 mod_timer(&ucs->timer_atrdy, jiffies + ATRDY_TIMEOUT * HZ / 10);
1898 }
1899 return 0;
1900 }
1901
1902 /* start_cbsend
1903 * start transmission of AT command queue if necessary
1904 * parameter:
1905 * cs controller state structure
1906 * return value:
1907 * 0 on success
1908 * error code < 0 on error
1909 */
1910 static int start_cbsend(struct cardstate *cs)
1911 {
1912 struct cmdbuf_t *cb;
1913 struct bas_cardstate *ucs = cs->hw.bas;
1914 unsigned long flags;
1915 int rc;
1916 int retval = 0;
1917
1918 /* check if suspend requested */
1919 if (ucs->basstate & BS_SUSPEND) {
1920 gig_dbg(DEBUG_OUTPUT, "suspending");
1921 return -EHOSTUNREACH;
1922 }
1923
1924 /* check if AT channel is open */
1925 if (!(ucs->basstate & BS_ATOPEN)) {
1926 gig_dbg(DEBUG_OUTPUT, "AT channel not open");
1927 rc = req_submit(cs->bcs, HD_OPEN_ATCHANNEL, 0, BAS_TIMEOUT);
1928 if (rc < 0) {
1929 /* flush command queue */
1930 spin_lock_irqsave(&cs->cmdlock, flags);
1931 while (cs->cmdbuf != NULL)
1932 complete_cb(cs);
1933 spin_unlock_irqrestore(&cs->cmdlock, flags);
1934 }
1935 return rc;
1936 }
1937
1938 /* try to send first command in queue */
1939 spin_lock_irqsave(&cs->cmdlock, flags);
1940
1941 while ((cb = cs->cmdbuf) != NULL && (ucs->basstate & BS_ATREADY)) {
1942 ucs->retry_cmd_out = 0;
1943 rc = atwrite_submit(cs, cb->buf, cb->len);
1944 if (unlikely(rc)) {
1945 retval = rc;
1946 complete_cb(cs);
1947 }
1948 }
1949
1950 spin_unlock_irqrestore(&cs->cmdlock, flags);
1951 return retval;
1952 }
1953
1954 /* gigaset_write_cmd
1955 * This function is called by the device independent part of the driver
1956 * to transmit an AT command string to the Gigaset device.
1957 * It encapsulates the device specific method for transmission over the
1958 * direct USB connection to the base.
1959 * The command string is added to the queue of commands to send, and
1960 * USB transmission is started if necessary.
1961 * parameters:
1962 * cs controller state structure
1963 * cb command buffer structure
1964 * return value:
1965 * number of bytes queued on success
1966 * error code < 0 on error
1967 */
1968 static int gigaset_write_cmd(struct cardstate *cs, struct cmdbuf_t *cb)
1969 {
1970 unsigned long flags;
1971 int rc;
1972
1973 gigaset_dbg_buffer(cs->mstate != MS_LOCKED ?
1974 DEBUG_TRANSCMD : DEBUG_LOCKCMD,
1975 "CMD Transmit", cb->len, cb->buf);
1976
1977 /* translate "+++" escape sequence sent as a single separate command
1978 * into "close AT channel" command for error recovery
1979 * The next command will reopen the AT channel automatically.
1980 */
1981 if (cb->len == 3 && !memcmp(cb->buf, "+++", 3)) {
1982 /* If an HD_RECEIVEATDATA_ACK message remains unhandled
1983 * because of an error, the base never sends another one.
1984 * The response channel is thus effectively blocked.
1985 * Closing and reopening the AT channel does *not* clear
1986 * this condition.
1987 * As a stopgap measure, submit a zero-length AT read
1988 * before closing the AT channel. This has the undocumented
1989 * effect of triggering a new HD_RECEIVEATDATA_ACK message
1990 * from the base if necessary.
1991 * The subsequent AT channel close then discards any pending
1992 * messages.
1993 */
1994 spin_lock_irqsave(&cs->lock, flags);
1995 if (!(cs->hw.bas->basstate & BS_ATRDPEND)) {
1996 kfree(cs->hw.bas->rcvbuf);
1997 cs->hw.bas->rcvbuf = NULL;
1998 cs->hw.bas->rcvbuf_size = 0;
1999 cs->hw.bas->retry_cmd_in = 0;
2000 atread_submit(cs, 0);
2001 }
2002 spin_unlock_irqrestore(&cs->lock, flags);
2003
2004 rc = req_submit(cs->bcs, HD_CLOSE_ATCHANNEL, 0, BAS_TIMEOUT);
2005 if (cb->wake_tasklet)
2006 tasklet_schedule(cb->wake_tasklet);
2007 if (!rc)
2008 rc = cb->len;
2009 kfree(cb);
2010 return rc;
2011 }
2012
2013 spin_lock_irqsave(&cs->cmdlock, flags);
2014 cb->prev = cs->lastcmdbuf;
2015 if (cs->lastcmdbuf)
2016 cs->lastcmdbuf->next = cb;
2017 else {
2018 cs->cmdbuf = cb;
2019 cs->curlen = cb->len;
2020 }
2021 cs->cmdbytes += cb->len;
2022 cs->lastcmdbuf = cb;
2023 spin_unlock_irqrestore(&cs->cmdlock, flags);
2024
2025 spin_lock_irqsave(&cs->lock, flags);
2026 if (unlikely(!cs->connected)) {
2027 spin_unlock_irqrestore(&cs->lock, flags);
2028 gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__);
2029 /* flush command queue */
2030 spin_lock_irqsave(&cs->cmdlock, flags);
2031 while (cs->cmdbuf != NULL)
2032 complete_cb(cs);
2033 spin_unlock_irqrestore(&cs->cmdlock, flags);
2034 return -ENODEV;
2035 }
2036 rc = start_cbsend(cs);
2037 spin_unlock_irqrestore(&cs->lock, flags);
2038 return rc < 0 ? rc : cb->len;
2039 }
2040
2041 /* gigaset_write_room
2042 * tty_driver.write_room interface routine
2043 * return number of characters the driver will accept to be written via
2044 * gigaset_write_cmd
2045 * parameter:
2046 * controller state structure
2047 * return value:
2048 * number of characters
2049 */
2050 static int gigaset_write_room(struct cardstate *cs)
2051 {
2052 return IF_WRITEBUF;
2053 }
2054
2055 /* gigaset_chars_in_buffer
2056 * tty_driver.chars_in_buffer interface routine
2057 * return number of characters waiting to be sent
2058 * parameter:
2059 * controller state structure
2060 * return value:
2061 * number of characters
2062 */
2063 static int gigaset_chars_in_buffer(struct cardstate *cs)
2064 {
2065 return cs->cmdbytes;
2066 }
2067
2068 /* gigaset_brkchars
2069 * implementation of ioctl(GIGASET_BRKCHARS)
2070 * parameter:
2071 * controller state structure
2072 * return value:
2073 * -EINVAL (unimplemented function)
2074 */
2075 static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6])
2076 {
2077 return -EINVAL;
2078 }
2079
2080
2081 /* Device Initialization/Shutdown */
2082 /* ============================== */
2083
2084 /* Free hardware dependent part of the B channel structure
2085 * parameter:
2086 * bcs B channel structure
2087 */
2088 static void gigaset_freebcshw(struct bc_state *bcs)
2089 {
2090 struct bas_bc_state *ubc = bcs->hw.bas;
2091 int i;
2092
2093 if (!ubc)
2094 return;
2095
2096 /* kill URBs and tasklets before freeing - better safe than sorry */
2097 ubc->running = 0;
2098 gig_dbg(DEBUG_INIT, "%s: killing isoc URBs", __func__);
2099 for (i = 0; i < BAS_OUTURBS; ++i) {
2100 usb_kill_urb(ubc->isoouturbs[i].urb);
2101 usb_free_urb(ubc->isoouturbs[i].urb);
2102 }
2103 for (i = 0; i < BAS_INURBS; ++i) {
2104 usb_kill_urb(ubc->isoinurbs[i]);
2105 usb_free_urb(ubc->isoinurbs[i]);
2106 }
2107 tasklet_kill(&ubc->sent_tasklet);
2108 tasklet_kill(&ubc->rcvd_tasklet);
2109 kfree(ubc->isooutbuf);
2110 kfree(ubc);
2111 bcs->hw.bas = NULL;
2112 }
2113
2114 /* Initialize hardware dependent part of the B channel structure
2115 * parameter:
2116 * bcs B channel structure
2117 * return value:
2118 * 0 on success, error code < 0 on failure
2119 */
2120 static int gigaset_initbcshw(struct bc_state *bcs)
2121 {
2122 int i;
2123 struct bas_bc_state *ubc;
2124
2125 bcs->hw.bas = ubc = kmalloc(sizeof(struct bas_bc_state), GFP_KERNEL);
2126 if (!ubc) {
2127 pr_err("out of memory\n");
2128 return -ENOMEM;
2129 }
2130
2131 ubc->running = 0;
2132 atomic_set(&ubc->corrbytes, 0);
2133 spin_lock_init(&ubc->isooutlock);
2134 for (i = 0; i < BAS_OUTURBS; ++i) {
2135 ubc->isoouturbs[i].urb = NULL;
2136 ubc->isoouturbs[i].bcs = bcs;
2137 }
2138 ubc->isooutdone = ubc->isooutfree = ubc->isooutovfl = NULL;
2139 ubc->numsub = 0;
2140 ubc->isooutbuf = kmalloc(sizeof(struct isowbuf_t), GFP_KERNEL);
2141 if (!ubc->isooutbuf) {
2142 pr_err("out of memory\n");
2143 kfree(ubc);
2144 bcs->hw.bas = NULL;
2145 return -ENOMEM;
2146 }
2147 tasklet_init(&ubc->sent_tasklet,
2148 write_iso_tasklet, (unsigned long) bcs);
2149
2150 spin_lock_init(&ubc->isoinlock);
2151 for (i = 0; i < BAS_INURBS; ++i)
2152 ubc->isoinurbs[i] = NULL;
2153 ubc->isoindone = NULL;
2154 ubc->loststatus = -EINPROGRESS;
2155 ubc->isoinlost = 0;
2156 ubc->seqlen = 0;
2157 ubc->inbyte = 0;
2158 ubc->inbits = 0;
2159 ubc->goodbytes = 0;
2160 ubc->alignerrs = 0;
2161 ubc->fcserrs = 0;
2162 ubc->frameerrs = 0;
2163 ubc->giants = 0;
2164 ubc->runts = 0;
2165 ubc->aborts = 0;
2166 ubc->shared0s = 0;
2167 ubc->stolen0s = 0;
2168 tasklet_init(&ubc->rcvd_tasklet,
2169 read_iso_tasklet, (unsigned long) bcs);
2170 return 0;
2171 }
2172
2173 static void gigaset_reinitbcshw(struct bc_state *bcs)
2174 {
2175 struct bas_bc_state *ubc = bcs->hw.bas;
2176
2177 bcs->hw.bas->running = 0;
2178 atomic_set(&bcs->hw.bas->corrbytes, 0);
2179 bcs->hw.bas->numsub = 0;
2180 spin_lock_init(&ubc->isooutlock);
2181 spin_lock_init(&ubc->isoinlock);
2182 ubc->loststatus = -EINPROGRESS;
2183 }
2184
2185 static void gigaset_freecshw(struct cardstate *cs)
2186 {
2187 /* timers, URBs and rcvbuf are disposed of in disconnect */
2188 kfree(cs->hw.bas->int_in_buf);
2189 kfree(cs->hw.bas);
2190 cs->hw.bas = NULL;
2191 }
2192
2193 /* Initialize hardware dependent part of the cardstate structure
2194 * parameter:
2195 * cs cardstate structure
2196 * return value:
2197 * 0 on success, error code < 0 on failure
2198 */
2199 static int gigaset_initcshw(struct cardstate *cs)
2200 {
2201 struct bas_cardstate *ucs;
2202
2203 cs->hw.bas = ucs = kmalloc(sizeof *ucs, GFP_KERNEL);
2204 if (!ucs) {
2205 pr_err("out of memory\n");
2206 return -ENOMEM;
2207 }
2208 ucs->int_in_buf = kmalloc(IP_MSGSIZE, GFP_KERNEL);
2209 if (!ucs->int_in_buf) {
2210 kfree(ucs);
2211 pr_err("out of memory\n");
2212 return -ENOMEM;
2213 }
2214
2215 ucs->urb_cmd_in = NULL;
2216 ucs->urb_cmd_out = NULL;
2217 ucs->rcvbuf = NULL;
2218 ucs->rcvbuf_size = 0;
2219
2220 spin_lock_init(&ucs->lock);
2221 ucs->pending = 0;
2222
2223 ucs->basstate = 0;
2224 setup_timer(&ucs->timer_ctrl, req_timeout, (unsigned long) cs);
2225 setup_timer(&ucs->timer_atrdy, atrdy_timeout, (unsigned long) cs);
2226 setup_timer(&ucs->timer_cmd_in, cmd_in_timeout, (unsigned long) cs);
2227 setup_timer(&ucs->timer_int_in, int_in_resubmit, (unsigned long) cs);
2228 init_waitqueue_head(&ucs->waitqueue);
2229 INIT_WORK(&ucs->int_in_wq, int_in_work);
2230
2231 return 0;
2232 }
2233
2234 /* freeurbs
2235 * unlink and deallocate all URBs unconditionally
2236 * caller must make sure that no commands are still in progress
2237 * parameter:
2238 * cs controller state structure
2239 */
2240 static void freeurbs(struct cardstate *cs)
2241 {
2242 struct bas_cardstate *ucs = cs->hw.bas;
2243 struct bas_bc_state *ubc;
2244 int i, j;
2245
2246 gig_dbg(DEBUG_INIT, "%s: killing URBs", __func__);
2247 for (j = 0; j < BAS_CHANNELS; ++j) {
2248 ubc = cs->bcs[j].hw.bas;
2249 for (i = 0; i < BAS_OUTURBS; ++i) {
2250 usb_kill_urb(ubc->isoouturbs[i].urb);
2251 usb_free_urb(ubc->isoouturbs[i].urb);
2252 ubc->isoouturbs[i].urb = NULL;
2253 }
2254 for (i = 0; i < BAS_INURBS; ++i) {
2255 usb_kill_urb(ubc->isoinurbs[i]);
2256 usb_free_urb(ubc->isoinurbs[i]);
2257 ubc->isoinurbs[i] = NULL;
2258 }
2259 }
2260 usb_kill_urb(ucs->urb_int_in);
2261 usb_free_urb(ucs->urb_int_in);
2262 ucs->urb_int_in = NULL;
2263 usb_kill_urb(ucs->urb_cmd_out);
2264 usb_free_urb(ucs->urb_cmd_out);
2265 ucs->urb_cmd_out = NULL;
2266 usb_kill_urb(ucs->urb_cmd_in);
2267 usb_free_urb(ucs->urb_cmd_in);
2268 ucs->urb_cmd_in = NULL;
2269 usb_kill_urb(ucs->urb_ctrl);
2270 usb_free_urb(ucs->urb_ctrl);
2271 ucs->urb_ctrl = NULL;
2272 }
2273
2274 /* gigaset_probe
2275 * This function is called when a new USB device is connected.
2276 * It checks whether the new device is handled by this driver.
2277 */
2278 static int gigaset_probe(struct usb_interface *interface,
2279 const struct usb_device_id *id)
2280 {
2281 struct usb_host_interface *hostif;
2282 struct usb_device *udev = interface_to_usbdev(interface);
2283 struct cardstate *cs = NULL;
2284 struct bas_cardstate *ucs = NULL;
2285 struct bas_bc_state *ubc;
2286 struct usb_endpoint_descriptor *endpoint;
2287 int i, j;
2288 int rc;
2289
2290 gig_dbg(DEBUG_INIT,
2291 "%s: Check if device matches .. (Vendor: 0x%x, Product: 0x%x)",
2292 __func__, le16_to_cpu(udev->descriptor.idVendor),
2293 le16_to_cpu(udev->descriptor.idProduct));
2294
2295 /* set required alternate setting */
2296 hostif = interface->cur_altsetting;
2297 if (hostif->desc.bAlternateSetting != 3) {
2298 gig_dbg(DEBUG_INIT,
2299 "%s: wrong alternate setting %d - trying to switch",
2300 __func__, hostif->desc.bAlternateSetting);
2301 if (usb_set_interface(udev, hostif->desc.bInterfaceNumber, 3)
2302 < 0) {
2303 dev_warn(&udev->dev, "usb_set_interface failed, "
2304 "device %d interface %d altsetting %d\n",
2305 udev->devnum, hostif->desc.bInterfaceNumber,
2306 hostif->desc.bAlternateSetting);
2307 return -ENODEV;
2308 }
2309 hostif = interface->cur_altsetting;
2310 }
2311
2312 /* Reject application specific interfaces
2313 */
2314 if (hostif->desc.bInterfaceClass != 255) {
2315 dev_warn(&udev->dev, "%s: bInterfaceClass == %d\n",
2316 __func__, hostif->desc.bInterfaceClass);
2317 return -ENODEV;
2318 }
2319
2320 dev_info(&udev->dev,
2321 "%s: Device matched (Vendor: 0x%x, Product: 0x%x)\n",
2322 __func__, le16_to_cpu(udev->descriptor.idVendor),
2323 le16_to_cpu(udev->descriptor.idProduct));
2324
2325 /* allocate memory for our device state and initialize it */
2326 cs = gigaset_initcs(driver, BAS_CHANNELS, 0, 0, cidmode,
2327 GIGASET_MODULENAME);
2328 if (!cs)
2329 return -ENODEV;
2330 ucs = cs->hw.bas;
2331
2332 /* save off device structure ptrs for later use */
2333 usb_get_dev(udev);
2334 ucs->udev = udev;
2335 ucs->interface = interface;
2336 cs->dev = &interface->dev;
2337
2338 /* allocate URBs:
2339 * - one for the interrupt pipe
2340 * - three for the different uses of the default control pipe
2341 * - three for each isochronous pipe
2342 */
2343 if (!(ucs->urb_int_in = usb_alloc_urb(0, GFP_KERNEL)) ||
2344 !(ucs->urb_cmd_in = usb_alloc_urb(0, GFP_KERNEL)) ||
2345 !(ucs->urb_cmd_out = usb_alloc_urb(0, GFP_KERNEL)) ||
2346 !(ucs->urb_ctrl = usb_alloc_urb(0, GFP_KERNEL)))
2347 goto allocerr;
2348
2349 for (j = 0; j < BAS_CHANNELS; ++j) {
2350 ubc = cs->bcs[j].hw.bas;
2351 for (i = 0; i < BAS_OUTURBS; ++i)
2352 if (!(ubc->isoouturbs[i].urb =
2353 usb_alloc_urb(BAS_NUMFRAMES, GFP_KERNEL)))
2354 goto allocerr;
2355 for (i = 0; i < BAS_INURBS; ++i)
2356 if (!(ubc->isoinurbs[i] =
2357 usb_alloc_urb(BAS_NUMFRAMES, GFP_KERNEL)))
2358 goto allocerr;
2359 }
2360
2361 ucs->rcvbuf = NULL;
2362 ucs->rcvbuf_size = 0;
2363
2364 /* Fill the interrupt urb and send it to the core */
2365 endpoint = &hostif->endpoint[0].desc;
2366 usb_fill_int_urb(ucs->urb_int_in, udev,
2367 usb_rcvintpipe(udev,
2368 usb_endpoint_num(endpoint)),
2369 ucs->int_in_buf, IP_MSGSIZE, read_int_callback, cs,
2370 endpoint->bInterval);
2371 rc = usb_submit_urb(ucs->urb_int_in, GFP_KERNEL);
2372 if (rc != 0) {
2373 dev_err(cs->dev, "could not submit interrupt URB: %s\n",
2374 get_usb_rcmsg(rc));
2375 goto error;
2376 }
2377 ucs->retry_int_in = 0;
2378
2379 /* tell the device that the driver is ready */
2380 rc = req_submit(cs->bcs, HD_DEVICE_INIT_ACK, 0, 0);
2381 if (rc != 0)
2382 goto error;
2383
2384 /* tell common part that the device is ready */
2385 if (startmode == SM_LOCKED)
2386 cs->mstate = MS_LOCKED;
2387
2388 /* save address of controller structure */
2389 usb_set_intfdata(interface, cs);
2390
2391 rc = gigaset_start(cs);
2392 if (rc < 0)
2393 goto error;
2394
2395 return 0;
2396
2397 allocerr:
2398 dev_err(cs->dev, "could not allocate URBs\n");
2399 rc = -ENOMEM;
2400 error:
2401 freeurbs(cs);
2402 usb_set_intfdata(interface, NULL);
2403 usb_put_dev(udev);
2404 gigaset_freecs(cs);
2405 return rc;
2406 }
2407
2408 /* gigaset_disconnect
2409 * This function is called when the Gigaset base is unplugged.
2410 */
2411 static void gigaset_disconnect(struct usb_interface *interface)
2412 {
2413 struct cardstate *cs;
2414 struct bas_cardstate *ucs;
2415 int j;
2416
2417 cs = usb_get_intfdata(interface);
2418
2419 ucs = cs->hw.bas;
2420
2421 dev_info(cs->dev, "disconnecting Gigaset base\n");
2422
2423 /* mark base as not ready, all channels disconnected */
2424 ucs->basstate = 0;
2425
2426 /* tell LL all channels are down */
2427 for (j = 0; j < BAS_CHANNELS; ++j)
2428 gigaset_bchannel_down(cs->bcs + j);
2429
2430 /* stop driver (common part) */
2431 gigaset_stop(cs);
2432
2433 /* stop delayed work and URBs, free ressources */
2434 del_timer_sync(&ucs->timer_ctrl);
2435 del_timer_sync(&ucs->timer_atrdy);
2436 del_timer_sync(&ucs->timer_cmd_in);
2437 del_timer_sync(&ucs->timer_int_in);
2438 cancel_work_sync(&ucs->int_in_wq);
2439 freeurbs(cs);
2440 usb_set_intfdata(interface, NULL);
2441 kfree(ucs->rcvbuf);
2442 ucs->rcvbuf = NULL;
2443 ucs->rcvbuf_size = 0;
2444 usb_put_dev(ucs->udev);
2445 ucs->interface = NULL;
2446 ucs->udev = NULL;
2447 cs->dev = NULL;
2448 gigaset_freecs(cs);
2449 }
2450
2451 /* gigaset_suspend
2452 * This function is called before the USB connection is suspended
2453 * or before the USB device is reset.
2454 * In the latter case, message == PMSG_ON.
2455 */
2456 static int gigaset_suspend(struct usb_interface *intf, pm_message_t message)
2457 {
2458 struct cardstate *cs = usb_get_intfdata(intf);
2459 struct bas_cardstate *ucs = cs->hw.bas;
2460 int rc;
2461
2462 /* set suspend flag; this stops AT command/response traffic */
2463 if (update_basstate(ucs, BS_SUSPEND, 0) & BS_SUSPEND) {
2464 gig_dbg(DEBUG_SUSPEND, "already suspended");
2465 return 0;
2466 }
2467
2468 /* wait a bit for blocking conditions to go away */
2469 rc = wait_event_timeout(ucs->waitqueue,
2470 !(ucs->basstate &
2471 (BS_B1OPEN | BS_B2OPEN | BS_ATRDPEND | BS_ATWRPEND)),
2472 BAS_TIMEOUT * HZ / 10);
2473 gig_dbg(DEBUG_SUSPEND, "wait_event_timeout() -> %d", rc);
2474
2475 /* check for conditions preventing suspend */
2476 if (ucs->basstate & (BS_B1OPEN | BS_B2OPEN | BS_ATRDPEND | BS_ATWRPEND)) {
2477 dev_warn(cs->dev, "cannot suspend:\n");
2478 if (ucs->basstate & BS_B1OPEN)
2479 dev_warn(cs->dev, " B channel 1 open\n");
2480 if (ucs->basstate & BS_B2OPEN)
2481 dev_warn(cs->dev, " B channel 2 open\n");
2482 if (ucs->basstate & BS_ATRDPEND)
2483 dev_warn(cs->dev, " receiving AT reply\n");
2484 if (ucs->basstate & BS_ATWRPEND)
2485 dev_warn(cs->dev, " sending AT command\n");
2486 update_basstate(ucs, 0, BS_SUSPEND);
2487 return -EBUSY;
2488 }
2489
2490 /* close AT channel if open */
2491 if (ucs->basstate & BS_ATOPEN) {
2492 gig_dbg(DEBUG_SUSPEND, "closing AT channel");
2493 rc = req_submit(cs->bcs, HD_CLOSE_ATCHANNEL, 0, 0);
2494 if (rc) {
2495 update_basstate(ucs, 0, BS_SUSPEND);
2496 return rc;
2497 }
2498 wait_event_timeout(ucs->waitqueue, !ucs->pending,
2499 BAS_TIMEOUT * HZ / 10);
2500 /* in case of timeout, proceed anyway */
2501 }
2502
2503 /* kill all URBs and delayed work that might still be pending */
2504 usb_kill_urb(ucs->urb_ctrl);
2505 usb_kill_urb(ucs->urb_int_in);
2506 del_timer_sync(&ucs->timer_ctrl);
2507 del_timer_sync(&ucs->timer_atrdy);
2508 del_timer_sync(&ucs->timer_cmd_in);
2509 del_timer_sync(&ucs->timer_int_in);
2510
2511 /* don't try to cancel int_in_wq from within reset as it
2512 * might be the one requesting the reset
2513 */
2514 if (message.event != PM_EVENT_ON)
2515 cancel_work_sync(&ucs->int_in_wq);
2516
2517 gig_dbg(DEBUG_SUSPEND, "suspend complete");
2518 return 0;
2519 }
2520
2521 /* gigaset_resume
2522 * This function is called after the USB connection has been resumed.
2523 */
2524 static int gigaset_resume(struct usb_interface *intf)
2525 {
2526 struct cardstate *cs = usb_get_intfdata(intf);
2527 struct bas_cardstate *ucs = cs->hw.bas;
2528 int rc;
2529
2530 /* resubmit interrupt URB for spontaneous messages from base */
2531 rc = usb_submit_urb(ucs->urb_int_in, GFP_KERNEL);
2532 if (rc) {
2533 dev_err(cs->dev, "could not resubmit interrupt URB: %s\n",
2534 get_usb_rcmsg(rc));
2535 return rc;
2536 }
2537 ucs->retry_int_in = 0;
2538
2539 /* clear suspend flag to reallow activity */
2540 update_basstate(ucs, 0, BS_SUSPEND);
2541
2542 gig_dbg(DEBUG_SUSPEND, "resume complete");
2543 return 0;
2544 }
2545
2546 /* gigaset_pre_reset
2547 * This function is called before the USB connection is reset.
2548 */
2549 static int gigaset_pre_reset(struct usb_interface *intf)
2550 {
2551 /* handle just like suspend */
2552 return gigaset_suspend(intf, PMSG_ON);
2553 }
2554
2555 /* gigaset_post_reset
2556 * This function is called after the USB connection has been reset.
2557 */
2558 static int gigaset_post_reset(struct usb_interface *intf)
2559 {
2560 /* FIXME: send HD_DEVICE_INIT_ACK? */
2561
2562 /* resume operations */
2563 return gigaset_resume(intf);
2564 }
2565
2566
2567 static const struct gigaset_ops gigops = {
2568 .write_cmd = gigaset_write_cmd,
2569 .write_room = gigaset_write_room,
2570 .chars_in_buffer = gigaset_chars_in_buffer,
2571 .brkchars = gigaset_brkchars,
2572 .init_bchannel = gigaset_init_bchannel,
2573 .close_bchannel = gigaset_close_bchannel,
2574 .initbcshw = gigaset_initbcshw,
2575 .freebcshw = gigaset_freebcshw,
2576 .reinitbcshw = gigaset_reinitbcshw,
2577 .initcshw = gigaset_initcshw,
2578 .freecshw = gigaset_freecshw,
2579 .set_modem_ctrl = gigaset_set_modem_ctrl,
2580 .baud_rate = gigaset_baud_rate,
2581 .set_line_ctrl = gigaset_set_line_ctrl,
2582 .send_skb = gigaset_isoc_send_skb,
2583 .handle_input = gigaset_isoc_input,
2584 };
2585
2586 /* bas_gigaset_init
2587 * This function is called after the kernel module is loaded.
2588 */
2589 static int __init bas_gigaset_init(void)
2590 {
2591 int result;
2592
2593 /* allocate memory for our driver state and initialize it */
2594 driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
2595 GIGASET_MODULENAME, GIGASET_DEVNAME,
2596 &gigops, THIS_MODULE);
2597 if (driver == NULL)
2598 goto error;
2599
2600 /* register this driver with the USB subsystem */
2601 result = usb_register(&gigaset_usb_driver);
2602 if (result < 0) {
2603 pr_err("error %d registering USB driver\n", -result);
2604 goto error;
2605 }
2606
2607 pr_info(DRIVER_DESC "\n");
2608 return 0;
2609
2610 error:
2611 if (driver)
2612 gigaset_freedriver(driver);
2613 driver = NULL;
2614 return -1;
2615 }
2616
2617 /* bas_gigaset_exit
2618 * This function is called before the kernel module is unloaded.
2619 */
2620 static void __exit bas_gigaset_exit(void)
2621 {
2622 struct bas_cardstate *ucs;
2623 int i;
2624
2625 gigaset_blockdriver(driver); /* => probe will fail
2626 * => no gigaset_start any more
2627 */
2628
2629 /* stop all connected devices */
2630 for (i = 0; i < driver->minors; i++) {
2631 if (gigaset_shutdown(driver->cs + i) < 0)
2632 continue; /* no device */
2633 /* from now on, no isdn callback should be possible */
2634
2635 /* close all still open channels */
2636 ucs = driver->cs[i].hw.bas;
2637 if (ucs->basstate & BS_B1OPEN) {
2638 gig_dbg(DEBUG_INIT, "closing B1 channel");
2639 usb_control_msg(ucs->udev,
2640 usb_sndctrlpipe(ucs->udev, 0),
2641 HD_CLOSE_B1CHANNEL, OUT_VENDOR_REQ,
2642 0, 0, NULL, 0, BAS_TIMEOUT);
2643 }
2644 if (ucs->basstate & BS_B2OPEN) {
2645 gig_dbg(DEBUG_INIT, "closing B2 channel");
2646 usb_control_msg(ucs->udev,
2647 usb_sndctrlpipe(ucs->udev, 0),
2648 HD_CLOSE_B2CHANNEL, OUT_VENDOR_REQ,
2649 0, 0, NULL, 0, BAS_TIMEOUT);
2650 }
2651 if (ucs->basstate & BS_ATOPEN) {
2652 gig_dbg(DEBUG_INIT, "closing AT channel");
2653 usb_control_msg(ucs->udev,
2654 usb_sndctrlpipe(ucs->udev, 0),
2655 HD_CLOSE_ATCHANNEL, OUT_VENDOR_REQ,
2656 0, 0, NULL, 0, BAS_TIMEOUT);
2657 }
2658 ucs->basstate = 0;
2659 }
2660
2661 /* deregister this driver with the USB subsystem */
2662 usb_deregister(&gigaset_usb_driver);
2663 /* this will call the disconnect-callback */
2664 /* from now on, no disconnect/probe callback should be running */
2665
2666 gigaset_freedriver(driver);
2667 driver = NULL;
2668 }
2669
2670
2671 module_init(bas_gigaset_init);
2672 module_exit(bas_gigaset_exit);
2673
2674 MODULE_AUTHOR(DRIVER_AUTHOR);
2675 MODULE_DESCRIPTION(DRIVER_DESC);
2676 MODULE_LICENSE("GPL");
ubuntu-bionic-kernel mirror