blob: c44950d3eb7b48f8a81fd16db9e46ecd15343a39 [file] [log] [blame]
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001/*
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>,
Tilman Schmidt70440cf2006-04-10 22:55:14 -07006 * Stefan Eilers.
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08007 *
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08008 * =====================================================================
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 * =====================================================================
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080014 */
15
16#include "gigaset.h"
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080017#include <linux/usb.h>
18#include <linux/module.h>
19#include <linux/moduleparam.h>
20
21/* Version Information */
Tilman Schmidt70440cf2006-04-10 22:55:14 -070022#define DRIVER_AUTHOR "Tilman Schmidt <tilman@imap.cc>, Hansjoerg Lipp <hjlipp@web.de>, Stefan Eilers"
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080023#define DRIVER_DESC "USB Driver for Gigaset 307x"
24
25
26/* Module parameters */
27
28static int startmode = SM_ISDN;
29static int cidmode = 1;
30
31module_param(startmode, int, S_IRUGO);
32module_param(cidmode, int, S_IRUGO);
33MODULE_PARM_DESC(startmode, "start in isdn4linux mode");
34MODULE_PARM_DESC(cidmode, "Call-ID mode");
35
36#define GIGASET_MINORS 1
37#define GIGASET_MINOR 16
38#define GIGASET_MODULENAME "bas_gigaset"
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080039#define GIGASET_DEVNAME "ttyGB"
40
Tilman Schmidt73a88812006-04-22 02:35:30 -070041/* length limit according to Siemens 3070usb-protokoll.doc ch. 2.1 */
42#define IF_WRITEBUF 264
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080043
Tilman Schmidt170ebf82009-03-18 23:44:23 -070044/* interrupt pipe message size according to ibid. ch. 2.2 */
45#define IP_MSGSIZE 3
46
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080047/* Values for the Gigaset 307x */
48#define USB_GIGA_VENDOR_ID 0x0681
Tilman Schmidt73a88812006-04-22 02:35:30 -070049#define USB_3070_PRODUCT_ID 0x0001
50#define USB_3075_PRODUCT_ID 0x0002
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080051#define USB_SX303_PRODUCT_ID 0x0021
52#define USB_SX353_PRODUCT_ID 0x0022
53
54/* table of devices that work with this driver */
Tilman Schmidt7891adf2009-10-25 09:30:37 +000055static const struct usb_device_id gigaset_table[] = {
Tilman Schmidt73a88812006-04-22 02:35:30 -070056 { USB_DEVICE(USB_GIGA_VENDOR_ID, USB_3070_PRODUCT_ID) },
57 { USB_DEVICE(USB_GIGA_VENDOR_ID, USB_3075_PRODUCT_ID) },
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080058 { 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
63MODULE_DEVICE_TABLE(usb, gigaset_table);
64
Tilman Schmidt06163f862006-06-26 00:25:33 -070065/*======================= local function prototypes ==========================*/
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080066
Tilman Schmidt06163f862006-06-26 00:25:33 -070067/* function called if a new device belonging to this driver is connected */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080068static 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 */
72static void gigaset_disconnect(struct usb_interface *interface);
73
Tilman Schmidt024fd292008-02-06 01:38:26 -080074/* functions called before/after suspend */
75static int gigaset_suspend(struct usb_interface *intf, pm_message_t message);
76static int gigaset_resume(struct usb_interface *intf);
77
78/* functions called before/after device reset */
79static int gigaset_pre_reset(struct usb_interface *intf);
80static int gigaset_post_reset(struct usb_interface *intf);
81
Tilman Schmidt06163f862006-06-26 00:25:33 -070082static int atread_submit(struct cardstate *, int);
Tilman Schmidt73a88812006-04-22 02:35:30 -070083static void stopurbs(struct bas_bc_state *);
Tilman Schmidt06163f862006-06-26 00:25:33 -070084static int req_submit(struct bc_state *, int, int, int);
Tilman Schmidt73a88812006-04-22 02:35:30 -070085static int atwrite_submit(struct cardstate *, unsigned char *, int);
86static int start_cbsend(struct cardstate *);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080087
Tilman Schmidt06163f862006-06-26 00:25:33 -070088/*============================================================================*/
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080089
90struct bas_cardstate {
Tilman Schmidt784d5852006-04-10 22:55:04 -070091 struct usb_device *udev; /* USB device pointer */
92 struct usb_interface *interface; /* interface for this device */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080093 unsigned char minor; /* starting minor number */
94
Tilman Schmidt784d5852006-04-10 22:55:04 -070095 struct urb *urb_ctrl; /* control pipe default URB */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080096 struct usb_ctrlrequest dr_ctrl;
97 struct timer_list timer_ctrl; /* control request timeout */
Tilman Schmidt06163f862006-06-26 00:25:33 -070098 int retry_ctrl;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -080099
100 struct timer_list timer_atrdy; /* AT command ready timeout */
Tilman Schmidt784d5852006-04-10 22:55:04 -0700101 struct urb *urb_cmd_out; /* for sending AT commands */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800102 struct usb_ctrlrequest dr_cmd_out;
103 int retry_cmd_out;
104
Tilman Schmidt784d5852006-04-10 22:55:04 -0700105 struct urb *urb_cmd_in; /* for receiving AT replies */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800106 struct usb_ctrlrequest dr_cmd_in;
107 struct timer_list timer_cmd_in; /* receive request timeout */
Tilman Schmidt784d5852006-04-10 22:55:04 -0700108 unsigned char *rcvbuf; /* AT reply receive buffer */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800109
Tilman Schmidt784d5852006-04-10 22:55:04 -0700110 struct urb *urb_int_in; /* URB for interrupt pipe */
Tilman Schmidt170ebf82009-03-18 23:44:23 -0700111 unsigned char *int_in_buf;
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000112 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;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800115
116 spinlock_t lock; /* locks all following */
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800117 int basstate; /* bitmap (BS_*) */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800118 int pending; /* uncompleted base request */
Tilman Schmidt024fd292008-02-06 01:38:26 -0800119 wait_queue_head_t waitqueue;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800120 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) */
Tilman Schmidt73a88812006-04-22 02:35:30 -0700126#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 */
Tilman Schmidt024fd292008-02-06 01:38:26 -0800134#define BS_SUSPEND 0x100 /* USB port suspended */
Tilman Schmidtb5f581d2009-10-06 12:18:51 +0000135#define BS_RESETTING 0x200 /* waiting for HD_RESET_INTERRUPT_PIPE_ACK */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800136
137
Tilman Schmidt7891adf2009-10-25 09:30:37 +0000138static struct gigaset_driver *driver;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800139
140/* usb specific object needed to register this driver with the usb subsystem */
141static struct usb_driver gigaset_usb_driver = {
142 .name = GIGASET_MODULENAME,
143 .probe = gigaset_probe,
144 .disconnect = gigaset_disconnect,
145 .id_table = gigaset_table,
Tilman Schmidt024fd292008-02-06 01:38:26 -0800146 .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,
Sarah Sharpe1f12eb2012-04-23 10:08:51 -0700151 .disable_hub_initiated_lpm = 1,
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800152};
153
Tilman Schmidt73a88812006-04-22 02:35:30 -0700154/* get message text for usb_submit_urb return code
155 */
156static 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:
Tilman Schmidtbb7196d2010-09-30 13:35:52 +0000176 return "too many isoc frames requested";
Tilman Schmidt73a88812006-04-22 02:35:30 -0700177 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
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800195/* get message text for USB status code
196 */
197static 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:
Tilman Schmidt73a88812006-04-22 02:35:30 -0700205 return "unlinked (sync)";
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800206 case -EINPROGRESS:
Tilman Schmidtbb7196d2010-09-30 13:35:52 +0000207 return "URB still pending";
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800208 case -EPROTO:
Tilman Schmidtbb7196d2010-09-30 13:35:52 +0000209 return "bitstuff error, timeout, or unknown USB error";
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800210 case -EILSEQ:
Tilman Schmidt73a88812006-04-22 02:35:30 -0700211 return "CRC mismatch, timeout, or unknown USB error";
Pete Zaitcev38e2bfc2006-09-18 22:49:02 -0700212 case -ETIME:
Tilman Schmidtbb7196d2010-09-30 13:35:52 +0000213 return "USB response timeout";
Tilman Schmidt73a88812006-04-22 02:35:30 -0700214 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:
Tilman Schmidtbb7196d2010-09-30 13:35:52 +0000221 return "endpoint babble";
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800222 case -EREMOTEIO:
Tilman Schmidtbb7196d2010-09-30 13:35:52 +0000223 return "short packet";
Tilman Schmidt73a88812006-04-22 02:35:30 -0700224 case -ENODEV:
225 return "device removed";
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800226 case -EXDEV:
Tilman Schmidtbb7196d2010-09-30 13:35:52 +0000227 return "partial isoc transfer";
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800228 case -EINVAL:
Tilman Schmidtbb7196d2010-09-30 13:35:52 +0000229 return "ISO madness";
Tilman Schmidt73a88812006-04-22 02:35:30 -0700230 case -ECONNRESET:
231 return "unlinked (async)";
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800232 case -ESHUTDOWN:
Tilman Schmidt73a88812006-04-22 02:35:30 -0700233 return "device shut down";
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800234 default:
Tilman Schmidt73a88812006-04-22 02:35:30 -0700235 snprintf(unkmsg, sizeof(unkmsg), "unknown status %d", status);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800236 return unkmsg;
237 }
238}
239
240/* usb_pipetype_str
241 * retrieve string representation of USB pipe type
242 */
243static 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 */
259static inline void dump_urb(enum debuglevel level, const char *tag,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700260 struct urb *urb)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800261{
262#ifdef CONFIG_GIGASET_DEBUG
263 int i;
Tilman Schmidt784d5852006-04-10 22:55:04 -0700264 gig_dbg(level, "%s urb(0x%08lx)->{", tag, (unsigned long) urb);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800265 if (urb) {
Tilman Schmidt784d5852006-04-10 22:55:04 -0700266 gig_dbg(level,
267 " dev=0x%08lx, pipe=%s:EP%d/DV%d:%s, "
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800268 "hcpriv=0x%08lx, transfer_flags=0x%x,",
Tilman Schmidt784d5852006-04-10 22:55:04 -0700269 (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",
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800273 (unsigned long) urb->hcpriv,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700274 urb->transfer_flags);
275 gig_dbg(level,
276 " transfer_buffer=0x%08lx[%d], actual_length=%d, "
Andrew Morton249b0612007-02-10 01:46:49 -0800277 "setup_packet=0x%08lx,",
Tilman Schmidt784d5852006-04-10 22:55:04 -0700278 (unsigned long) urb->transfer_buffer,
279 urb->transfer_buffer_length, urb->actual_length,
Andrew Morton249b0612007-02-10 01:46:49 -0800280 (unsigned long) urb->setup_packet);
Tilman Schmidt784d5852006-04-10 22:55:04 -0700281 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);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800291 for (i = 0; i < urb->number_of_packets; i++) {
Tilman Schmidt917f5082006-04-10 22:55:00 -0700292 struct usb_iso_packet_descriptor *pifd
293 = &urb->iso_frame_desc[i];
Tilman Schmidt784d5852006-04-10 22:55:04 -0700294 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);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800299 }
300 }
Tilman Schmidt784d5852006-04-10 22:55:04 -0700301 gig_dbg(level, "}}");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800302#endif
303}
304
305/* read/set modem control bits etc. (m10x only) */
306static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700307 unsigned new_state)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800308{
309 return -EINVAL;
310}
311
312static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag)
313{
314 return -EINVAL;
315}
316
317static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
318{
319 return -EINVAL;
320}
321
Tilman Schmidtb5f581d2009-10-06 12:18:51 +0000322/* set/clear bits in base connection state, return previous state
323 */
324static 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
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800337/* 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.
Tilman Schmidt06163f862006-06-26 00:25:33 -0700341 * cs->lock must not be held.
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800342 * argument:
343 * B channel control structure
344 */
345static inline void error_hangup(struct bc_state *bcs)
346{
347 struct cardstate *cs = bcs->cs;
348
Tilman Schmidt1528b182010-02-22 13:09:52 +0000349 gigaset_add_event(cs, &bcs->at_state, EV_HUP, NULL, 0, NULL);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800350 gigaset_schedule_event(cs);
351}
352
353/* error_reset
354 * reset Gigaset device because of an unrecoverable error
Tilman Schmidt06163f862006-06-26 00:25:33 -0700355 * This function may be called from any context, and takes care of
Tilman Schmidt73a88812006-04-22 02:35:30 -0700356 * scheduling the necessary actions for execution outside of interrupt context.
Tilman Schmidt60798c682010-09-30 13:35:21 +0000357 * cs->hw.bas->lock must not be held.
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800358 * argument:
359 * controller state structure
360 */
361static inline void error_reset(struct cardstate *cs)
362{
Tilman Schmidtb5f581d2009-10-06 12:18:51 +0000363 /* reset interrupt pipe to recover (ignore errors) */
364 update_basstate(cs->hw.bas, BS_RESETTING, 0);
Tilman Schmidt60798c682010-09-30 13:35:21 +0000365 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);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800368}
369
370/* check_pending
371 * check for completion of pending control request
372 * parameter:
Tilman Schmidt784d5852006-04-10 22:55:04 -0700373 * ucs hardware specific controller state structure
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800374 */
375static void check_pending(struct bas_cardstate *ucs)
376{
377 unsigned long flags;
378
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800379 spin_lock_irqsave(&ucs->lock, flags);
380 switch (ucs->pending) {
381 case 0:
382 break;
383 case HD_OPEN_ATCHANNEL:
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800384 if (ucs->basstate & BS_ATOPEN)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800385 ucs->pending = 0;
386 break;
387 case HD_OPEN_B1CHANNEL:
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800388 if (ucs->basstate & BS_B1OPEN)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800389 ucs->pending = 0;
390 break;
391 case HD_OPEN_B2CHANNEL:
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800392 if (ucs->basstate & BS_B2OPEN)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800393 ucs->pending = 0;
394 break;
395 case HD_CLOSE_ATCHANNEL:
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800396 if (!(ucs->basstate & BS_ATOPEN))
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800397 ucs->pending = 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800398 break;
399 case HD_CLOSE_B1CHANNEL:
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800400 if (!(ucs->basstate & BS_B1OPEN))
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800401 ucs->pending = 0;
402 break;
403 case HD_CLOSE_B2CHANNEL:
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800404 if (!(ucs->basstate & BS_B2OPEN))
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800405 ucs->pending = 0;
406 break;
407 case HD_DEVICE_INIT_ACK: /* no reply expected */
408 ucs->pending = 0;
409 break;
Tilman Schmidtb5f581d2009-10-06 12:18:51 +0000410 case HD_RESET_INTERRUPT_PIPE:
411 if (!(ucs->basstate & BS_RESETTING))
412 ucs->pending = 0;
413 break;
Tilman Schmidtf86936f2012-04-25 13:02:20 +0000414 /*
415 * HD_READ_ATMESSAGE and HD_WRITE_ATMESSAGE are handled separately
416 * and should never end up here
417 */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800418 default:
Tilman Schmidt784d5852006-04-10 22:55:04 -0700419 dev_warn(&ucs->interface->dev,
420 "unknown pending request 0x%02x cleared\n",
421 ucs->pending);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800422 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 */
436static void cmd_in_timeout(unsigned long data)
437{
438 struct cardstate *cs = (struct cardstate *) data;
Tilman Schmidtd48c7782006-04-10 22:55:08 -0700439 struct bas_cardstate *ucs = cs->hw.bas;
Tilman Schmidt06163f862006-06-26 00:25:33 -0700440 int rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800441
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800442 if (!ucs->rcvbuf_size) {
Tilman Schmidt784d5852006-04-10 22:55:04 -0700443 gig_dbg(DEBUG_USBREQ, "%s: no receive in progress", __func__);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800444 return;
445 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800446
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000447 if (ucs->retry_cmd_in++ >= BAS_RETRY) {
Tilman Schmidt06163f862006-06-26 00:25:33 -0700448 dev_err(cs->dev,
449 "control read: timeout, giving up after %d tries\n",
450 ucs->retry_cmd_in);
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000451 kfree(ucs->rcvbuf);
452 ucs->rcvbuf = NULL;
453 ucs->rcvbuf_size = 0;
454 error_reset(cs);
455 return;
Tilman Schmidt06163f862006-06-26 00:25:33 -0700456 }
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000457
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 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800468}
469
Tilman Schmidt06163f862006-06-26 00:25:33 -0700470/* 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 */
David Howells7d12e782006-10-05 14:55:46 +0100477static void read_ctrl_callback(struct urb *urb)
Tilman Schmidt06163f862006-06-26 00:25:33 -0700478{
479 struct inbuf_t *inbuf = urb->context;
480 struct cardstate *cs = inbuf->cs;
481 struct bas_cardstate *ucs = cs->hw.bas;
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800482 int status = urb->status;
Tilman Schmidt06163f862006-06-26 00:25:33 -0700483 unsigned numbytes;
484 int rc;
485
486 update_basstate(ucs, 0, BS_ATRDPEND);
Tilman Schmidt024fd292008-02-06 01:38:26 -0800487 wake_up(&ucs->waitqueue);
Tilman Schmidt06163f862006-06-26 00:25:33 -0700488 del_timer(&ucs->timer_cmd_in);
489
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800490 switch (status) {
Tilman Schmidt06163f862006-06-26 00:25:33 -0700491 case 0: /* normal completion */
492 numbytes = urb->actual_length;
493 if (unlikely(numbytes != ucs->rcvbuf_size)) {
494 dev_warn(cs->dev,
Joe Perches475be4d2012-02-19 19:52:38 -0800495 "control read: received %d chars, expected %d\n",
Tilman Schmidt06163f862006-06-26 00:25:33 -0700496 numbytes, ucs->rcvbuf_size);
497 if (numbytes > ucs->rcvbuf_size)
498 numbytes = ucs->rcvbuf_size;
499 }
500
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000501 /* 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);
Tilman Schmidt06163f862006-06-26 00:25:33 -0700505 }
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 */
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000513 /* no further action necessary */
Tilman Schmidt06163f862006-06-26 00:25:33 -0700514 gig_dbg(DEBUG_USBREQ, "%s: %s",
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800515 __func__, get_usb_statmsg(status));
Tilman Schmidt06163f862006-06-26 00:25:33 -0700516 break;
517
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000518 default: /* other errors: retry */
Tilman Schmidt06163f862006-06-26 00:25:33 -0700519 if (ucs->retry_cmd_in++ < BAS_RETRY) {
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000520 gig_dbg(DEBUG_USBREQ, "%s: %s, retry %d", __func__,
521 get_usb_statmsg(status), ucs->retry_cmd_in);
Tilman Schmidt06163f862006-06-26 00:25:33 -0700522 rc = atread_submit(cs, BAS_TIMEOUT);
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000523 if (rc >= 0)
524 /* successfully resubmitted, skip freeing */
Tilman Schmidt06163f862006-06-26 00:25:33 -0700525 return;
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000526 if (rc == -ENODEV)
527 /* disconnect, no further action necessary */
528 break;
Tilman Schmidt06163f862006-06-26 00:25:33 -0700529 }
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000530 dev_err(cs->dev, "control read: %s, giving up after %d tries\n",
531 get_usb_statmsg(status), ucs->retry_cmd_in);
Tilman Schmidt06163f862006-06-26 00:25:33 -0700532 error_reset(cs);
533 }
534
Tilman Schmidtc8701a02010-09-30 13:34:40 +0000535 /* read finished, free buffer */
Tilman Schmidt06163f862006-06-26 00:25:33 -0700536 kfree(ucs->rcvbuf);
537 ucs->rcvbuf = NULL;
538 ucs->rcvbuf_size = 0;
Tilman Schmidt06163f862006-06-26 00:25:33 -0700539}
540
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800541/* atread_submit
Tilman Schmidt73a88812006-04-22 02:35:30 -0700542 * submit an HD_READ_ATMESSAGE command URB and optionally start a timeout
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800543 * parameters:
544 * cs controller state structure
545 * timeout timeout in 1/10 sec., 0: none
546 * return value:
547 * 0 on success
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800548 * -EBUSY if another request is pending
549 * any URB submission error code
550 */
551static int atread_submit(struct cardstate *cs, int timeout)
552{
Tilman Schmidtd48c7782006-04-10 22:55:08 -0700553 struct bas_cardstate *ucs = cs->hw.bas;
Tilman Schmidt024fd292008-02-06 01:38:26 -0800554 int basstate;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800555 int ret;
556
Tilman Schmidt784d5852006-04-10 22:55:04 -0700557 gig_dbg(DEBUG_USBREQ, "-------> HD_READ_ATMESSAGE (%d)",
558 ucs->rcvbuf_size);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800559
Tilman Schmidt024fd292008-02-06 01:38:26 -0800560 basstate = update_basstate(ucs, BS_ATRDPEND, 0);
561 if (basstate & BS_ATRDPEND) {
Tilman Schmidt784d5852006-04-10 22:55:04 -0700562 dev_err(cs->dev,
563 "could not submit HD_READ_ATMESSAGE: URB busy\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800564 return -EBUSY;
565 }
566
Tilman Schmidt024fd292008-02-06 01:38:26 -0800567 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
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800576 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,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700582 usb_rcvctrlpipe(ucs->udev, 0),
Tilman Schmidt7891adf2009-10-25 09:30:37 +0000583 (unsigned char *) &ucs->dr_cmd_in,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700584 ucs->rcvbuf, ucs->rcvbuf_size,
585 read_ctrl_callback, cs->inbuf);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800586
Tilman Schmidt7891adf2009-10-25 09:30:37 +0000587 ret = usb_submit_urb(ucs->urb_cmd_in, GFP_ATOMIC);
588 if (ret != 0) {
Tilman Schmidt73a88812006-04-22 02:35:30 -0700589 update_basstate(ucs, 0, BS_ATRDPEND);
Tilman Schmidt784d5852006-04-10 22:55:04 -0700590 dev_err(cs->dev, "could not submit HD_READ_ATMESSAGE: %s\n",
Tilman Schmidt06163f862006-06-26 00:25:33 -0700591 get_usb_rcmsg(ret));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800592 return ret;
593 }
594
595 if (timeout > 0) {
Tilman Schmidt784d5852006-04-10 22:55:04 -0700596 gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +0000597 mod_timer(&ucs->timer_cmd_in, jiffies + timeout * HZ / 10);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800598 }
599 return 0;
600}
601
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000602/* int_in_work
603 * workqueue routine to clear halt on interrupt in endpoint
604 */
605
606static 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);
Tilman Schmidtc6fdd8e2012-10-24 08:44:32 +0000620
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 */
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000627 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 */
642static 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
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800664/* 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 */
David Howells7d12e782006-10-05 14:55:46 +0100671static void read_int_callback(struct urb *urb)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800672{
Tilman Schmidtd48c7782006-04-10 22:55:08 -0700673 struct cardstate *cs = urb->context;
674 struct bas_cardstate *ucs = cs->hw.bas;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800675 struct bc_state *bcs;
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800676 int status = urb->status;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800677 unsigned long flags;
Tilman Schmidt73a88812006-04-22 02:35:30 -0700678 int rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800679 unsigned l;
680 int channel;
681
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800682 switch (status) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800683 case 0: /* success */
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000684 ucs->retry_int_in = 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800685 break;
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000686 case -EPIPE: /* endpoint stalled */
687 schedule_work(&ucs->int_in_wq);
688 /* fall through */
Tilman Schmidt73a88812006-04-22 02:35:30 -0700689 case -ENOENT: /* cancelled */
690 case -ECONNRESET: /* cancelled (async) */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800691 case -EINPROGRESS: /* pending */
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000692 case -ENODEV: /* device removed */
693 case -ESHUTDOWN: /* device shut down */
694 /* no further action necessary */
Tilman Schmidt784d5852006-04-10 22:55:04 -0700695 gig_dbg(DEBUG_USBREQ, "%s: %s",
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800696 __func__, get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800697 return;
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000698 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);
Tilman Schmidt73a88812006-04-22 02:35:30 -0700705 return;
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000706 default: /* other errors: just resubmit */
Tilman Schmidt784d5852006-04-10 22:55:04 -0700707 dev_warn(cs->dev, "interrupt read: %s\n",
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800708 get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800709 goto resubmit;
710 }
711
Tilman Schmidt73a88812006-04-22 02:35:30 -0700712 /* drop incomplete packets even if the missing bytes wouldn't matter */
Tilman Schmidt170ebf82009-03-18 23:44:23 -0700713 if (unlikely(urb->actual_length < IP_MSGSIZE)) {
Tilman Schmidt73a88812006-04-22 02:35:30 -0700714 dev_warn(cs->dev, "incomplete interrupt packet (%d bytes)\n",
715 urb->actual_length);
716 goto resubmit;
717 }
718
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800719 l = (unsigned) ucs->int_in_buf[1] +
Joe Perches475be4d2012-02-19 19:52:38 -0800720 (((unsigned) ucs->int_in_buf[2]) << 8);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800721
Tilman Schmidt784d5852006-04-10 22:55:04 -0700722 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]);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800725
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,
Tilman Schmidt784d5852006-04-10 22:55:04 -0700770 &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));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800775 break;
776
777 case HD_RECEIVEATDATA_ACK: /* AT response ready to be received */
778 if (!l) {
Tilman Schmidt784d5852006-04-10 22:55:04 -0700779 dev_warn(cs->dev,
Joe Perches475be4d2012-02-19 19:52:38 -0800780 "HD_RECEIVEATDATA_ACK with length 0 ignored\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800781 break;
782 }
783 spin_lock_irqsave(&cs->lock, flags);
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000784 if (ucs->basstate & BS_ATRDPEND) {
785 spin_unlock_irqrestore(&cs->lock, flags);
786 dev_warn(cs->dev,
Joe Perches475be4d2012-02-19 19:52:38 -0800787 "HD_RECEIVEATDATA_ACK(%d) during HD_READ_ATMESSAGE(%d) ignored\n",
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000788 l, ucs->rcvbuf_size);
789 break;
790 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800791 if (ucs->rcvbuf_size) {
Tilman Schmidt73a88812006-04-22 02:35:30 -0700792 /* throw away previous buffer - we have no queue */
Tilman Schmidt784d5852006-04-10 22:55:04 -0700793 dev_err(cs->dev,
Tilman Schmidt73a88812006-04-22 02:35:30 -0700794 "receive AT data overrun, %d bytes lost\n",
795 ucs->rcvbuf_size);
796 kfree(ucs->rcvbuf);
797 ucs->rcvbuf_size = 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800798 }
Tilman Schmidt7891adf2009-10-25 09:30:37 +0000799 ucs->rcvbuf = kmalloc(l, GFP_ATOMIC);
800 if (ucs->rcvbuf == NULL) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800801 spin_unlock_irqrestore(&cs->lock, flags);
Tilman Schmidt73a88812006-04-22 02:35:30 -0700802 dev_err(cs->dev, "out of memory receiving AT data\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800803 break;
804 }
805 ucs->rcvbuf_size = l;
806 ucs->retry_cmd_in = 0;
Tilman Schmidt7891adf2009-10-25 09:30:37 +0000807 rc = atread_submit(cs, BAS_TIMEOUT);
808 if (rc < 0) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800809 kfree(ucs->rcvbuf);
810 ucs->rcvbuf = NULL;
811 ucs->rcvbuf_size = 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800812 }
813 spin_unlock_irqrestore(&cs->lock, flags);
Tilman Schmidtc9c0c302010-09-30 13:35:42 +0000814 if (rc < 0 && rc != -ENODEV)
815 error_reset(cs);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800816 break;
817
818 case HD_RESET_INTERRUPT_PIPE_ACK:
Tilman Schmidtb5f581d2009-10-06 12:18:51 +0000819 update_basstate(ucs, 0, BS_RESETTING);
820 dev_notice(cs->dev, "interrupt pipe reset\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800821 break;
822
823 case HD_SUSPEND_END:
Tilman Schmidt784d5852006-04-10 22:55:04 -0700824 gig_dbg(DEBUG_USBREQ, "HD_SUSPEND_END");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800825 break;
826
827 default:
Tilman Schmidt784d5852006-04-10 22:55:04 -0700828 dev_warn(cs->dev,
829 "unknown Gigaset signal 0x%02x (%u) ignored\n",
830 (int) ucs->int_in_buf[0], l);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800831 }
832
833 check_pending(ucs);
Tilman Schmidt024fd292008-02-06 01:38:26 -0800834 wake_up(&ucs->waitqueue);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800835
836resubmit:
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800837 rc = usb_submit_urb(urb, GFP_ATOMIC);
Tilman Schmidt73a88812006-04-22 02:35:30 -0700838 if (unlikely(rc != 0 && rc != -ENODEV)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -0700839 dev_err(cs->dev, "could not resubmit interrupt URB: %s\n",
Tilman Schmidt73a88812006-04-22 02:35:30 -0700840 get_usb_rcmsg(rc));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800841 error_reset(cs);
842 }
843}
844
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800845/* 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 */
David Howells7d12e782006-10-05 14:55:46 +0100852static void read_iso_callback(struct urb *urb)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800853{
854 struct bc_state *bcs;
855 struct bas_bc_state *ubc;
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800856 int status = urb->status;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800857 unsigned long flags;
858 int i, rc;
859
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800860 /* status codes not worth bothering the tasklet with */
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800861 if (unlikely(status == -ENOENT ||
862 status == -ECONNRESET ||
863 status == -EINPROGRESS ||
864 status == -ENODEV ||
865 status == -ESHUTDOWN)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -0700866 gig_dbg(DEBUG_ISO, "%s: %s",
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800867 __func__, get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800868 return;
869 }
870
Tilman Schmidtd48c7782006-04-10 22:55:08 -0700871 bcs = urb->context;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800872 ubc = bcs->hw.bas;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800873
874 spin_lock_irqsave(&ubc->isoinlock, flags);
875 if (likely(ubc->isoindone == NULL)) {
876 /* pass URB to tasklet */
877 ubc->isoindone = urb;
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800878 ubc->isoinstatus = status;
Tilman Schmidt368fd812009-04-05 06:39:33 +0000879 tasklet_hi_schedule(&ubc->rcvd_tasklet);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800880 } else {
881 /* tasklet still busy, drop data and resubmit URB */
Tilman Schmidtbb7196d2010-09-30 13:35:52 +0000882 gig_dbg(DEBUG_ISO, "%s: overrun", __func__);
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800883 ubc->loststatus = status;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800884 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 &&
Tilman Schmidtf86936f2012-04-25 13:02:20 +0000887 urb->iso_frame_desc[i].status != -EINPROGRESS))
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800888 ubc->loststatus = urb->iso_frame_desc[i].status;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800889 urb->iso_frame_desc[i].status = 0;
890 urb->iso_frame_desc[i].actual_length = 0;
891 }
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800892 if (likely(ubc->running)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -0700893 /* urb->dev is clobbered by USB subsystem */
894 urb->dev = bcs->cs->hw.bas->udev;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800895 urb->transfer_flags = URB_ISO_ASAP;
896 urb->number_of_packets = BAS_NUMFRAMES;
Christoph Lameter54e6ecb2006-12-06 20:33:16 -0800897 rc = usb_submit_urb(urb, GFP_ATOMIC);
Tilman Schmidt73a88812006-04-22 02:35:30 -0700898 if (unlikely(rc != 0 && rc != -ENODEV)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -0700899 dev_err(bcs->cs->dev,
Joe Perches475be4d2012-02-19 19:52:38 -0800900 "could not resubmit isoc read URB: %s\n",
Tilman Schmidtbb7196d2010-09-30 13:35:52 +0000901 get_usb_rcmsg(rc));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800902 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 */
David Howells7d12e782006-10-05 14:55:46 +0100917static void write_iso_callback(struct urb *urb)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800918{
919 struct isow_urbctx_t *ucx;
920 struct bas_bc_state *ubc;
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800921 int status = urb->status;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800922 unsigned long flags;
923
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800924 /* status codes not worth bothering the tasklet with */
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800925 if (unlikely(status == -ENOENT ||
926 status == -ECONNRESET ||
927 status == -EINPROGRESS ||
928 status == -ENODEV ||
929 status == -ESHUTDOWN)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -0700930 gig_dbg(DEBUG_ISO, "%s: %s",
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800931 __func__, get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800932 return;
933 }
934
935 /* pass URB context to tasklet */
Tilman Schmidtd48c7782006-04-10 22:55:08 -0700936 ucx = urb->context;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800937 ubc = ucx->bcs->hw.bas;
Tilman Schmidtdbd98232008-02-06 01:38:23 -0800938 ucx->status = status;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800939
940 spin_lock_irqsave(&ubc->isooutlock, flags);
941 ubc->isooutovfl = ubc->isooutdone;
942 ubc->isooutdone = ucx;
943 spin_unlock_irqrestore(&ubc->isooutlock, flags);
Tilman Schmidt368fd812009-04-05 06:39:33 +0000944 tasklet_hi_schedule(&ubc->sent_tasklet);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800945}
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 */
955static int starturbs(struct bc_state *bcs)
956{
Tilman Schmidtd48c7782006-04-10 22:55:08 -0700957 struct bas_bc_state *ubc = bcs->hw.bas;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800958 struct urb *urb;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800959 int j, k;
960 int rc;
961
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800962 /* initialize L2 reception */
Tilman Schmidt088ec0c2009-10-06 12:19:07 +0000963 if (bcs->proto2 == L2_HDLC)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800964 bcs->inputstate |= INS_flag_hunt;
965
966 /* submit all isochronous input URBs */
Tilman Schmidt9d4bee22008-02-06 01:38:28 -0800967 ubc->running = 1;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800968 for (k = 0; k < BAS_INURBS; k++) {
969 urb = ubc->isoinurbs[k];
970 if (!urb) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800971 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);
Tilman Schmidt7891adf2009-10-25 09:30:37 +0000992 rc = usb_submit_urb(urb, GFP_ATOMIC);
993 if (rc != 0)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800994 goto error;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -0800995 }
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) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001004 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
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001025 /* keep one URB free, submit the others */
Joe Perches475be4d2012-02-19 19:52:38 -08001026 for (k = 0; k < BAS_OUTURBS - 1; ++k) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001027 dump_urb(DEBUG_ISO, "Initial isoc write", urb);
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001028 rc = usb_submit_urb(ubc->isoouturbs[k].urb, GFP_ATOMIC);
Tilman Schmidt73a88812006-04-22 02:35:30 -07001029 if (rc != 0)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001030 goto error;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001031 }
1032 dump_urb(DEBUG_ISO, "Initial isoc write (free)", urb);
Joe Perches475be4d2012-02-19 19:52:38 -08001033 ubc->isooutfree = &ubc->isoouturbs[BAS_OUTURBS - 1];
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001034 ubc->isooutdone = ubc->isooutovfl = NULL;
1035 return 0;
Joe Perches475be4d2012-02-19 19:52:38 -08001036error:
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001037 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 */
1047static void stopurbs(struct bas_bc_state *ubc)
1048{
1049 int k, rc;
1050
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001051 ubc->running = 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001052
1053 for (k = 0; k < BAS_INURBS; ++k) {
1054 rc = usb_unlink_urb(ubc->isoinurbs[k]);
Tilman Schmidt784d5852006-04-10 22:55:04 -07001055 gig_dbg(DEBUG_ISO,
Tilman Schmidt73a88812006-04-22 02:35:30 -07001056 "%s: isoc input URB %d unlinked, result = %s",
1057 __func__, k, get_usb_rcmsg(rc));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001058 }
1059
1060 for (k = 0; k < BAS_OUTURBS; ++k) {
1061 rc = usb_unlink_urb(ubc->isoouturbs[k].urb);
Tilman Schmidt784d5852006-04-10 22:55:04 -07001062 gig_dbg(DEBUG_ISO,
Tilman Schmidt73a88812006-04-22 02:35:30 -07001063 "%s: isoc output URB %d unlinked, result = %s",
1064 __func__, k, get_usb_rcmsg(rc));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001065 }
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:
Tilman Schmidt73a88812006-04-22 02:35:30 -07001074 * ucx context structure containing URB
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001075 * 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 */
1080static int submit_iso_write_urb(struct isow_urbctx_t *ucx)
1081{
Tilman Schmidtd48c7782006-04-10 22:55:08 -07001082 struct urb *urb = ucx->urb;
1083 struct bas_bc_state *ubc = ucx->bcs->hw.bas;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001084 struct usb_iso_packet_descriptor *ifd;
1085 int corrbytes, nframe, rc;
1086
Tilman Schmidt784d5852006-04-10 22:55:04 -07001087 /* urb->dev is clobbered by USB subsystem */
1088 urb->dev = ucx->bcs->cs->hw.bas->udev;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001089 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;
Tilman Schmidt7891adf2009-10-25 09:30:37 +00001098 corrbytes = atomic_read(&ubc->corrbytes);
1099 if (corrbytes != 0) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001100 gig_dbg(DEBUG_ISO, "%s: corrbytes=%d",
1101 __func__, corrbytes);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001102 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 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001109
1110 /* retrieve block of data to send */
Tilman Schmidt5f09c4c2008-07-23 21:28:27 -07001111 rc = gigaset_isowbuf_getbytes(ubc->isooutbuf, ifd->length);
1112 if (rc < 0) {
1113 if (rc == -EBUSY) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001114 gig_dbg(DEBUG_ISO,
1115 "%s: buffer busy at frame %d",
1116 __func__, nframe);
1117 /* tasklet will be restarted from
Tilman Schmidt088ec0c2009-10-06 12:19:07 +00001118 gigaset_isoc_send_skb() */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001119 } else {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001120 dev_err(ucx->bcs->cs->dev,
1121 "%s: buffer error %d at frame %d\n",
Tilman Schmidt5f09c4c2008-07-23 21:28:27 -07001122 __func__, rc, nframe);
1123 return rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001124 }
1125 break;
1126 }
Tilman Schmidt5f09c4c2008-07-23 21:28:27 -07001127 ifd->offset = rc;
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001128 ucx->limit = ubc->isooutbuf->nextread;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001129 ifd->status = 0;
1130 ifd->actual_length = 0;
1131 }
Tilman Schmidt73a88812006-04-22 02:35:30 -07001132 if (unlikely(nframe == 0))
1133 return 0; /* no data to send */
1134 urb->number_of_packets = nframe;
Tilman Schmidt69049cc2006-04-10 22:55:16 -07001135
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001136 rc = usb_submit_urb(urb, GFP_ATOMIC);
Tilman Schmidt73a88812006-04-22 02:35:30 -07001137 if (unlikely(rc)) {
1138 if (rc == -ENODEV)
1139 /* device removed - give up silently */
1140 gig_dbg(DEBUG_ISO, "%s: disconnected", __func__);
1141 else
Tilman Schmidt784d5852006-04-10 22:55:04 -07001142 dev_err(ucx->bcs->cs->dev,
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001143 "could not submit isoc write URB: %s\n",
Tilman Schmidt73a88812006-04-22 02:35:30 -07001144 get_usb_rcmsg(rc));
1145 return rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001146 }
Tilman Schmidt73a88812006-04-22 02:35:30 -07001147 ++ubc->numsub;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001148 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 */
1157static void write_iso_tasklet(unsigned long data)
1158{
Tilman Schmidtd48c7782006-04-10 22:55:08 -07001159 struct bc_state *bcs = (struct bc_state *) data;
1160 struct bas_bc_state *ubc = bcs->hw.bas;
1161 struct cardstate *cs = bcs->cs;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001162 struct isow_urbctx_t *done, *next, *ovfl;
1163 struct urb *urb;
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001164 int status;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001165 struct usb_iso_packet_descriptor *ifd;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001166 unsigned long flags;
1167 int i;
1168 struct sk_buff *skb;
1169 int len;
Tilman Schmidt73a88812006-04-22 02:35:30 -07001170 int rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001171
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001172 /* loop while completed URBs arrive in time */
1173 for (;;) {
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001174 if (unlikely(!(ubc->running))) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001175 gig_dbg(DEBUG_ISO, "%s: not running", __func__);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001176 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) {
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001187 dev_err(cs->dev, "isoc write underrun\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001188 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) {
Tilman Schmidt73a88812006-04-22 02:35:30 -07001200 rc = submit_iso_write_urb(next);
1201 if (unlikely(rc <= 0 && rc != -ENODEV)) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001202 /* 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 */
Tilman Schmidt784d5852006-04-10 22:55:04 -07001211 dev_err(cs->dev,
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001212 "losing isoc write URB\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001213 error_hangup(bcs);
1214 }
1215 }
1216 }
1217
1218 /* process completed URB */
1219 urb = done->urb;
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001220 status = done->status;
1221 switch (status) {
Tilman Schmidt73a88812006-04-22 02:35:30 -07001222 case -EXDEV: /* partial completion */
1223 gig_dbg(DEBUG_ISO, "%s: URB partially completed",
1224 __func__);
1225 /* fall through - what's the difference anyway? */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001226 case 0: /* normal completion */
Tilman Schmidt73a88812006-04-22 02:35:30 -07001227 /* inspect individual frames
1228 * assumptions (for lack of documentation):
1229 * - actual_length bytes of first frame in error are
Tilman Schmidt917f5082006-04-10 22:55:00 -07001230 * successfully sent
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001231 * - all following frames are not sent at all
1232 */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001233 for (i = 0; i < BAS_NUMFRAMES; i++) {
1234 ifd = &urb->iso_frame_desc[i];
1235 if (ifd->status ||
1236 ifd->actual_length != ifd->length) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001237 dev_warn(cs->dev,
Joe Perches475be4d2012-02-19 19:52:38 -08001238 "isoc write: frame %d[%d/%d]: %s\n",
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001239 i, ifd->actual_length,
1240 ifd->length,
1241 get_usb_statmsg(ifd->status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001242 break;
1243 }
1244 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001245 break;
Tilman Schmidt73a88812006-04-22 02:35:30 -07001246 case -EPIPE: /* stall - probably underrun */
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001247 dev_err(cs->dev, "isoc write: stalled\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001248 error_hangup(bcs);
1249 break;
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001250 default: /* other errors */
1251 dev_warn(cs->dev, "isoc write: %s\n",
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001252 get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001253 }
1254
1255 /* mark the write buffer area covered by this URB as free */
1256 if (done->limit >= 0)
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001257 ubc->isooutbuf->read = done->limit;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001258
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 */
Tilman Schmidt73a88812006-04-22 02:35:30 -07001266 rc = submit_iso_write_urb(next);
1267 if (unlikely(rc <= 0 && rc != -ENODEV)) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001268 /* 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);
Tilman Schmidt784d5852006-04-10 22:55:04 -07001281 gig_dbg(DEBUG_ISO, "%s: skb requeued, qlen=%d",
1282 __func__, skb_queue_len(&bcs->squeue));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001283 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 */
1300static void read_iso_tasklet(unsigned long data)
1301{
Tilman Schmidtd48c7782006-04-10 22:55:08 -07001302 struct bc_state *bcs = (struct bc_state *) data;
1303 struct bas_bc_state *ubc = bcs->hw.bas;
1304 struct cardstate *cs = bcs->cs;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001305 struct urb *urb;
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001306 int status;
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001307 struct usb_iso_packet_descriptor *ifd;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001308 char *rcvbuf;
1309 unsigned long flags;
1310 int totleft, numbytes, offset, frame, rc;
1311
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001312 /* loop while more completed URBs arrive in the meantime */
1313 for (;;) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001314 /* retrieve URB */
1315 spin_lock_irqsave(&ubc->isoinlock, flags);
Tilman Schmidt7891adf2009-10-25 09:30:37 +00001316 urb = ubc->isoindone;
1317 if (!urb) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001318 spin_unlock_irqrestore(&ubc->isoinlock, flags);
1319 return;
1320 }
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001321 status = ubc->isoinstatus;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001322 ubc->isoindone = NULL;
1323 if (unlikely(ubc->loststatus != -EINPROGRESS)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001324 dev_warn(cs->dev,
Joe Perches475be4d2012-02-19 19:52:38 -08001325 "isoc read overrun, URB dropped (status: %s, %d bytes)\n",
Tilman Schmidt784d5852006-04-10 22:55:04 -07001326 get_usb_statmsg(ubc->loststatus),
1327 ubc->isoinlost);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001328 ubc->loststatus = -EINPROGRESS;
1329 }
1330 spin_unlock_irqrestore(&ubc->isoinlock, flags);
1331
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001332 if (unlikely(!(ubc->running))) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001333 gig_dbg(DEBUG_ISO,
1334 "%s: channel not running, "
1335 "dropped URB with status: %s",
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001336 __func__, get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001337 return;
1338 }
1339
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001340 switch (status) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001341 case 0: /* normal completion */
1342 break;
Tilman Schmidt917f5082006-04-10 22:55:00 -07001343 case -EXDEV: /* inspect individual frames
1344 (we do that anyway) */
Tilman Schmidt784d5852006-04-10 22:55:04 -07001345 gig_dbg(DEBUG_ISO, "%s: URB partially completed",
1346 __func__);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001347 break;
1348 case -ENOENT:
1349 case -ECONNRESET:
Tilman Schmidt73a88812006-04-22 02:35:30 -07001350 case -EINPROGRESS:
1351 gig_dbg(DEBUG_ISO, "%s: %s",
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001352 __func__, get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001353 continue; /* -> skip */
1354 case -EPIPE:
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001355 dev_err(cs->dev, "isoc read: stalled\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001356 error_hangup(bcs);
1357 continue; /* -> skip */
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001358 default: /* other error */
1359 dev_warn(cs->dev, "isoc read: %s\n",
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001360 get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001361 goto error;
1362 }
1363
1364 rcvbuf = urb->transfer_buffer;
1365 totleft = urb->actual_length;
1366 for (frame = 0; totleft > 0 && frame < BAS_NUMFRAMES; frame++) {
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001367 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 */
Tilman Schmidt784d5852006-04-10 22:55:04 -07001383 dev_warn(cs->dev,
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001384 "isoc read: frame %d[%d]: %s\n",
Tilman Schmidteb4459f2009-10-06 12:18:36 +00001385 frame, numbytes,
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001386 get_usb_statmsg(ifd->status));
1387 }
Tilman Schmidteb4459f2009-10-06 12:18:36 +00001388 if (unlikely(numbytes > BAS_MAXFRAME))
Tilman Schmidt784d5852006-04-10 22:55:04 -07001389 dev_warn(cs->dev,
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001390 "isoc read: frame %d[%d]: %s\n",
1391 frame, numbytes,
1392 "exceeds max frame size");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001393 if (unlikely(numbytes > totleft)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001394 dev_warn(cs->dev,
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001395 "isoc read: frame %d[%d]: %s\n",
1396 frame, numbytes,
1397 "exceeds total transfer length");
Tilman Schmidteb4459f2009-10-06 12:18:36 +00001398 numbytes = totleft;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001399 }
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001400 offset = ifd->offset;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001401 if (unlikely(offset + numbytes > BAS_INBUFSIZE)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001402 dev_warn(cs->dev,
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001403 "isoc read: frame %d[%d]: %s\n",
1404 frame, numbytes,
1405 "exceeds end of buffer");
Tilman Schmidteb4459f2009-10-06 12:18:36 +00001406 numbytes = BAS_INBUFSIZE - offset;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001407 }
1408 gigaset_isoc_receive(rcvbuf + offset, numbytes, bcs);
1409 totleft -= numbytes;
1410 }
1411 if (unlikely(totleft > 0))
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001412 dev_warn(cs->dev, "isoc read: %d data bytes missing\n",
Tilman Schmidt784d5852006-04-10 22:55:04 -07001413 totleft);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001414
Tilman Schmidt7891adf2009-10-25 09:30:37 +00001415error:
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001416 /* 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 }
Tilman Schmidt784d5852006-04-10 22:55:04 -07001421 /* urb->dev is clobbered by USB subsystem */
1422 urb->dev = bcs->cs->hw.bas->udev;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001423 urb->transfer_flags = URB_ISO_ASAP;
1424 urb->number_of_packets = BAS_NUMFRAMES;
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001425 rc = usb_submit_urb(urb, GFP_ATOMIC);
Tilman Schmidt73a88812006-04-22 02:35:30 -07001426 if (unlikely(rc != 0 && rc != -ENODEV)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001427 dev_err(cs->dev,
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001428 "could not resubmit isoc read URB: %s\n",
Tilman Schmidt73a88812006-04-22 02:35:30 -07001429 get_usb_rcmsg(rc));
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001430 dump_urb(DEBUG_ISO, "resubmit isoc read", urb);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001431 error_hangup(bcs);
1432 }
1433 }
1434}
1435
1436/* Channel Operations */
1437/* ================== */
1438
1439/* req_timeout
1440 * timeout routine for control output request
1441 * argument:
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001442 * controller state structure
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001443 */
1444static void req_timeout(unsigned long data)
1445{
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001446 struct cardstate *cs = (struct cardstate *) data;
1447 struct bas_cardstate *ucs = cs->hw.bas;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001448 int pending;
1449 unsigned long flags;
1450
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001451 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 */
Tilman Schmidt784d5852006-04-10 22:55:04 -07001460 gig_dbg(DEBUG_USBREQ, "%s: no request pending", __func__);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001461 break;
1462
1463 case HD_OPEN_ATCHANNEL:
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001464 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]);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001471 break;
1472
1473 case HD_OPEN_B2CHANNEL:
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001474 dev_err(cs->dev, "timeout opening channel 2\n");
1475 error_hangup(&cs->bcs[1]);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001476 break;
1477
1478 case HD_CLOSE_ATCHANNEL:
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001479 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);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001486 break;
1487
1488 case HD_CLOSE_B2CHANNEL:
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001489 dev_err(cs->dev, "timeout closing channel 2\n");
1490 error_reset(cs);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001491 break;
1492
Tilman Schmidtb5f581d2009-10-06 12:18:51 +00001493 case HD_RESET_INTERRUPT_PIPE:
1494 /* error recovery escalation */
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001495 dev_err(cs->dev,
Tilman Schmidtb5f581d2009-10-06 12:18:51 +00001496 "reset interrupt pipe timeout, attempting USB reset\n");
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001497 usb_queue_reset_device(ucs->interface);
Tilman Schmidtb5f581d2009-10-06 12:18:51 +00001498 break;
1499
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001500 default:
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001501 dev_warn(cs->dev, "request 0x%02x timed out, clearing\n",
Tilman Schmidt784d5852006-04-10 22:55:04 -07001502 pending);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001503 }
Tilman Schmidt024fd292008-02-06 01:38:26 -08001504
1505 wake_up(&ucs->waitqueue);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001506}
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 */
David Howells7d12e782006-10-05 14:55:46 +01001515static void write_ctrl_callback(struct urb *urb)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001516{
Tilman Schmidtd48c7782006-04-10 22:55:08 -07001517 struct bas_cardstate *ucs = urb->context;
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001518 int status = urb->status;
Tilman Schmidt06163f862006-06-26 00:25:33 -07001519 int rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001520 unsigned long flags;
1521
Tilman Schmidt06163f862006-06-26 00:25:33 -07001522 /* check status */
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001523 switch (status) {
Tilman Schmidt06163f862006-06-26 00:25:33 -07001524 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",
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001542 __func__, get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001543 break;
Tilman Schmidt06163f862006-06-26 00:25:33 -07001544
1545 default: /* any failure */
Tilman Schmidt024fd292008-02-06 01:38:26 -08001546 /* don't retry if suspend requested */
1547 if (++ucs->retry_ctrl > BAS_RETRY ||
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001548 (ucs->basstate & BS_SUSPEND)) {
Tilman Schmidt06163f862006-06-26 00:25:33 -07001549 dev_err(&ucs->interface->dev,
1550 "control request 0x%02x failed: %s\n",
1551 ucs->dr_ctrl.bRequest,
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001552 get_usb_statmsg(status));
Tilman Schmidt06163f862006-06-26 00:25:33 -07001553 break; /* give up */
1554 }
1555 dev_notice(&ucs->interface->dev,
1556 "control request 0x%02x: %s, retry %d\n",
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001557 ucs->dr_ctrl.bRequest, get_usb_statmsg(status),
Tilman Schmidt06163f862006-06-26 00:25:33 -07001558 ucs->retry_ctrl);
1559 /* urb->dev is clobbered by USB subsystem */
1560 urb->dev = ucs->udev;
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001561 rc = usb_submit_urb(urb, GFP_ATOMIC);
Tilman Schmidt06163f862006-06-26 00:25:33 -07001562 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;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001570 }
Tilman Schmidt06163f862006-06-26 00:25:33 -07001571
1572 /* failed, clear pending request */
1573 spin_lock_irqsave(&ucs->lock, flags);
1574 del_timer(&ucs->timer_ctrl);
1575 ucs->pending = 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001576 spin_unlock_irqrestore(&ucs->lock, flags);
Tilman Schmidt024fd292008-02-06 01:38:26 -08001577 wake_up(&ucs->waitqueue);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001578}
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
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001590 * -EBUSY if another request is pending
1591 * any URB submission error code
1592 */
1593static int req_submit(struct bc_state *bcs, int req, int val, int timeout)
1594{
Tilman Schmidtd48c7782006-04-10 22:55:08 -07001595 struct bas_cardstate *ucs = bcs->cs->hw.bas;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001596 int ret;
1597 unsigned long flags;
1598
Tilman Schmidt784d5852006-04-10 22:55:04 -07001599 gig_dbg(DEBUG_USBREQ, "-------> 0x%02x (%d)", req, val);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001600
1601 spin_lock_irqsave(&ucs->lock, flags);
1602 if (ucs->pending) {
1603 spin_unlock_irqrestore(&ucs->lock, flags);
Tilman Schmidt784d5852006-04-10 22:55:04 -07001604 dev_err(bcs->cs->dev,
1605 "submission of request 0x%02x failed: "
1606 "request 0x%02x still pending\n",
1607 req, ucs->pending);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001608 return -EBUSY;
1609 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001610
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,
Tilman Schmidt784d5852006-04-10 22:55:04 -07001617 usb_sndctrlpipe(ucs->udev, 0),
Tilman Schmidt7891adf2009-10-25 09:30:37 +00001618 (unsigned char *) &ucs->dr_ctrl, NULL, 0,
Tilman Schmidt784d5852006-04-10 22:55:04 -07001619 write_ctrl_callback, ucs);
Tilman Schmidt06163f862006-06-26 00:25:33 -07001620 ucs->retry_ctrl = 0;
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001621 ret = usb_submit_urb(ucs->urb_ctrl, GFP_ATOMIC);
Tilman Schmidt06163f862006-06-26 00:25:33 -07001622 if (unlikely(ret)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001623 dev_err(bcs->cs->dev, "could not submit request 0x%02x: %s\n",
Tilman Schmidt06163f862006-06-26 00:25:33 -07001624 req, get_usb_rcmsg(ret));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001625 spin_unlock_irqrestore(&ucs->lock, flags);
1626 return ret;
1627 }
1628 ucs->pending = req;
1629
1630 if (timeout > 0) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001631 gig_dbg(DEBUG_USBREQ, "setting timeout of %d/10 secs", timeout);
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001632 mod_timer(&ucs->timer_ctrl, jiffies + timeout * HZ / 10);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001633 }
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 */
1647static int gigaset_init_bchannel(struct bc_state *bcs)
1648{
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001649 struct cardstate *cs = bcs->cs;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001650 int req, ret;
Tilman Schmidt73a88812006-04-22 02:35:30 -07001651 unsigned long flags;
1652
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001653 spin_lock_irqsave(&cs->lock, flags);
1654 if (unlikely(!cs->connected)) {
Tilman Schmidt73a88812006-04-22 02:35:30 -07001655 gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__);
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001656 spin_unlock_irqrestore(&cs->lock, flags);
Tilman Schmidt73a88812006-04-22 02:35:30 -07001657 return -ENODEV;
1658 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001659
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001660 if (cs->hw.bas->basstate & BS_SUSPEND) {
Tilman Schmidt024fd292008-02-06 01:38:26 -08001661 dev_notice(cs->dev,
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001662 "not starting isoc I/O, suspend in progress\n");
Tilman Schmidt024fd292008-02-06 01:38:26 -08001663 spin_unlock_irqrestore(&cs->lock, flags);
1664 return -EHOSTUNREACH;
1665 }
1666
Tilman Schmidt7891adf2009-10-25 09:30:37 +00001667 ret = starturbs(bcs);
1668 if (ret < 0) {
Tilman Schmidtb33ffa52010-09-30 13:34:30 +00001669 spin_unlock_irqrestore(&cs->lock, flags);
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001670 dev_err(cs->dev,
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00001671 "could not start isoc I/O for channel B%d: %s\n",
Tilman Schmidt73a88812006-04-22 02:35:30 -07001672 bcs->channel + 1,
1673 ret == -EFAULT ? "null URB" : get_usb_rcmsg(ret));
1674 if (ret != -ENODEV)
1675 error_hangup(bcs);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001676 return ret;
1677 }
1678
1679 req = bcs->channel ? HD_OPEN_B2CHANNEL : HD_OPEN_B1CHANNEL;
Tilman Schmidt7891adf2009-10-25 09:30:37 +00001680 ret = req_submit(bcs, req, 0, BAS_TIMEOUT);
1681 if (ret < 0) {
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001682 dev_err(cs->dev, "could not open channel B%d\n",
Tilman Schmidt73a88812006-04-22 02:35:30 -07001683 bcs->channel + 1);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001684 stopurbs(bcs->hw.bas);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001685 }
Tilman Schmidt73a88812006-04-22 02:35:30 -07001686
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001687 spin_unlock_irqrestore(&cs->lock, flags);
Tilman Schmidtb33ffa52010-09-30 13:34:30 +00001688 if (ret < 0 && ret != -ENODEV)
1689 error_hangup(bcs);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001690 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 */
1703static int gigaset_close_bchannel(struct bc_state *bcs)
1704{
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001705 struct cardstate *cs = bcs->cs;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001706 int req, ret;
Tilman Schmidt73a88812006-04-22 02:35:30 -07001707 unsigned long flags;
1708
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001709 spin_lock_irqsave(&cs->lock, flags);
1710 if (unlikely(!cs->connected)) {
1711 spin_unlock_irqrestore(&cs->lock, flags);
Tilman Schmidt73a88812006-04-22 02:35:30 -07001712 gig_dbg(DEBUG_USBREQ, "%s: not connected", __func__);
1713 return -ENODEV;
1714 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001715
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001716 if (!(cs->hw.bas->basstate & (bcs->channel ? BS_B2OPEN : BS_B1OPEN))) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001717 /* channel not running: just signal common.c */
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001718 spin_unlock_irqrestore(&cs->lock, flags);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001719 gigaset_bchannel_down(bcs);
1720 return 0;
1721 }
1722
Tilman Schmidt73a88812006-04-22 02:35:30 -07001723 /* channel running: tell device to close it */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001724 req = bcs->channel ? HD_CLOSE_B2CHANNEL : HD_CLOSE_B1CHANNEL;
Tilman Schmidt7891adf2009-10-25 09:30:37 +00001725 ret = req_submit(bcs, req, 0, BAS_TIMEOUT);
1726 if (ret < 0)
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001727 dev_err(cs->dev, "closing channel B%d failed\n",
Tilman Schmidt73a88812006-04-22 02:35:30 -07001728 bcs->channel + 1);
1729
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08001730 spin_unlock_irqrestore(&cs->lock, flags);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001731 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 */
1743static void complete_cb(struct cardstate *cs)
1744{
Tilman Schmidtd48c7782006-04-10 22:55:08 -07001745 struct cmdbuf_t *cb = cs->cmdbuf;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001746
1747 /* unqueue completed buffer */
1748 cs->cmdbytes -= cs->curlen;
Tilman Schmidt1528b182010-02-22 13:09:52 +00001749 gig_dbg(DEBUG_OUTPUT, "write_command: sent %u bytes, %u left",
Tilman Schmidt784d5852006-04-10 22:55:04 -07001750 cs->curlen, cs->cmdbytes);
Tilman Schmidt7891adf2009-10-25 09:30:37 +00001751 if (cb->next != NULL) {
1752 cs->cmdbuf = cb->next;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001753 cs->cmdbuf->prev = NULL;
1754 cs->curlen = cs->cmdbuf->len;
1755 } else {
Tilman Schmidt7891adf2009-10-25 09:30:37 +00001756 cs->cmdbuf = NULL;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001757 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
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001767/* 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 */
David Howells7d12e782006-10-05 14:55:46 +01001774static void write_command_callback(struct urb *urb)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001775{
Tilman Schmidtd48c7782006-04-10 22:55:08 -07001776 struct cardstate *cs = urb->context;
1777 struct bas_cardstate *ucs = cs->hw.bas;
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001778 int status = urb->status;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001779 unsigned long flags;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001780
Tilman Schmidt73a88812006-04-22 02:35:30 -07001781 update_basstate(ucs, 0, BS_ATWRPEND);
Tilman Schmidt024fd292008-02-06 01:38:26 -08001782 wake_up(&ucs->waitqueue);
Tilman Schmidt73a88812006-04-22 02:35:30 -07001783
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001784 /* check status */
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001785 switch (status) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001786 case 0: /* normal completion */
1787 break;
Tilman Schmidt73a88812006-04-22 02:35:30 -07001788 case -ENOENT: /* cancelled */
1789 case -ECONNRESET: /* cancelled (async) */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001790 case -EINPROGRESS: /* pending */
Tilman Schmidt73a88812006-04-22 02:35:30 -07001791 case -ENODEV: /* device removed */
1792 case -ESHUTDOWN: /* device shut down */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001793 /* ignore silently */
Tilman Schmidt784d5852006-04-10 22:55:04 -07001794 gig_dbg(DEBUG_USBREQ, "%s: %s",
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001795 __func__, get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001796 return;
1797 default: /* any failure */
1798 if (++ucs->retry_cmd_out > BAS_RETRY) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001799 dev_warn(cs->dev,
1800 "command write: %s, "
1801 "giving up after %d retries\n",
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001802 get_usb_statmsg(status),
Tilman Schmidt784d5852006-04-10 22:55:04 -07001803 ucs->retry_cmd_out);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001804 break;
1805 }
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001806 if (ucs->basstate & BS_SUSPEND) {
Tilman Schmidt024fd292008-02-06 01:38:26 -08001807 dev_warn(cs->dev,
1808 "command write: %s, "
1809 "won't retry - suspend requested\n",
1810 get_usb_statmsg(status));
1811 break;
1812 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001813 if (cs->cmdbuf == NULL) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001814 dev_warn(cs->dev,
1815 "command write: %s, "
1816 "cannot retry - cmdbuf gone\n",
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001817 get_usb_statmsg(status));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001818 break;
1819 }
Tilman Schmidt784d5852006-04-10 22:55:04 -07001820 dev_notice(cs->dev, "command write: %s, retry %d\n",
Tilman Schmidtdbd98232008-02-06 01:38:23 -08001821 get_usb_statmsg(status), ucs->retry_cmd_out);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001822 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 */
1840static void atrdy_timeout(unsigned long data)
1841{
1842 struct cardstate *cs = (struct cardstate *) data;
Tilman Schmidtd48c7782006-04-10 22:55:08 -07001843 struct bas_cardstate *ucs = cs->hw.bas;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001844
Tilman Schmidt784d5852006-04-10 22:55:04 -07001845 dev_warn(cs->dev, "timeout waiting for HD_READY_SEND_ATDATA\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001846
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
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001860 * -EBUSY if another request is pending
1861 * any URB submission error code
1862 */
1863static int atwrite_submit(struct cardstate *cs, unsigned char *buf, int len)
1864{
Tilman Schmidtd48c7782006-04-10 22:55:08 -07001865 struct bas_cardstate *ucs = cs->hw.bas;
Tilman Schmidt73a88812006-04-22 02:35:30 -07001866 int rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001867
Tilman Schmidt784d5852006-04-10 22:55:04 -07001868 gig_dbg(DEBUG_USBREQ, "-------> HD_WRITE_ATMESSAGE (%d)", len);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001869
Tilman Schmidt73a88812006-04-22 02:35:30 -07001870 if (update_basstate(ucs, BS_ATWRPEND, 0) & BS_ATWRPEND) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001871 dev_err(cs->dev,
1872 "could not submit HD_WRITE_ATMESSAGE: URB busy\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001873 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),
Tilman Schmidt7891adf2009-10-25 09:30:37 +00001883 (unsigned char *) &ucs->dr_cmd_out, buf, len,
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001884 write_command_callback, cs);
Christoph Lameter54e6ecb2006-12-06 20:33:16 -08001885 rc = usb_submit_urb(ucs->urb_cmd_out, GFP_ATOMIC);
Tilman Schmidt73a88812006-04-22 02:35:30 -07001886 if (unlikely(rc)) {
1887 update_basstate(ucs, 0, BS_ATWRPEND);
Tilman Schmidt784d5852006-04-10 22:55:04 -07001888 dev_err(cs->dev, "could not submit HD_WRITE_ATMESSAGE: %s\n",
Tilman Schmidt73a88812006-04-22 02:35:30 -07001889 get_usb_rcmsg(rc));
1890 return rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001891 }
1892
Tilman Schmidt73a88812006-04-22 02:35:30 -07001893 /* submitted successfully, start timeout if necessary */
1894 if (!(update_basstate(ucs, BS_ATTIMER, BS_ATREADY) & BS_ATTIMER)) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07001895 gig_dbg(DEBUG_OUTPUT, "setting ATREADY timeout of %d/10 secs",
1896 ATRDY_TIMEOUT);
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00001897 mod_timer(&ucs->timer_atrdy, jiffies + ATRDY_TIMEOUT * HZ / 10);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001898 }
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 */
1910static int start_cbsend(struct cardstate *cs)
1911{
1912 struct cmdbuf_t *cb;
Tilman Schmidtd48c7782006-04-10 22:55:08 -07001913 struct bas_cardstate *ucs = cs->hw.bas;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001914 unsigned long flags;
1915 int rc;
1916 int retval = 0;
1917
Tilman Schmidt024fd292008-02-06 01:38:26 -08001918 /* check if suspend requested */
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001919 if (ucs->basstate & BS_SUSPEND) {
Tilman Schmidt1528b182010-02-22 13:09:52 +00001920 gig_dbg(DEBUG_OUTPUT, "suspending");
Tilman Schmidt024fd292008-02-06 01:38:26 -08001921 return -EHOSTUNREACH;
1922 }
1923
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001924 /* check if AT channel is open */
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001925 if (!(ucs->basstate & BS_ATOPEN)) {
Tilman Schmidt1528b182010-02-22 13:09:52 +00001926 gig_dbg(DEBUG_OUTPUT, "AT channel not open");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001927 rc = req_submit(cs->bcs, HD_OPEN_ATCHANNEL, 0, BAS_TIMEOUT);
1928 if (rc < 0) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001929 /* 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
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001941 while ((cb = cs->cmdbuf) != NULL && (ucs->basstate & BS_ATREADY)) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001942 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
Tilman Schmidte3628dd2010-07-05 14:18:43 +00001963 * cb command buffer structure
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001964 * return value:
1965 * number of bytes queued on success
1966 * error code < 0 on error
1967 */
Tilman Schmidte3628dd2010-07-05 14:18:43 +00001968static int gigaset_write_cmd(struct cardstate *cs, struct cmdbuf_t *cb)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001969{
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001970 unsigned long flags;
Tilman Schmidt39f07222006-12-13 00:33:52 -08001971 int rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001972
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08001973 gigaset_dbg_buffer(cs->mstate != MS_LOCKED ?
Joe Perches475be4d2012-02-19 19:52:38 -08001974 DEBUG_TRANSCMD : DEBUG_LOCKCMD,
Tilman Schmidte3628dd2010-07-05 14:18:43 +00001975 "CMD Transmit", cb->len, cb->buf);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08001976
Tilman Schmidtb5f581d2009-10-06 12:18:51 +00001977 /* 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 */
Tilman Schmidte3628dd2010-07-05 14:18:43 +00001981 if (cb->len == 3 && !memcmp(cb->buf, "+++", 3)) {
Tilman Schmidt4cb5e422010-09-30 13:35:31 +00001982 /* 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
Tilman Schmidtb5f581d2009-10-06 12:18:51 +00002004 rc = req_submit(cs->bcs, HD_CLOSE_ATCHANNEL, 0, BAS_TIMEOUT);
Tilman Schmidte3628dd2010-07-05 14:18:43 +00002005 if (cb->wake_tasklet)
2006 tasklet_schedule(cb->wake_tasklet);
Dan Carpenter8bcfbd02010-08-05 22:21:26 +00002007 if (!rc)
2008 rc = cb->len;
2009 kfree(cb);
2010 return rc;
Tilman Schmidtb5f581d2009-10-06 12:18:51 +00002011 }
2012
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002013 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;
Tilman Schmidte3628dd2010-07-05 14:18:43 +00002019 cs->curlen = cb->len;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002020 }
Tilman Schmidte3628dd2010-07-05 14:18:43 +00002021 cs->cmdbytes += cb->len;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002022 cs->lastcmdbuf = cb;
2023 spin_unlock_irqrestore(&cs->cmdlock, flags);
2024
Tilman Schmidt73a88812006-04-22 02:35:30 -07002025 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__);
Tilman Schmidt39f07222006-12-13 00:33:52 -08002029 /* 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);
Tilman Schmidt73a88812006-04-22 02:35:30 -07002034 return -ENODEV;
2035 }
Tilman Schmidt39f07222006-12-13 00:33:52 -08002036 rc = start_cbsend(cs);
Tilman Schmidt73a88812006-04-22 02:35:30 -07002037 spin_unlock_irqrestore(&cs->lock, flags);
Tilman Schmidte3628dd2010-07-05 14:18:43 +00002038 return rc < 0 ? rc : cb->len;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002039}
2040
2041/* gigaset_write_room
2042 * tty_driver.write_room interface routine
Tilman Schmidt917f5082006-04-10 22:55:00 -07002043 * return number of characters the driver will accept to be written via
2044 * gigaset_write_cmd
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002045 * parameter:
2046 * controller state structure
2047 * return value:
2048 * number of characters
2049 */
2050static 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 */
2063static int gigaset_chars_in_buffer(struct cardstate *cs)
2064{
Tilman Schmidt4d1ff582007-10-16 01:27:50 -07002065 return cs->cmdbytes;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002066}
2067
2068/* gigaset_brkchars
2069 * implementation of ioctl(GIGASET_BRKCHARS)
2070 * parameter:
2071 * controller state structure
2072 * return value:
2073 * -EINVAL (unimplemented function)
2074 */
2075static 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
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002087 */
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002088static void gigaset_freebcshw(struct bc_state *bcs)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002089{
Tilman Schmidt73a88812006-04-22 02:35:30 -07002090 struct bas_bc_state *ubc = bcs->hw.bas;
2091 int i;
2092
2093 if (!ubc)
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002094 return;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002095
Tilman Schmidt73a88812006-04-22 02:35:30 -07002096 /* kill URBs and tasklets before freeing - better safe than sorry */
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002097 ubc->running = 0;
Tilman Schmidtbb7196d2010-09-30 13:35:52 +00002098 gig_dbg(DEBUG_INIT, "%s: killing isoc URBs", __func__);
Tilman Schmidt39f07222006-12-13 00:33:52 -08002099 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 }
Tilman Schmidt73a88812006-04-22 02:35:30 -07002107 tasklet_kill(&ubc->sent_tasklet);
2108 tasklet_kill(&ubc->rcvd_tasklet);
2109 kfree(ubc->isooutbuf);
2110 kfree(ubc);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002111 bcs->hw.bas = NULL;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002112}
2113
2114/* Initialize hardware dependent part of the B channel structure
2115 * parameter:
2116 * bcs B channel structure
2117 * return value:
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002118 * 0 on success, error code < 0 on failure
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002119 */
2120static 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) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -08002127 pr_err("out of memory\n");
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002128 return -ENOMEM;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002129 }
2130
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002131 ubc->running = 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002132 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;
Tilman Schmidt7891adf2009-10-25 09:30:37 +00002140 ubc->isooutbuf = kmalloc(sizeof(struct isowbuf_t), GFP_KERNEL);
2141 if (!ubc->isooutbuf) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -08002142 pr_err("out of memory\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002143 kfree(ubc);
2144 bcs->hw.bas = NULL;
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002145 return -ENOMEM;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002146 }
2147 tasklet_init(&ubc->sent_tasklet,
Joe Perches5452fee2009-11-19 09:55:53 +00002148 write_iso_tasklet, (unsigned long) bcs);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002149
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,
Joe Perches5452fee2009-11-19 09:55:53 +00002169 read_iso_tasklet, (unsigned long) bcs);
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002170 return 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002171}
2172
2173static void gigaset_reinitbcshw(struct bc_state *bcs)
2174{
2175 struct bas_bc_state *ubc = bcs->hw.bas;
2176
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002177 bcs->hw.bas->running = 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002178 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
2185static void gigaset_freecshw(struct cardstate *cs)
2186{
Tilman Schmidt73a88812006-04-22 02:35:30 -07002187 /* timers, URBs and rcvbuf are disposed of in disconnect */
Tilman Schmidt170ebf82009-03-18 23:44:23 -07002188 kfree(cs->hw.bas->int_in_buf);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002189 kfree(cs->hw.bas);
Tilman Schmidt73a88812006-04-22 02:35:30 -07002190 cs->hw.bas = NULL;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002191}
2192
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002193/* 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 */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002199static int gigaset_initcshw(struct cardstate *cs)
2200{
2201 struct bas_cardstate *ucs;
2202
2203 cs->hw.bas = ucs = kmalloc(sizeof *ucs, GFP_KERNEL);
Tilman Schmidtc8770dc2008-12-26 01:21:29 -08002204 if (!ucs) {
2205 pr_err("out of memory\n");
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002206 return -ENOMEM;
Tilman Schmidtc8770dc2008-12-26 01:21:29 -08002207 }
Tilman Schmidt170ebf82009-03-18 23:44:23 -07002208 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");
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002212 return -ENOMEM;
Tilman Schmidt170ebf82009-03-18 23:44:23 -07002213 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002214
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
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002223 ucs->basstate = 0;
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00002224 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);
Tilman Schmidtc9c0c302010-09-30 13:35:42 +00002227 setup_timer(&ucs->timer_int_in, int_in_resubmit, (unsigned long) cs);
Tilman Schmidt024fd292008-02-06 01:38:26 -08002228 init_waitqueue_head(&ucs->waitqueue);
Tilman Schmidtc9c0c302010-09-30 13:35:42 +00002229 INIT_WORK(&ucs->int_in_wq, int_in_work);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002230
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002231 return 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002232}
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 */
2240static void freeurbs(struct cardstate *cs)
2241{
Tilman Schmidtd48c7782006-04-10 22:55:08 -07002242 struct bas_cardstate *ucs = cs->hw.bas;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002243 struct bas_bc_state *ubc;
2244 int i, j;
2245
Tilman Schmidt39f07222006-12-13 00:33:52 -08002246 gig_dbg(DEBUG_INIT, "%s: killing URBs", __func__);
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08002247 for (j = 0; j < BAS_CHANNELS; ++j) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002248 ubc = cs->bcs[j].hw.bas;
Tilman Schmidt39f07222006-12-13 00:33:52 -08002249 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 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002259 }
Tilman Schmidt39f07222006-12-13 00:33:52 -08002260 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;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002272}
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 */
2278static 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;
Tilman Schmidt73a88812006-04-22 02:35:30 -07002288 int rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002289
Tilman Schmidt1528b182010-02-22 13:09:52 +00002290 gig_dbg(DEBUG_INIT,
Tilman Schmidt784d5852006-04-10 22:55:04 -07002291 "%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));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002294
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002295 /* set required alternate setting */
2296 hostif = interface->cur_altsetting;
2297 if (hostif->desc.bAlternateSetting != 3) {
Tilman Schmidt1528b182010-02-22 13:09:52 +00002298 gig_dbg(DEBUG_INIT,
Tilman Schmidt784d5852006-04-10 22:55:04 -07002299 "%s: wrong alternate setting %d - trying to switch",
2300 __func__, hostif->desc.bAlternateSetting);
Tilman Schmidt7891adf2009-10-25 09:30:37 +00002301 if (usb_set_interface(udev, hostif->desc.bInterfaceNumber, 3)
2302 < 0) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07002303 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);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002307 return -ENODEV;
2308 }
2309 hostif = interface->cur_altsetting;
2310 }
2311
2312 /* Reject application specific interfaces
2313 */
2314 if (hostif->desc.bInterfaceClass != 255) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07002315 dev_warn(&udev->dev, "%s: bInterfaceClass == %d\n",
2316 __func__, hostif->desc.bInterfaceClass);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002317 return -ENODEV;
2318 }
2319
Tilman Schmidt784d5852006-04-10 22:55:04 -07002320 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));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002324
Uwe Kleine-Königb5950762010-11-01 15:38:34 -04002325 /* allocate memory for our device state and initialize it */
Tilman Schmidte468c042008-02-06 01:38:29 -08002326 cs = gigaset_initcs(driver, BAS_CHANNELS, 0, 0, cidmode,
2327 GIGASET_MODULENAME);
2328 if (!cs)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002329 return -ENODEV;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002330 ucs = cs->hw.bas;
Tilman Schmidt784d5852006-04-10 22:55:04 -07002331
2332 /* save off device structure ptrs for later use */
2333 usb_get_dev(udev);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002334 ucs->udev = udev;
2335 ucs->interface = interface;
Tilman Schmidtb1d47462006-04-10 22:55:07 -07002336 cs->dev = &interface->dev;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002337
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 */
Christoph Lametere94b1762006-12-06 20:33:17 -08002343 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)))
Tilman Schmidt73a88812006-04-22 02:35:30 -07002347 goto allocerr;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002348
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08002349 for (j = 0; j < BAS_CHANNELS; ++j) {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002350 ubc = cs->bcs[j].hw.bas;
Tilman Schmidt73a88812006-04-22 02:35:30 -07002351 for (i = 0; i < BAS_OUTURBS; ++i)
2352 if (!(ubc->isoouturbs[i].urb =
Christoph Lametere94b1762006-12-06 20:33:17 -08002353 usb_alloc_urb(BAS_NUMFRAMES, GFP_KERNEL)))
Tilman Schmidt73a88812006-04-22 02:35:30 -07002354 goto allocerr;
2355 for (i = 0; i < BAS_INURBS; ++i)
2356 if (!(ubc->isoinurbs[i] =
Christoph Lametere94b1762006-12-06 20:33:17 -08002357 usb_alloc_urb(BAS_NUMFRAMES, GFP_KERNEL)))
Tilman Schmidt73a88812006-04-22 02:35:30 -07002358 goto allocerr;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002359 }
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,
Tilman Schmidt784d5852006-04-10 22:55:04 -07002367 usb_rcvintpipe(udev,
2368 (endpoint->bEndpointAddress) & 0x0f),
Tilman Schmidt170ebf82009-03-18 23:44:23 -07002369 ucs->int_in_buf, IP_MSGSIZE, read_int_callback, cs,
Tilman Schmidt784d5852006-04-10 22:55:04 -07002370 endpoint->bInterval);
Tilman Schmidt7891adf2009-10-25 09:30:37 +00002371 rc = usb_submit_urb(ucs->urb_int_in, GFP_KERNEL);
2372 if (rc != 0) {
Tilman Schmidt784d5852006-04-10 22:55:04 -07002373 dev_err(cs->dev, "could not submit interrupt URB: %s\n",
Tilman Schmidt73a88812006-04-22 02:35:30 -07002374 get_usb_rcmsg(rc));
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002375 goto error;
2376 }
Tilman Schmidtc9c0c302010-09-30 13:35:42 +00002377 ucs->retry_int_in = 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002378
2379 /* tell the device that the driver is ready */
Tilman Schmidt7891adf2009-10-25 09:30:37 +00002380 rc = req_submit(cs->bcs, HD_DEVICE_INIT_ACK, 0, 0);
2381 if (rc != 0)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002382 goto error;
2383
2384 /* tell common part that the device is ready */
2385 if (startmode == SM_LOCKED)
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002386 cs->mstate = MS_LOCKED;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002387
2388 /* save address of controller structure */
2389 usb_set_intfdata(interface, cs);
2390
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002391 rc = gigaset_start(cs);
2392 if (rc < 0)
Tilman Schmidtb1d47462006-04-10 22:55:07 -07002393 goto error;
2394
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002395 return 0;
2396
Tilman Schmidt73a88812006-04-22 02:35:30 -07002397allocerr:
2398 dev_err(cs->dev, "could not allocate URBs\n");
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002399 rc = -ENOMEM;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002400error:
2401 freeurbs(cs);
Tilman Schmidt69049cc2006-04-10 22:55:16 -07002402 usb_set_intfdata(interface, NULL);
Tilman Schmidte468c042008-02-06 01:38:29 -08002403 gigaset_freecs(cs);
Tilman Schmidt81fa7b82012-04-25 13:02:20 +00002404 return rc;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002405}
2406
2407/* gigaset_disconnect
2408 * This function is called when the Gigaset base is unplugged.
2409 */
2410static void gigaset_disconnect(struct usb_interface *interface)
2411{
2412 struct cardstate *cs;
2413 struct bas_cardstate *ucs;
Tilman Schmidt73a88812006-04-22 02:35:30 -07002414 int j;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002415
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002416 cs = usb_get_intfdata(interface);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002417
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002418 ucs = cs->hw.bas;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002419
Tilman Schmidtb1d47462006-04-10 22:55:07 -07002420 dev_info(cs->dev, "disconnecting Gigaset base\n");
Tilman Schmidt73a88812006-04-22 02:35:30 -07002421
2422 /* mark base as not ready, all channels disconnected */
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002423 ucs->basstate = 0;
Tilman Schmidt73a88812006-04-22 02:35:30 -07002424
2425 /* tell LL all channels are down */
Tilman Schmidtc652cbd2008-02-06 01:38:24 -08002426 for (j = 0; j < BAS_CHANNELS; ++j)
Tilman Schmidt73a88812006-04-22 02:35:30 -07002427 gigaset_bchannel_down(cs->bcs + j);
2428
2429 /* stop driver (common part) */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002430 gigaset_stop(cs);
Tilman Schmidt73a88812006-04-22 02:35:30 -07002431
Tilman Schmidtc9c0c302010-09-30 13:35:42 +00002432 /* stop delayed work and URBs, free ressources */
Tilman Schmidt73a88812006-04-22 02:35:30 -07002433 del_timer_sync(&ucs->timer_ctrl);
2434 del_timer_sync(&ucs->timer_atrdy);
2435 del_timer_sync(&ucs->timer_cmd_in);
Tilman Schmidtc9c0c302010-09-30 13:35:42 +00002436 del_timer_sync(&ucs->timer_int_in);
2437 cancel_work_sync(&ucs->int_in_wq);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002438 freeurbs(cs);
Tilman Schmidtb1d47462006-04-10 22:55:07 -07002439 usb_set_intfdata(interface, NULL);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002440 kfree(ucs->rcvbuf);
2441 ucs->rcvbuf = NULL;
2442 ucs->rcvbuf_size = 0;
Tilman Schmidtb1d47462006-04-10 22:55:07 -07002443 usb_put_dev(ucs->udev);
2444 ucs->interface = NULL;
2445 ucs->udev = NULL;
2446 cs->dev = NULL;
Tilman Schmidte468c042008-02-06 01:38:29 -08002447 gigaset_freecs(cs);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002448}
2449
Tilman Schmidt024fd292008-02-06 01:38:26 -08002450/* gigaset_suspend
Tilman Schmidtc6fdd8e2012-10-24 08:44:32 +00002451 * This function is called before the USB connection is suspended
2452 * or before the USB device is reset.
2453 * In the latter case, message == PMSG_ON.
Tilman Schmidt024fd292008-02-06 01:38:26 -08002454 */
2455static int gigaset_suspend(struct usb_interface *intf, pm_message_t message)
2456{
2457 struct cardstate *cs = usb_get_intfdata(intf);
2458 struct bas_cardstate *ucs = cs->hw.bas;
Tilman Schmidt024fd292008-02-06 01:38:26 -08002459 int rc;
2460
2461 /* set suspend flag; this stops AT command/response traffic */
2462 if (update_basstate(ucs, BS_SUSPEND, 0) & BS_SUSPEND) {
2463 gig_dbg(DEBUG_SUSPEND, "already suspended");
2464 return 0;
2465 }
2466
2467 /* wait a bit for blocking conditions to go away */
2468 rc = wait_event_timeout(ucs->waitqueue,
Joe Perches475be4d2012-02-19 19:52:38 -08002469 !(ucs->basstate &
2470 (BS_B1OPEN | BS_B2OPEN | BS_ATRDPEND | BS_ATWRPEND)),
2471 BAS_TIMEOUT * HZ / 10);
Tilman Schmidt024fd292008-02-06 01:38:26 -08002472 gig_dbg(DEBUG_SUSPEND, "wait_event_timeout() -> %d", rc);
2473
2474 /* check for conditions preventing suspend */
Joe Perches475be4d2012-02-19 19:52:38 -08002475 if (ucs->basstate & (BS_B1OPEN | BS_B2OPEN | BS_ATRDPEND | BS_ATWRPEND)) {
Tilman Schmidt024fd292008-02-06 01:38:26 -08002476 dev_warn(cs->dev, "cannot suspend:\n");
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002477 if (ucs->basstate & BS_B1OPEN)
Tilman Schmidt024fd292008-02-06 01:38:26 -08002478 dev_warn(cs->dev, " B channel 1 open\n");
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002479 if (ucs->basstate & BS_B2OPEN)
Tilman Schmidt024fd292008-02-06 01:38:26 -08002480 dev_warn(cs->dev, " B channel 2 open\n");
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002481 if (ucs->basstate & BS_ATRDPEND)
Tilman Schmidt024fd292008-02-06 01:38:26 -08002482 dev_warn(cs->dev, " receiving AT reply\n");
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002483 if (ucs->basstate & BS_ATWRPEND)
Tilman Schmidt024fd292008-02-06 01:38:26 -08002484 dev_warn(cs->dev, " sending AT command\n");
2485 update_basstate(ucs, 0, BS_SUSPEND);
2486 return -EBUSY;
2487 }
2488
2489 /* close AT channel if open */
Tilman Schmidt9d4bee22008-02-06 01:38:28 -08002490 if (ucs->basstate & BS_ATOPEN) {
Tilman Schmidt024fd292008-02-06 01:38:26 -08002491 gig_dbg(DEBUG_SUSPEND, "closing AT channel");
2492 rc = req_submit(cs->bcs, HD_CLOSE_ATCHANNEL, 0, 0);
2493 if (rc) {
2494 update_basstate(ucs, 0, BS_SUSPEND);
2495 return rc;
2496 }
2497 wait_event_timeout(ucs->waitqueue, !ucs->pending,
Joe Perches475be4d2012-02-19 19:52:38 -08002498 BAS_TIMEOUT * HZ / 10);
Tilman Schmidt024fd292008-02-06 01:38:26 -08002499 /* in case of timeout, proceed anyway */
2500 }
2501
Tilman Schmidtc9c0c302010-09-30 13:35:42 +00002502 /* kill all URBs and delayed work that might still be pending */
Tilman Schmidt024fd292008-02-06 01:38:26 -08002503 usb_kill_urb(ucs->urb_ctrl);
2504 usb_kill_urb(ucs->urb_int_in);
2505 del_timer_sync(&ucs->timer_ctrl);
Tilman Schmidt1d5a9ed2010-09-30 13:35:11 +00002506 del_timer_sync(&ucs->timer_atrdy);
2507 del_timer_sync(&ucs->timer_cmd_in);
Tilman Schmidtc9c0c302010-09-30 13:35:42 +00002508 del_timer_sync(&ucs->timer_int_in);
Tilman Schmidtc6fdd8e2012-10-24 08:44:32 +00002509
2510 /* don't try to cancel int_in_wq from within reset as it
2511 * might be the one requesting the reset
2512 */
2513 if (message.event != PM_EVENT_ON)
2514 cancel_work_sync(&ucs->int_in_wq);
Tilman Schmidt024fd292008-02-06 01:38:26 -08002515
2516 gig_dbg(DEBUG_SUSPEND, "suspend complete");
2517 return 0;
2518}
2519
2520/* gigaset_resume
2521 * This function is called after the USB connection has been resumed.
2522 */
2523static int gigaset_resume(struct usb_interface *intf)
2524{
2525 struct cardstate *cs = usb_get_intfdata(intf);
2526 struct bas_cardstate *ucs = cs->hw.bas;
2527 int rc;
2528
2529 /* resubmit interrupt URB for spontaneous messages from base */
2530 rc = usb_submit_urb(ucs->urb_int_in, GFP_KERNEL);
2531 if (rc) {
2532 dev_err(cs->dev, "could not resubmit interrupt URB: %s\n",
2533 get_usb_rcmsg(rc));
2534 return rc;
2535 }
Tilman Schmidtc9c0c302010-09-30 13:35:42 +00002536 ucs->retry_int_in = 0;
Tilman Schmidt024fd292008-02-06 01:38:26 -08002537
2538 /* clear suspend flag to reallow activity */
2539 update_basstate(ucs, 0, BS_SUSPEND);
2540
2541 gig_dbg(DEBUG_SUSPEND, "resume complete");
2542 return 0;
2543}
2544
2545/* gigaset_pre_reset
2546 * This function is called before the USB connection is reset.
2547 */
2548static int gigaset_pre_reset(struct usb_interface *intf)
2549{
2550 /* handle just like suspend */
2551 return gigaset_suspend(intf, PMSG_ON);
2552}
2553
2554/* gigaset_post_reset
2555 * This function is called after the USB connection has been reset.
2556 */
2557static int gigaset_post_reset(struct usb_interface *intf)
2558{
2559 /* FIXME: send HD_DEVICE_INIT_ACK? */
2560
2561 /* resume operations */
2562 return gigaset_resume(intf);
2563}
2564
2565
Tilman Schmidt35dc8452007-03-29 01:20:34 -07002566static const struct gigaset_ops gigops = {
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002567 gigaset_write_cmd,
2568 gigaset_write_room,
2569 gigaset_chars_in_buffer,
2570 gigaset_brkchars,
2571 gigaset_init_bchannel,
2572 gigaset_close_bchannel,
2573 gigaset_initbcshw,
2574 gigaset_freebcshw,
2575 gigaset_reinitbcshw,
2576 gigaset_initcshw,
2577 gigaset_freecshw,
2578 gigaset_set_modem_ctrl,
2579 gigaset_baud_rate,
2580 gigaset_set_line_ctrl,
2581 gigaset_isoc_send_skb,
2582 gigaset_isoc_input,
2583};
2584
2585/* bas_gigaset_init
2586 * This function is called after the kernel module is loaded.
2587 */
2588static int __init bas_gigaset_init(void)
2589{
2590 int result;
2591
Uwe Kleine-Königb5950762010-11-01 15:38:34 -04002592 /* allocate memory for our driver state and initialize it */
Tilman Schmidt7891adf2009-10-25 09:30:37 +00002593 driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
2594 GIGASET_MODULENAME, GIGASET_DEVNAME,
2595 &gigops, THIS_MODULE);
2596 if (driver == NULL)
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002597 goto error;
2598
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002599 /* register this driver with the USB subsystem */
2600 result = usb_register(&gigaset_usb_driver);
2601 if (result < 0) {
Tilman Schmidtc8770dc2008-12-26 01:21:29 -08002602 pr_err("error %d registering USB driver\n", -result);
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002603 goto error;
2604 }
2605
Tilman Schmidtc8770dc2008-12-26 01:21:29 -08002606 pr_info(DRIVER_DESC "\n");
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002607 return 0;
2608
Tilman Schmidte468c042008-02-06 01:38:29 -08002609error:
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002610 if (driver)
2611 gigaset_freedriver(driver);
2612 driver = NULL;
2613 return -1;
2614}
2615
2616/* bas_gigaset_exit
2617 * This function is called before the kernel module is unloaded.
2618 */
2619static void __exit bas_gigaset_exit(void)
2620{
Tilman Schmidte468c042008-02-06 01:38:29 -08002621 struct bas_cardstate *ucs;
2622 int i;
Tilman Schmidt73a88812006-04-22 02:35:30 -07002623
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002624 gigaset_blockdriver(driver); /* => probe will fail
Tilman Schmidt784d5852006-04-10 22:55:04 -07002625 * => no gigaset_start any more
2626 */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002627
Tilman Schmidte468c042008-02-06 01:38:29 -08002628 /* stop all connected devices */
2629 for (i = 0; i < driver->minors; i++) {
2630 if (gigaset_shutdown(driver->cs + i) < 0)
2631 continue; /* no device */
2632 /* from now on, no isdn callback should be possible */
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002633
Tilman Schmidte468c042008-02-06 01:38:29 -08002634 /* close all still open channels */
2635 ucs = driver->cs[i].hw.bas;
2636 if (ucs->basstate & BS_B1OPEN) {
2637 gig_dbg(DEBUG_INIT, "closing B1 channel");
2638 usb_control_msg(ucs->udev,
2639 usb_sndctrlpipe(ucs->udev, 0),
2640 HD_CLOSE_B1CHANNEL, OUT_VENDOR_REQ,
2641 0, 0, NULL, 0, BAS_TIMEOUT);
2642 }
2643 if (ucs->basstate & BS_B2OPEN) {
2644 gig_dbg(DEBUG_INIT, "closing B2 channel");
2645 usb_control_msg(ucs->udev,
2646 usb_sndctrlpipe(ucs->udev, 0),
2647 HD_CLOSE_B2CHANNEL, OUT_VENDOR_REQ,
2648 0, 0, NULL, 0, BAS_TIMEOUT);
2649 }
2650 if (ucs->basstate & BS_ATOPEN) {
2651 gig_dbg(DEBUG_INIT, "closing AT channel");
2652 usb_control_msg(ucs->udev,
2653 usb_sndctrlpipe(ucs->udev, 0),
2654 HD_CLOSE_ATCHANNEL, OUT_VENDOR_REQ,
2655 0, 0, NULL, 0, BAS_TIMEOUT);
2656 }
2657 ucs->basstate = 0;
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002658 }
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002659
2660 /* deregister this driver with the USB subsystem */
2661 usb_deregister(&gigaset_usb_driver);
2662 /* this will call the disconnect-callback */
2663 /* from now on, no disconnect/probe callback should be running */
2664
Hansjoerg Lippcf7776d2006-03-26 01:38:34 -08002665 gigaset_freedriver(driver);
2666 driver = NULL;
2667}
2668
2669
2670module_init(bas_gigaset_init);
2671module_exit(bas_gigaset_exit);
2672
2673MODULE_AUTHOR(DRIVER_AUTHOR);
2674MODULE_DESCRIPTION(DRIVER_DESC);
2675MODULE_LICENSE("GPL");