usb-gigaset.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973
  1. /*
  2. * USB driver for Gigaset 307x directly or using M105 Data.
  3. *
  4. * Copyright (c) 2001 by Stefan Eilers
  5. * and Hansjoerg Lipp <hjlipp@web.de>.
  6. *
  7. * This driver was derived from the USB skeleton driver by
  8. * Greg Kroah-Hartman <greg@kroah.com>
  9. *
  10. * =====================================================================
  11. * This program is free software; you can redistribute it and/or
  12. * modify it under the terms of the GNU General Public License as
  13. * published by the Free Software Foundation; either version 2 of
  14. * the License, or (at your option) any later version.
  15. * =====================================================================
  16. */
  17. #include "gigaset.h"
  18. #include <linux/errno.h>
  19. #include <linux/init.h>
  20. #include <linux/slab.h>
  21. #include <linux/usb.h>
  22. #include <linux/module.h>
  23. #include <linux/moduleparam.h>
  24. /* Version Information */
  25. #define DRIVER_AUTHOR "Hansjoerg Lipp <hjlipp@web.de>, Stefan Eilers"
  26. #define DRIVER_DESC "USB Driver for Gigaset 307x using M105"
  27. /* Module parameters */
  28. static int startmode = SM_ISDN;
  29. static int cidmode = 1;
  30. module_param(startmode, int, S_IRUGO);
  31. module_param(cidmode, int, S_IRUGO);
  32. MODULE_PARM_DESC(startmode, "start in isdn4linux mode");
  33. MODULE_PARM_DESC(cidmode, "Call-ID mode");
  34. #define GIGASET_MINORS 1
  35. #define GIGASET_MINOR 8
  36. #define GIGASET_MODULENAME "usb_gigaset"
  37. #define GIGASET_DEVNAME "ttyGU"
  38. #define IF_WRITEBUF 2000 /* arbitrary limit */
  39. /* Values for the Gigaset M105 Data */
  40. #define USB_M105_VENDOR_ID 0x0681
  41. #define USB_M105_PRODUCT_ID 0x0009
  42. /* table of devices that work with this driver */
  43. static const struct usb_device_id gigaset_table[] = {
  44. { USB_DEVICE(USB_M105_VENDOR_ID, USB_M105_PRODUCT_ID) },
  45. { } /* Terminating entry */
  46. };
  47. MODULE_DEVICE_TABLE(usb, gigaset_table);
  48. /*
  49. * Control requests (empty fields: 00)
  50. *
  51. * RT|RQ|VALUE|INDEX|LEN |DATA
  52. * In:
  53. * C1 08 01
  54. * Get flags (1 byte). Bits: 0=dtr,1=rts,3-7:?
  55. * C1 0F ll ll
  56. * Get device information/status (llll: 0x200 and 0x40 seen).
  57. * Real size: I only saw MIN(llll,0x64).
  58. * Contents: seems to be always the same...
  59. * offset 0x00: Length of this structure (0x64) (len: 1,2,3 bytes)
  60. * offset 0x3c: String (16 bit chars): "MCCI USB Serial V2.0"
  61. * rest: ?
  62. * Out:
  63. * 41 11
  64. * Initialize/reset device ?
  65. * 41 00 xx 00
  66. * ? (xx=00 or 01; 01 on start, 00 on close)
  67. * 41 07 vv mm
  68. * Set/clear flags vv=value, mm=mask (see RQ 08)
  69. * 41 12 xx
  70. * Used before the following configuration requests are issued
  71. * (with xx=0x0f). I've seen other values<0xf, though.
  72. * 41 01 xx xx
  73. * Set baud rate. xxxx=ceil(0x384000/rate)=trunc(0x383fff/rate)+1.
  74. * 41 03 ps bb
  75. * Set byte size and parity. p: 0x20=even,0x10=odd,0x00=no parity
  76. * [ 0x30: m, 0x40: s ]
  77. * [s: 0: 1 stop bit; 1: 1.5; 2: 2]
  78. * bb: bits/byte (seen 7 and 8)
  79. * 41 13 -- -- -- -- 10 00 ww 00 00 00 xx 00 00 00 yy 00 00 00 zz 00 00 00
  80. * ??
  81. * Initialization: 01, 40, 00, 00
  82. * Open device: 00 40, 00, 00
  83. * yy and zz seem to be equal, either 0x00 or 0x0a
  84. * (ww,xx) pairs seen: (00,00), (00,40), (01,40), (09,80), (19,80)
  85. * 41 19 -- -- -- -- 06 00 00 00 00 xx 11 13
  86. * Used after every "configuration sequence" (RQ 12, RQs 01/03/13).
  87. * xx is usually 0x00 but was 0x7e before starting data transfer
  88. * in unimodem mode. So, this might be an array of characters that
  89. * need special treatment ("commit all bufferd data"?), 11=^Q, 13=^S.
  90. *
  91. * Unimodem mode: use "modprobe ppp_async flag_time=0" as the device _needs_ two
  92. * flags per packet.
  93. */
  94. /* functions called if a device of this driver is connected/disconnected */
  95. static int gigaset_probe(struct usb_interface *interface,
  96. const struct usb_device_id *id);
  97. static void gigaset_disconnect(struct usb_interface *interface);
  98. /* functions called before/after suspend */
  99. static int gigaset_suspend(struct usb_interface *intf, pm_message_t message);
  100. static int gigaset_resume(struct usb_interface *intf);
  101. static int gigaset_pre_reset(struct usb_interface *intf);
  102. static struct gigaset_driver *driver;
  103. /* usb specific object needed to register this driver with the usb subsystem */
  104. static struct usb_driver gigaset_usb_driver = {
  105. .name = GIGASET_MODULENAME,
  106. .probe = gigaset_probe,
  107. .disconnect = gigaset_disconnect,
  108. .id_table = gigaset_table,
  109. .suspend = gigaset_suspend,
  110. .resume = gigaset_resume,
  111. .reset_resume = gigaset_resume,
  112. .pre_reset = gigaset_pre_reset,
  113. .post_reset = gigaset_resume,
  114. };
  115. struct usb_cardstate {
  116. struct usb_device *udev; /* usb device pointer */
  117. struct usb_interface *interface; /* interface for this device */
  118. int busy; /* bulk output in progress */
  119. /* Output buffer */
  120. unsigned char *bulk_out_buffer;
  121. int bulk_out_size;
  122. __u8 bulk_out_endpointAddr;
  123. struct urb *bulk_out_urb;
  124. /* Input buffer */
  125. unsigned char *rcvbuf;
  126. int rcvbuf_size;
  127. struct urb *read_urb;
  128. __u8 int_in_endpointAddr;
  129. char bchars[6]; /* for request 0x19 */
  130. };
  131. static inline unsigned tiocm_to_gigaset(unsigned state)
  132. {
  133. return ((state & TIOCM_DTR) ? 1 : 0) | ((state & TIOCM_RTS) ? 2 : 0);
  134. }
  135. static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
  136. unsigned new_state)
  137. {
  138. struct usb_device *udev = cs->hw.usb->udev;
  139. unsigned mask, val;
  140. int r;
  141. mask = tiocm_to_gigaset(old_state ^ new_state);
  142. val = tiocm_to_gigaset(new_state);
  143. gig_dbg(DEBUG_USBREQ, "set flags 0x%02x with mask 0x%02x", val, mask);
  144. r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 7, 0x41,
  145. (val & 0xff) | ((mask & 0xff) << 8), 0,
  146. NULL, 0, 2000 /* timeout? */);
  147. if (r < 0)
  148. return r;
  149. return 0;
  150. }
  151. /*
  152. * Set M105 configuration value
  153. * using undocumented device commands reverse engineered from USB traces
  154. * of the Siemens Windows driver
  155. */
  156. static int set_value(struct cardstate *cs, u8 req, u16 val)
  157. {
  158. struct usb_device *udev = cs->hw.usb->udev;
  159. int r, r2;
  160. gig_dbg(DEBUG_USBREQ, "request %02x (%04x)",
  161. (unsigned)req, (unsigned)val);
  162. r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x12, 0x41,
  163. 0xf /*?*/, 0, NULL, 0, 2000 /*?*/);
  164. /* no idea what this does */
  165. if (r < 0) {
  166. dev_err(&udev->dev, "error %d on request 0x12\n", -r);
  167. return r;
  168. }
  169. r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), req, 0x41,
  170. val, 0, NULL, 0, 2000 /*?*/);
  171. if (r < 0)
  172. dev_err(&udev->dev, "error %d on request 0x%02x\n",
  173. -r, (unsigned)req);
  174. r2 = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x19, 0x41,
  175. 0, 0, cs->hw.usb->bchars, 6, 2000 /*?*/);
  176. if (r2 < 0)
  177. dev_err(&udev->dev, "error %d on request 0x19\n", -r2);
  178. return r < 0 ? r : (r2 < 0 ? r2 : 0);
  179. }
  180. /*
  181. * set the baud rate on the internal serial adapter
  182. * using the undocumented parameter setting command
  183. */
  184. static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag)
  185. {
  186. u16 val;
  187. u32 rate;
  188. cflag &= CBAUD;
  189. switch (cflag) {
  190. case B300: rate = 300; break;
  191. case B600: rate = 600; break;
  192. case B1200: rate = 1200; break;
  193. case B2400: rate = 2400; break;
  194. case B4800: rate = 4800; break;
  195. case B9600: rate = 9600; break;
  196. case B19200: rate = 19200; break;
  197. case B38400: rate = 38400; break;
  198. case B57600: rate = 57600; break;
  199. case B115200: rate = 115200; break;
  200. default:
  201. rate = 9600;
  202. dev_err(cs->dev, "unsupported baudrate request 0x%x,"
  203. " using default of B9600\n", cflag);
  204. }
  205. val = 0x383fff / rate + 1;
  206. return set_value(cs, 1, val);
  207. }
  208. /*
  209. * set the line format on the internal serial adapter
  210. * using the undocumented parameter setting command
  211. */
  212. static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
  213. {
  214. u16 val = 0;
  215. /* set the parity */
  216. if (cflag & PARENB)
  217. val |= (cflag & PARODD) ? 0x10 : 0x20;
  218. /* set the number of data bits */
  219. switch (cflag & CSIZE) {
  220. case CS5:
  221. val |= 5 << 8; break;
  222. case CS6:
  223. val |= 6 << 8; break;
  224. case CS7:
  225. val |= 7 << 8; break;
  226. case CS8:
  227. val |= 8 << 8; break;
  228. default:
  229. dev_err(cs->dev, "CSIZE was not CS5-CS8, using default of 8\n");
  230. val |= 8 << 8;
  231. break;
  232. }
  233. /* set the number of stop bits */
  234. if (cflag & CSTOPB) {
  235. if ((cflag & CSIZE) == CS5)
  236. val |= 1; /* 1.5 stop bits */
  237. else
  238. val |= 2; /* 2 stop bits */
  239. }
  240. return set_value(cs, 3, val);
  241. }
  242. /*============================================================================*/
  243. static int gigaset_init_bchannel(struct bc_state *bcs)
  244. {
  245. /* nothing to do for M10x */
  246. gigaset_bchannel_up(bcs);
  247. return 0;
  248. }
  249. static int gigaset_close_bchannel(struct bc_state *bcs)
  250. {
  251. /* nothing to do for M10x */
  252. gigaset_bchannel_down(bcs);
  253. return 0;
  254. }
  255. static int write_modem(struct cardstate *cs);
  256. static int send_cb(struct cardstate *cs, struct cmdbuf_t *cb);
  257. /* Write tasklet handler: Continue sending current skb, or send command, or
  258. * start sending an skb from the send queue.
  259. */
  260. static void gigaset_modem_fill(unsigned long data)
  261. {
  262. struct cardstate *cs = (struct cardstate *) data;
  263. struct bc_state *bcs = &cs->bcs[0]; /* only one channel */
  264. struct cmdbuf_t *cb;
  265. int again;
  266. gig_dbg(DEBUG_OUTPUT, "modem_fill");
  267. if (cs->hw.usb->busy) {
  268. gig_dbg(DEBUG_OUTPUT, "modem_fill: busy");
  269. return;
  270. }
  271. do {
  272. again = 0;
  273. if (!bcs->tx_skb) { /* no skb is being sent */
  274. cb = cs->cmdbuf;
  275. if (cb) { /* commands to send? */
  276. gig_dbg(DEBUG_OUTPUT, "modem_fill: cb");
  277. if (send_cb(cs, cb) < 0) {
  278. gig_dbg(DEBUG_OUTPUT,
  279. "modem_fill: send_cb failed");
  280. again = 1; /* no callback will be
  281. called! */
  282. }
  283. } else { /* skbs to send? */
  284. bcs->tx_skb = skb_dequeue(&bcs->squeue);
  285. if (bcs->tx_skb)
  286. gig_dbg(DEBUG_INTR,
  287. "Dequeued skb (Adr: %lx)!",
  288. (unsigned long) bcs->tx_skb);
  289. }
  290. }
  291. if (bcs->tx_skb) {
  292. gig_dbg(DEBUG_OUTPUT, "modem_fill: tx_skb");
  293. if (write_modem(cs) < 0) {
  294. gig_dbg(DEBUG_OUTPUT,
  295. "modem_fill: write_modem failed");
  296. again = 1; /* no callback will be called! */
  297. }
  298. }
  299. } while (again);
  300. }
  301. /*
  302. * Interrupt Input URB completion routine
  303. */
  304. static void gigaset_read_int_callback(struct urb *urb)
  305. {
  306. struct cardstate *cs = urb->context;
  307. struct inbuf_t *inbuf = cs->inbuf;
  308. int status = urb->status;
  309. int r;
  310. unsigned numbytes;
  311. unsigned char *src;
  312. unsigned long flags;
  313. if (!status) {
  314. numbytes = urb->actual_length;
  315. if (numbytes) {
  316. src = cs->hw.usb->rcvbuf;
  317. if (unlikely(*src))
  318. dev_warn(cs->dev,
  319. "%s: There was no leading 0, but 0x%02x!\n",
  320. __func__, (unsigned) *src);
  321. ++src; /* skip leading 0x00 */
  322. --numbytes;
  323. if (gigaset_fill_inbuf(inbuf, src, numbytes)) {
  324. gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
  325. gigaset_schedule_event(inbuf->cs);
  326. }
  327. } else
  328. gig_dbg(DEBUG_INTR, "Received zero block length");
  329. } else {
  330. /* The urb might have been killed. */
  331. gig_dbg(DEBUG_ANY, "%s - nonzero status received: %d",
  332. __func__, status);
  333. if (status == -ENOENT || status == -ESHUTDOWN)
  334. /* killed or endpoint shutdown: don't resubmit */
  335. return;
  336. }
  337. /* resubmit URB */
  338. spin_lock_irqsave(&cs->lock, flags);
  339. if (!cs->connected) {
  340. spin_unlock_irqrestore(&cs->lock, flags);
  341. pr_err("%s: disconnected\n", __func__);
  342. return;
  343. }
  344. r = usb_submit_urb(urb, GFP_ATOMIC);
  345. spin_unlock_irqrestore(&cs->lock, flags);
  346. if (r)
  347. dev_err(cs->dev, "error %d resubmitting URB\n", -r);
  348. }
  349. /* This callback routine is called when data was transmitted to the device. */
  350. static void gigaset_write_bulk_callback(struct urb *urb)
  351. {
  352. struct cardstate *cs = urb->context;
  353. int status = urb->status;
  354. unsigned long flags;
  355. switch (status) {
  356. case 0: /* normal completion */
  357. break;
  358. case -ENOENT: /* killed */
  359. gig_dbg(DEBUG_ANY, "%s: killed", __func__);
  360. cs->hw.usb->busy = 0;
  361. return;
  362. default:
  363. dev_err(cs->dev, "bulk transfer failed (status %d)\n",
  364. -status);
  365. /* That's all we can do. Communication problems
  366. are handled by timeouts or network protocols. */
  367. }
  368. spin_lock_irqsave(&cs->lock, flags);
  369. if (!cs->connected) {
  370. pr_err("%s: disconnected\n", __func__);
  371. } else {
  372. cs->hw.usb->busy = 0;
  373. tasklet_schedule(&cs->write_tasklet);
  374. }
  375. spin_unlock_irqrestore(&cs->lock, flags);
  376. }
  377. static int send_cb(struct cardstate *cs, struct cmdbuf_t *cb)
  378. {
  379. struct cmdbuf_t *tcb;
  380. unsigned long flags;
  381. int count;
  382. int status = -ENOENT;
  383. struct usb_cardstate *ucs = cs->hw.usb;
  384. do {
  385. if (!cb->len) {
  386. tcb = cb;
  387. spin_lock_irqsave(&cs->cmdlock, flags);
  388. cs->cmdbytes -= cs->curlen;
  389. gig_dbg(DEBUG_OUTPUT, "send_cb: sent %u bytes, %u left",
  390. cs->curlen, cs->cmdbytes);
  391. cs->cmdbuf = cb = cb->next;
  392. if (cb) {
  393. cb->prev = NULL;
  394. cs->curlen = cb->len;
  395. } else {
  396. cs->lastcmdbuf = NULL;
  397. cs->curlen = 0;
  398. }
  399. spin_unlock_irqrestore(&cs->cmdlock, flags);
  400. if (tcb->wake_tasklet)
  401. tasklet_schedule(tcb->wake_tasklet);
  402. kfree(tcb);
  403. }
  404. if (cb) {
  405. count = min(cb->len, ucs->bulk_out_size);
  406. gig_dbg(DEBUG_OUTPUT, "send_cb: send %d bytes", count);
  407. usb_fill_bulk_urb(ucs->bulk_out_urb, ucs->udev,
  408. usb_sndbulkpipe(ucs->udev,
  409. ucs->bulk_out_endpointAddr & 0x0f),
  410. cb->buf + cb->offset, count,
  411. gigaset_write_bulk_callback, cs);
  412. cb->offset += count;
  413. cb->len -= count;
  414. ucs->busy = 1;
  415. spin_lock_irqsave(&cs->lock, flags);
  416. status = cs->connected ?
  417. usb_submit_urb(ucs->bulk_out_urb, GFP_ATOMIC) :
  418. -ENODEV;
  419. spin_unlock_irqrestore(&cs->lock, flags);
  420. if (status) {
  421. ucs->busy = 0;
  422. dev_err(cs->dev,
  423. "could not submit urb (error %d)\n",
  424. -status);
  425. cb->len = 0; /* skip urb => remove cb+wakeup
  426. in next loop cycle */
  427. }
  428. }
  429. } while (cb && status); /* next command on error */
  430. return status;
  431. }
  432. /* Send command to device. */
  433. static int gigaset_write_cmd(struct cardstate *cs, const unsigned char *buf,
  434. int len, struct tasklet_struct *wake_tasklet)
  435. {
  436. struct cmdbuf_t *cb;
  437. unsigned long flags;
  438. gigaset_dbg_buffer(cs->mstate != MS_LOCKED ?
  439. DEBUG_TRANSCMD : DEBUG_LOCKCMD,
  440. "CMD Transmit", len, buf);
  441. if (len <= 0)
  442. return 0;
  443. cb = kmalloc(sizeof(struct cmdbuf_t) + len, GFP_ATOMIC);
  444. if (!cb) {
  445. dev_err(cs->dev, "%s: out of memory\n", __func__);
  446. return -ENOMEM;
  447. }
  448. memcpy(cb->buf, buf, len);
  449. cb->len = len;
  450. cb->offset = 0;
  451. cb->next = NULL;
  452. cb->wake_tasklet = wake_tasklet;
  453. spin_lock_irqsave(&cs->cmdlock, flags);
  454. cb->prev = cs->lastcmdbuf;
  455. if (cs->lastcmdbuf)
  456. cs->lastcmdbuf->next = cb;
  457. else {
  458. cs->cmdbuf = cb;
  459. cs->curlen = len;
  460. }
  461. cs->cmdbytes += len;
  462. cs->lastcmdbuf = cb;
  463. spin_unlock_irqrestore(&cs->cmdlock, flags);
  464. spin_lock_irqsave(&cs->lock, flags);
  465. if (cs->connected)
  466. tasklet_schedule(&cs->write_tasklet);
  467. spin_unlock_irqrestore(&cs->lock, flags);
  468. return len;
  469. }
  470. static int gigaset_write_room(struct cardstate *cs)
  471. {
  472. unsigned bytes;
  473. bytes = cs->cmdbytes;
  474. return bytes < IF_WRITEBUF ? IF_WRITEBUF - bytes : 0;
  475. }
  476. static int gigaset_chars_in_buffer(struct cardstate *cs)
  477. {
  478. return cs->cmdbytes;
  479. }
  480. /*
  481. * set the break characters on the internal serial adapter
  482. * using undocumented device commands reverse engineered from USB traces
  483. * of the Siemens Windows driver
  484. */
  485. static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6])
  486. {
  487. struct usb_device *udev = cs->hw.usb->udev;
  488. gigaset_dbg_buffer(DEBUG_USBREQ, "brkchars", 6, buf);
  489. memcpy(cs->hw.usb->bchars, buf, 6);
  490. return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x19, 0x41,
  491. 0, 0, &buf, 6, 2000);
  492. }
  493. static int gigaset_freebcshw(struct bc_state *bcs)
  494. {
  495. /* unused */
  496. return 1;
  497. }
  498. /* Initialize the b-channel structure */
  499. static int gigaset_initbcshw(struct bc_state *bcs)
  500. {
  501. /* unused */
  502. bcs->hw.usb = NULL;
  503. return 1;
  504. }
  505. static void gigaset_reinitbcshw(struct bc_state *bcs)
  506. {
  507. /* nothing to do for M10x */
  508. }
  509. static void gigaset_freecshw(struct cardstate *cs)
  510. {
  511. tasklet_kill(&cs->write_tasklet);
  512. kfree(cs->hw.usb);
  513. }
  514. static int gigaset_initcshw(struct cardstate *cs)
  515. {
  516. struct usb_cardstate *ucs;
  517. cs->hw.usb = ucs =
  518. kmalloc(sizeof(struct usb_cardstate), GFP_KERNEL);
  519. if (!ucs) {
  520. pr_err("out of memory\n");
  521. return 0;
  522. }
  523. ucs->bchars[0] = 0;
  524. ucs->bchars[1] = 0;
  525. ucs->bchars[2] = 0;
  526. ucs->bchars[3] = 0;
  527. ucs->bchars[4] = 0x11;
  528. ucs->bchars[5] = 0x13;
  529. ucs->bulk_out_buffer = NULL;
  530. ucs->bulk_out_urb = NULL;
  531. ucs->read_urb = NULL;
  532. tasklet_init(&cs->write_tasklet,
  533. gigaset_modem_fill, (unsigned long) cs);
  534. return 1;
  535. }
  536. /* Send data from current skb to the device. */
  537. static int write_modem(struct cardstate *cs)
  538. {
  539. int ret = 0;
  540. int count;
  541. struct bc_state *bcs = &cs->bcs[0]; /* only one channel */
  542. struct usb_cardstate *ucs = cs->hw.usb;
  543. unsigned long flags;
  544. gig_dbg(DEBUG_WRITE, "len: %d...", bcs->tx_skb->len);
  545. if (!bcs->tx_skb->len) {
  546. dev_kfree_skb_any(bcs->tx_skb);
  547. bcs->tx_skb = NULL;
  548. return -EINVAL;
  549. }
  550. /* Copy data to bulk out buffer and transmit data */
  551. count = min(bcs->tx_skb->len, (unsigned) ucs->bulk_out_size);
  552. skb_copy_from_linear_data(bcs->tx_skb, ucs->bulk_out_buffer, count);
  553. skb_pull(bcs->tx_skb, count);
  554. ucs->busy = 1;
  555. gig_dbg(DEBUG_OUTPUT, "write_modem: send %d bytes", count);
  556. spin_lock_irqsave(&cs->lock, flags);
  557. if (cs->connected) {
  558. usb_fill_bulk_urb(ucs->bulk_out_urb, ucs->udev,
  559. usb_sndbulkpipe(ucs->udev,
  560. ucs->bulk_out_endpointAddr &
  561. 0x0f),
  562. ucs->bulk_out_buffer, count,
  563. gigaset_write_bulk_callback, cs);
  564. ret = usb_submit_urb(ucs->bulk_out_urb, GFP_ATOMIC);
  565. } else {
  566. ret = -ENODEV;
  567. }
  568. spin_unlock_irqrestore(&cs->lock, flags);
  569. if (ret) {
  570. dev_err(cs->dev, "could not submit urb (error %d)\n", -ret);
  571. ucs->busy = 0;
  572. }
  573. if (!bcs->tx_skb->len) {
  574. /* skb sent completely */
  575. gigaset_skb_sent(bcs, bcs->tx_skb);
  576. gig_dbg(DEBUG_INTR, "kfree skb (Adr: %lx)!",
  577. (unsigned long) bcs->tx_skb);
  578. dev_kfree_skb_any(bcs->tx_skb);
  579. bcs->tx_skb = NULL;
  580. }
  581. return ret;
  582. }
  583. static int gigaset_probe(struct usb_interface *interface,
  584. const struct usb_device_id *id)
  585. {
  586. int retval;
  587. struct usb_device *udev = interface_to_usbdev(interface);
  588. struct usb_host_interface *hostif = interface->cur_altsetting;
  589. struct cardstate *cs = NULL;
  590. struct usb_cardstate *ucs = NULL;
  591. struct usb_endpoint_descriptor *endpoint;
  592. int buffer_size;
  593. gig_dbg(DEBUG_ANY, "%s: Check if device matches ...", __func__);
  594. /* See if the device offered us matches what we can accept */
  595. if ((le16_to_cpu(udev->descriptor.idVendor) != USB_M105_VENDOR_ID) ||
  596. (le16_to_cpu(udev->descriptor.idProduct) != USB_M105_PRODUCT_ID)) {
  597. gig_dbg(DEBUG_ANY, "device ID (0x%x, 0x%x) not for me - skip",
  598. le16_to_cpu(udev->descriptor.idVendor),
  599. le16_to_cpu(udev->descriptor.idProduct));
  600. return -ENODEV;
  601. }
  602. if (hostif->desc.bInterfaceNumber != 0) {
  603. gig_dbg(DEBUG_ANY, "interface %d not for me - skip",
  604. hostif->desc.bInterfaceNumber);
  605. return -ENODEV;
  606. }
  607. if (hostif->desc.bAlternateSetting != 0) {
  608. dev_notice(&udev->dev, "unsupported altsetting %d - skip",
  609. hostif->desc.bAlternateSetting);
  610. return -ENODEV;
  611. }
  612. if (hostif->desc.bInterfaceClass != 255) {
  613. dev_notice(&udev->dev, "unsupported interface class %d - skip",
  614. hostif->desc.bInterfaceClass);
  615. return -ENODEV;
  616. }
  617. dev_info(&udev->dev, "%s: Device matched ... !\n", __func__);
  618. /* allocate memory for our device state and intialize it */
  619. cs = gigaset_initcs(driver, 1, 1, 0, cidmode, GIGASET_MODULENAME);
  620. if (!cs)
  621. return -ENODEV;
  622. ucs = cs->hw.usb;
  623. /* save off device structure ptrs for later use */
  624. usb_get_dev(udev);
  625. ucs->udev = udev;
  626. ucs->interface = interface;
  627. cs->dev = &interface->dev;
  628. /* save address of controller structure */
  629. usb_set_intfdata(interface, cs);
  630. endpoint = &hostif->endpoint[0].desc;
  631. buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
  632. ucs->bulk_out_size = buffer_size;
  633. ucs->bulk_out_endpointAddr = endpoint->bEndpointAddress;
  634. ucs->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
  635. if (!ucs->bulk_out_buffer) {
  636. dev_err(cs->dev, "Couldn't allocate bulk_out_buffer\n");
  637. retval = -ENOMEM;
  638. goto error;
  639. }
  640. ucs->bulk_out_urb = usb_alloc_urb(0, GFP_KERNEL);
  641. if (!ucs->bulk_out_urb) {
  642. dev_err(cs->dev, "Couldn't allocate bulk_out_urb\n");
  643. retval = -ENOMEM;
  644. goto error;
  645. }
  646. endpoint = &hostif->endpoint[1].desc;
  647. ucs->busy = 0;
  648. ucs->read_urb = usb_alloc_urb(0, GFP_KERNEL);
  649. if (!ucs->read_urb) {
  650. dev_err(cs->dev, "No free urbs available\n");
  651. retval = -ENOMEM;
  652. goto error;
  653. }
  654. buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
  655. ucs->rcvbuf_size = buffer_size;
  656. ucs->int_in_endpointAddr = endpoint->bEndpointAddress;
  657. ucs->rcvbuf = kmalloc(buffer_size, GFP_KERNEL);
  658. if (!ucs->rcvbuf) {
  659. dev_err(cs->dev, "Couldn't allocate rcvbuf\n");
  660. retval = -ENOMEM;
  661. goto error;
  662. }
  663. /* Fill the interrupt urb and send it to the core */
  664. usb_fill_int_urb(ucs->read_urb, udev,
  665. usb_rcvintpipe(udev,
  666. endpoint->bEndpointAddress & 0x0f),
  667. ucs->rcvbuf, buffer_size,
  668. gigaset_read_int_callback,
  669. cs, endpoint->bInterval);
  670. retval = usb_submit_urb(ucs->read_urb, GFP_KERNEL);
  671. if (retval) {
  672. dev_err(cs->dev, "Could not submit URB (error %d)\n", -retval);
  673. goto error;
  674. }
  675. /* tell common part that the device is ready */
  676. if (startmode == SM_LOCKED)
  677. cs->mstate = MS_LOCKED;
  678. if (!gigaset_start(cs)) {
  679. tasklet_kill(&cs->write_tasklet);
  680. retval = -ENODEV;
  681. goto error;
  682. }
  683. return 0;
  684. error:
  685. usb_kill_urb(ucs->read_urb);
  686. kfree(ucs->bulk_out_buffer);
  687. usb_free_urb(ucs->bulk_out_urb);
  688. kfree(ucs->rcvbuf);
  689. usb_free_urb(ucs->read_urb);
  690. usb_set_intfdata(interface, NULL);
  691. ucs->read_urb = ucs->bulk_out_urb = NULL;
  692. ucs->rcvbuf = ucs->bulk_out_buffer = NULL;
  693. usb_put_dev(ucs->udev);
  694. ucs->udev = NULL;
  695. ucs->interface = NULL;
  696. gigaset_freecs(cs);
  697. return retval;
  698. }
  699. static void gigaset_disconnect(struct usb_interface *interface)
  700. {
  701. struct cardstate *cs;
  702. struct usb_cardstate *ucs;
  703. cs = usb_get_intfdata(interface);
  704. ucs = cs->hw.usb;
  705. dev_info(cs->dev, "disconnecting Gigaset USB adapter\n");
  706. usb_kill_urb(ucs->read_urb);
  707. gigaset_stop(cs);
  708. usb_set_intfdata(interface, NULL);
  709. tasklet_kill(&cs->write_tasklet);
  710. usb_kill_urb(ucs->bulk_out_urb);
  711. kfree(ucs->bulk_out_buffer);
  712. usb_free_urb(ucs->bulk_out_urb);
  713. kfree(ucs->rcvbuf);
  714. usb_free_urb(ucs->read_urb);
  715. ucs->read_urb = ucs->bulk_out_urb = NULL;
  716. ucs->rcvbuf = ucs->bulk_out_buffer = NULL;
  717. usb_put_dev(ucs->udev);
  718. ucs->interface = NULL;
  719. ucs->udev = NULL;
  720. cs->dev = NULL;
  721. gigaset_freecs(cs);
  722. }
  723. /* gigaset_suspend
  724. * This function is called before the USB connection is suspended or reset.
  725. */
  726. static int gigaset_suspend(struct usb_interface *intf, pm_message_t message)
  727. {
  728. struct cardstate *cs = usb_get_intfdata(intf);
  729. /* stop activity */
  730. cs->connected = 0; /* prevent rescheduling */
  731. usb_kill_urb(cs->hw.usb->read_urb);
  732. tasklet_kill(&cs->write_tasklet);
  733. usb_kill_urb(cs->hw.usb->bulk_out_urb);
  734. gig_dbg(DEBUG_SUSPEND, "suspend complete");
  735. return 0;
  736. }
  737. /* gigaset_resume
  738. * This function is called after the USB connection has been resumed or reset.
  739. */
  740. static int gigaset_resume(struct usb_interface *intf)
  741. {
  742. struct cardstate *cs = usb_get_intfdata(intf);
  743. int rc;
  744. /* resubmit interrupt URB */
  745. cs->connected = 1;
  746. rc = usb_submit_urb(cs->hw.usb->read_urb, GFP_KERNEL);
  747. if (rc) {
  748. dev_err(cs->dev, "Could not submit read URB (error %d)\n", -rc);
  749. return rc;
  750. }
  751. gig_dbg(DEBUG_SUSPEND, "resume complete");
  752. return 0;
  753. }
  754. /* gigaset_pre_reset
  755. * This function is called before the USB connection is reset.
  756. */
  757. static int gigaset_pre_reset(struct usb_interface *intf)
  758. {
  759. /* same as suspend */
  760. return gigaset_suspend(intf, PMSG_ON);
  761. }
  762. static const struct gigaset_ops ops = {
  763. gigaset_write_cmd,
  764. gigaset_write_room,
  765. gigaset_chars_in_buffer,
  766. gigaset_brkchars,
  767. gigaset_init_bchannel,
  768. gigaset_close_bchannel,
  769. gigaset_initbcshw,
  770. gigaset_freebcshw,
  771. gigaset_reinitbcshw,
  772. gigaset_initcshw,
  773. gigaset_freecshw,
  774. gigaset_set_modem_ctrl,
  775. gigaset_baud_rate,
  776. gigaset_set_line_ctrl,
  777. gigaset_m10x_send_skb,
  778. gigaset_m10x_input,
  779. };
  780. /*
  781. * This function is called while kernel-module is loaded
  782. */
  783. static int __init usb_gigaset_init(void)
  784. {
  785. int result;
  786. /* allocate memory for our driver state and intialize it */
  787. driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
  788. GIGASET_MODULENAME, GIGASET_DEVNAME,
  789. &ops, THIS_MODULE);
  790. if (driver == NULL)
  791. goto error;
  792. /* register this driver with the USB subsystem */
  793. result = usb_register(&gigaset_usb_driver);
  794. if (result < 0) {
  795. pr_err("error %d registering USB driver\n", -result);
  796. goto error;
  797. }
  798. pr_info(DRIVER_DESC "\n");
  799. return 0;
  800. error:
  801. if (driver)
  802. gigaset_freedriver(driver);
  803. driver = NULL;
  804. return -1;
  805. }
  806. /*
  807. * This function is called while unloading the kernel-module
  808. */
  809. static void __exit usb_gigaset_exit(void)
  810. {
  811. int i;
  812. gigaset_blockdriver(driver); /* => probe will fail
  813. * => no gigaset_start any more
  814. */
  815. /* stop all connected devices */
  816. for (i = 0; i < driver->minors; i++)
  817. gigaset_shutdown(driver->cs + i);
  818. /* from now on, no isdn callback should be possible */
  819. /* deregister this driver with the USB subsystem */
  820. usb_deregister(&gigaset_usb_driver);
  821. /* this will call the disconnect-callback */
  822. /* from now on, no disconnect/probe callback should be running */
  823. gigaset_freedriver(driver);
  824. driver = NULL;
  825. }
  826. module_init(usb_gigaset_init);
  827. module_exit(usb_gigaset_exit);
  828. MODULE_AUTHOR(DRIVER_AUTHOR);
  829. MODULE_DESCRIPTION(DRIVER_DESC);
  830. MODULE_LICENSE("GPL");