cdc-acm.c 37 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443
  1. /*
  2. * cdc-acm.c
  3. *
  4. * Copyright (c) 1999 Armin Fuerst <fuerst@in.tum.de>
  5. * Copyright (c) 1999 Pavel Machek <pavel@suse.cz>
  6. * Copyright (c) 1999 Johannes Erdfelt <johannes@erdfelt.com>
  7. * Copyright (c) 2000 Vojtech Pavlik <vojtech@suse.cz>
  8. * Copyright (c) 2004 Oliver Neukum <oliver@neukum.name>
  9. * Copyright (c) 2005 David Kubicek <dave@awk.cz>
  10. *
  11. * USB Abstract Control Model driver for USB modems and ISDN adapters
  12. *
  13. * Sponsored by SuSE
  14. *
  15. * ChangeLog:
  16. * v0.9 - thorough cleaning, URBification, almost a rewrite
  17. * v0.10 - some more cleanups
  18. * v0.11 - fixed flow control, read error doesn't stop reads
  19. * v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
  20. * v0.13 - added termios, added hangup
  21. * v0.14 - sized down struct acm
  22. * v0.15 - fixed flow control again - characters could be lost
  23. * v0.16 - added code for modems with swapped data and control interfaces
  24. * v0.17 - added new style probing
  25. * v0.18 - fixed new style probing for devices with more configurations
  26. * v0.19 - fixed CLOCAL handling (thanks to Richard Shih-Ping Chan)
  27. * v0.20 - switched to probing on interface (rather than device) class
  28. * v0.21 - revert to probing on device for devices with multiple configs
  29. * v0.22 - probe only the control interface. if usbcore doesn't choose the
  30. * config we want, sysadmin changes bConfigurationValue in sysfs.
  31. * v0.23 - use softirq for rx processing, as needed by tty layer
  32. * v0.24 - change probe method to evaluate CDC union descriptor
  33. * v0.25 - downstream tasks paralelized to maximize throughput
  34. * v0.26 - multiple write urbs, writesize increased
  35. */
  36. /*
  37. * This program is free software; you can redistribute it and/or modify
  38. * it under the terms of the GNU General Public License as published by
  39. * the Free Software Foundation; either version 2 of the License, or
  40. * (at your option) any later version.
  41. *
  42. * This program is distributed in the hope that it will be useful,
  43. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  44. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  45. * GNU General Public License for more details.
  46. *
  47. * You should have received a copy of the GNU General Public License
  48. * along with this program; if not, write to the Free Software
  49. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  50. */
  51. #undef DEBUG
  52. #include <linux/kernel.h>
  53. #include <linux/errno.h>
  54. #include <linux/init.h>
  55. #include <linux/slab.h>
  56. #include <linux/tty.h>
  57. #include <linux/tty_driver.h>
  58. #include <linux/tty_flip.h>
  59. #include <linux/module.h>
  60. #include <linux/mutex.h>
  61. #include <asm/uaccess.h>
  62. #include <linux/usb.h>
  63. #include <linux/usb/cdc.h>
  64. #include <asm/byteorder.h>
  65. #include <asm/unaligned.h>
  66. #include <linux/list.h>
  67. #include "cdc-acm.h"
  68. /*
  69. * Version Information
  70. */
  71. #define DRIVER_VERSION "v0.26"
  72. #define DRIVER_AUTHOR "Armin Fuerst, Pavel Machek, Johannes Erdfelt, Vojtech Pavlik, David Kubicek"
  73. #define DRIVER_DESC "USB Abstract Control Model driver for USB modems and ISDN adapters"
  74. static struct usb_driver acm_driver;
  75. static struct tty_driver *acm_tty_driver;
  76. static struct acm *acm_table[ACM_TTY_MINORS];
  77. static DEFINE_MUTEX(open_mutex);
  78. #define ACM_READY(acm) (acm && acm->dev && acm->used)
  79. /*
  80. * Functions for ACM control messages.
  81. */
  82. static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
  83. {
  84. int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
  85. request, USB_RT_ACM, value,
  86. acm->control->altsetting[0].desc.bInterfaceNumber,
  87. buf, len, 5000);
  88. dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
  89. return retval < 0 ? retval : 0;
  90. }
  91. /* devices aren't required to support these requests.
  92. * the cdc acm descriptor tells whether they do...
  93. */
  94. #define acm_set_control(acm, control) \
  95. acm_ctrl_msg(acm, USB_CDC_REQ_SET_CONTROL_LINE_STATE, control, NULL, 0)
  96. #define acm_set_line(acm, line) \
  97. acm_ctrl_msg(acm, USB_CDC_REQ_SET_LINE_CODING, 0, line, sizeof *(line))
  98. #define acm_send_break(acm, ms) \
  99. acm_ctrl_msg(acm, USB_CDC_REQ_SEND_BREAK, ms, NULL, 0)
  100. /*
  101. * Write buffer management.
  102. * All of these assume proper locks taken by the caller.
  103. */
  104. static int acm_wb_alloc(struct acm *acm)
  105. {
  106. int i, wbn;
  107. struct acm_wb *wb;
  108. wbn = 0;
  109. i = 0;
  110. for (;;) {
  111. wb = &acm->wb[wbn];
  112. if (!wb->use) {
  113. wb->use = 1;
  114. return wbn;
  115. }
  116. wbn = (wbn + 1) % ACM_NW;
  117. if (++i >= ACM_NW)
  118. return -1;
  119. }
  120. }
  121. static int acm_wb_is_avail(struct acm *acm)
  122. {
  123. int i, n;
  124. n = ACM_NW;
  125. for (i = 0; i < ACM_NW; i++) {
  126. n -= acm->wb[i].use;
  127. }
  128. return n;
  129. }
  130. /*
  131. * Finish write.
  132. */
  133. static void acm_write_done(struct acm *acm, struct acm_wb *wb)
  134. {
  135. unsigned long flags;
  136. spin_lock_irqsave(&acm->write_lock, flags);
  137. wb->use = 0;
  138. acm->transmitting--;
  139. spin_unlock_irqrestore(&acm->write_lock, flags);
  140. }
  141. /*
  142. * Poke write.
  143. *
  144. * the caller is responsible for locking
  145. */
  146. static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
  147. {
  148. int rc;
  149. acm->transmitting++;
  150. wb->urb->transfer_buffer = wb->buf;
  151. wb->urb->transfer_dma = wb->dmah;
  152. wb->urb->transfer_buffer_length = wb->len;
  153. wb->urb->dev = acm->dev;
  154. if ((rc = usb_submit_urb(wb->urb, GFP_ATOMIC)) < 0) {
  155. dbg("usb_submit_urb(write bulk) failed: %d", rc);
  156. acm_write_done(acm, wb);
  157. }
  158. return rc;
  159. }
  160. static int acm_write_start(struct acm *acm, int wbn)
  161. {
  162. unsigned long flags;
  163. struct acm_wb *wb = &acm->wb[wbn];
  164. int rc;
  165. spin_lock_irqsave(&acm->write_lock, flags);
  166. if (!acm->dev) {
  167. wb->use = 0;
  168. spin_unlock_irqrestore(&acm->write_lock, flags);
  169. return -ENODEV;
  170. }
  171. dbg("%s susp_count: %d", __func__, acm->susp_count);
  172. if (acm->susp_count) {
  173. acm->delayed_wb = wb;
  174. schedule_work(&acm->waker);
  175. spin_unlock_irqrestore(&acm->write_lock, flags);
  176. return 0; /* A white lie */
  177. }
  178. usb_mark_last_busy(acm->dev);
  179. rc = acm_start_wb(acm, wb);
  180. spin_unlock_irqrestore(&acm->write_lock, flags);
  181. return rc;
  182. }
  183. /*
  184. * attributes exported through sysfs
  185. */
  186. static ssize_t show_caps
  187. (struct device *dev, struct device_attribute *attr, char *buf)
  188. {
  189. struct usb_interface *intf = to_usb_interface(dev);
  190. struct acm *acm = usb_get_intfdata(intf);
  191. return sprintf(buf, "%d", acm->ctrl_caps);
  192. }
  193. static DEVICE_ATTR(bmCapabilities, S_IRUGO, show_caps, NULL);
  194. static ssize_t show_country_codes
  195. (struct device *dev, struct device_attribute *attr, char *buf)
  196. {
  197. struct usb_interface *intf = to_usb_interface(dev);
  198. struct acm *acm = usb_get_intfdata(intf);
  199. memcpy(buf, acm->country_codes, acm->country_code_size);
  200. return acm->country_code_size;
  201. }
  202. static DEVICE_ATTR(wCountryCodes, S_IRUGO, show_country_codes, NULL);
  203. static ssize_t show_country_rel_date
  204. (struct device *dev, struct device_attribute *attr, char *buf)
  205. {
  206. struct usb_interface *intf = to_usb_interface(dev);
  207. struct acm *acm = usb_get_intfdata(intf);
  208. return sprintf(buf, "%d", acm->country_rel_date);
  209. }
  210. static DEVICE_ATTR(iCountryCodeRelDate, S_IRUGO, show_country_rel_date, NULL);
  211. /*
  212. * Interrupt handlers for various ACM device responses
  213. */
  214. /* control interface reports status changes with "interrupt" transfers */
  215. static void acm_ctrl_irq(struct urb *urb)
  216. {
  217. struct acm *acm = urb->context;
  218. struct usb_cdc_notification *dr = urb->transfer_buffer;
  219. unsigned char *data;
  220. int newctrl;
  221. int retval;
  222. int status = urb->status;
  223. switch (status) {
  224. case 0:
  225. /* success */
  226. break;
  227. case -ECONNRESET:
  228. case -ENOENT:
  229. case -ESHUTDOWN:
  230. /* this urb is terminated, clean up */
  231. dbg("%s - urb shutting down with status: %d", __func__, status);
  232. return;
  233. default:
  234. dbg("%s - nonzero urb status received: %d", __func__, status);
  235. goto exit;
  236. }
  237. if (!ACM_READY(acm))
  238. goto exit;
  239. data = (unsigned char *)(dr + 1);
  240. switch (dr->bNotificationType) {
  241. case USB_CDC_NOTIFY_NETWORK_CONNECTION:
  242. dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
  243. break;
  244. case USB_CDC_NOTIFY_SERIAL_STATE:
  245. newctrl = get_unaligned_le16(data);
  246. if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
  247. dbg("calling hangup");
  248. tty_hangup(acm->tty);
  249. }
  250. acm->ctrlin = newctrl;
  251. dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
  252. acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
  253. acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI ? '+' : '-',
  254. acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-', acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
  255. acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
  256. break;
  257. default:
  258. dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
  259. dr->bNotificationType, dr->wIndex,
  260. dr->wLength, data[0], data[1]);
  261. break;
  262. }
  263. exit:
  264. usb_mark_last_busy(acm->dev);
  265. retval = usb_submit_urb (urb, GFP_ATOMIC);
  266. if (retval)
  267. err ("%s - usb_submit_urb failed with result %d",
  268. __func__, retval);
  269. }
  270. /* data interface returns incoming bytes, or we got unthrottled */
  271. static void acm_read_bulk(struct urb *urb)
  272. {
  273. struct acm_rb *buf;
  274. struct acm_ru *rcv = urb->context;
  275. struct acm *acm = rcv->instance;
  276. int status = urb->status;
  277. dbg("Entering acm_read_bulk with status %d", status);
  278. if (!ACM_READY(acm)) {
  279. dev_dbg(&acm->data->dev, "Aborting, acm not ready");
  280. return;
  281. }
  282. usb_mark_last_busy(acm->dev);
  283. if (status)
  284. dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
  285. buf = rcv->buffer;
  286. buf->size = urb->actual_length;
  287. if (likely(status == 0)) {
  288. spin_lock(&acm->read_lock);
  289. acm->processing++;
  290. list_add_tail(&rcv->list, &acm->spare_read_urbs);
  291. list_add_tail(&buf->list, &acm->filled_read_bufs);
  292. spin_unlock(&acm->read_lock);
  293. } else {
  294. /* we drop the buffer due to an error */
  295. spin_lock(&acm->read_lock);
  296. list_add_tail(&rcv->list, &acm->spare_read_urbs);
  297. list_add(&buf->list, &acm->spare_read_bufs);
  298. spin_unlock(&acm->read_lock);
  299. /* nevertheless the tasklet must be kicked unconditionally
  300. so the queue cannot dry up */
  301. }
  302. if (likely(!acm->susp_count))
  303. tasklet_schedule(&acm->urb_task);
  304. }
  305. static void acm_rx_tasklet(unsigned long _acm)
  306. {
  307. struct acm *acm = (void *)_acm;
  308. struct acm_rb *buf;
  309. struct tty_struct *tty = acm->tty;
  310. struct acm_ru *rcv;
  311. unsigned long flags;
  312. unsigned char throttled;
  313. dbg("Entering acm_rx_tasklet");
  314. if (!ACM_READY(acm))
  315. {
  316. dbg("acm_rx_tasklet: ACM not ready");
  317. return;
  318. }
  319. spin_lock_irqsave(&acm->throttle_lock, flags);
  320. throttled = acm->throttle;
  321. spin_unlock_irqrestore(&acm->throttle_lock, flags);
  322. if (throttled)
  323. {
  324. dbg("acm_rx_tasklet: throttled");
  325. return;
  326. }
  327. next_buffer:
  328. spin_lock_irqsave(&acm->read_lock, flags);
  329. if (list_empty(&acm->filled_read_bufs)) {
  330. spin_unlock_irqrestore(&acm->read_lock, flags);
  331. goto urbs;
  332. }
  333. buf = list_entry(acm->filled_read_bufs.next,
  334. struct acm_rb, list);
  335. list_del(&buf->list);
  336. spin_unlock_irqrestore(&acm->read_lock, flags);
  337. dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
  338. tty_buffer_request_room(tty, buf->size);
  339. spin_lock_irqsave(&acm->throttle_lock, flags);
  340. throttled = acm->throttle;
  341. spin_unlock_irqrestore(&acm->throttle_lock, flags);
  342. if (!throttled)
  343. tty_insert_flip_string(tty, buf->base, buf->size);
  344. tty_flip_buffer_push(tty);
  345. if (throttled) {
  346. dbg("Throttling noticed");
  347. spin_lock_irqsave(&acm->read_lock, flags);
  348. list_add(&buf->list, &acm->filled_read_bufs);
  349. spin_unlock_irqrestore(&acm->read_lock, flags);
  350. return;
  351. }
  352. spin_lock_irqsave(&acm->read_lock, flags);
  353. list_add(&buf->list, &acm->spare_read_bufs);
  354. spin_unlock_irqrestore(&acm->read_lock, flags);
  355. goto next_buffer;
  356. urbs:
  357. while (!list_empty(&acm->spare_read_bufs)) {
  358. spin_lock_irqsave(&acm->read_lock, flags);
  359. if (list_empty(&acm->spare_read_urbs)) {
  360. acm->processing = 0;
  361. spin_unlock_irqrestore(&acm->read_lock, flags);
  362. return;
  363. }
  364. rcv = list_entry(acm->spare_read_urbs.next,
  365. struct acm_ru, list);
  366. list_del(&rcv->list);
  367. spin_unlock_irqrestore(&acm->read_lock, flags);
  368. buf = list_entry(acm->spare_read_bufs.next,
  369. struct acm_rb, list);
  370. list_del(&buf->list);
  371. rcv->buffer = buf;
  372. usb_fill_bulk_urb(rcv->urb, acm->dev,
  373. acm->rx_endpoint,
  374. buf->base,
  375. acm->readsize,
  376. acm_read_bulk, rcv);
  377. rcv->urb->transfer_dma = buf->dma;
  378. rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  379. /* This shouldn't kill the driver as unsuccessful URBs are returned to the
  380. free-urbs-pool and resubmited ASAP */
  381. spin_lock_irqsave(&acm->read_lock, flags);
  382. if (acm->susp_count || usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
  383. list_add(&buf->list, &acm->spare_read_bufs);
  384. list_add(&rcv->list, &acm->spare_read_urbs);
  385. acm->processing = 0;
  386. spin_unlock_irqrestore(&acm->read_lock, flags);
  387. return;
  388. } else {
  389. spin_unlock_irqrestore(&acm->read_lock, flags);
  390. dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
  391. }
  392. }
  393. spin_lock_irqsave(&acm->read_lock, flags);
  394. acm->processing = 0;
  395. spin_unlock_irqrestore(&acm->read_lock, flags);
  396. }
  397. /* data interface wrote those outgoing bytes */
  398. static void acm_write_bulk(struct urb *urb)
  399. {
  400. struct acm *acm;
  401. struct acm_wb *wb = urb->context;
  402. dbg("Entering acm_write_bulk with status %d", urb->status);
  403. acm = wb->instance;
  404. acm_write_done(acm, wb);
  405. if (ACM_READY(acm))
  406. schedule_work(&acm->work);
  407. }
  408. static void acm_softint(struct work_struct *work)
  409. {
  410. struct acm *acm = container_of(work, struct acm, work);
  411. dbg("Entering acm_softint.");
  412. if (!ACM_READY(acm))
  413. return;
  414. tty_wakeup(acm->tty);
  415. }
  416. static void acm_waker(struct work_struct *waker)
  417. {
  418. struct acm *acm = container_of(waker, struct acm, waker);
  419. int rv;
  420. rv = usb_autopm_get_interface(acm->control);
  421. if (rv < 0) {
  422. err("Autopm failure in %s", __func__);
  423. return;
  424. }
  425. if (acm->delayed_wb) {
  426. acm_start_wb(acm, acm->delayed_wb);
  427. acm->delayed_wb = NULL;
  428. }
  429. usb_autopm_put_interface(acm->control);
  430. }
  431. /*
  432. * TTY handlers
  433. */
  434. static int acm_tty_open(struct tty_struct *tty, struct file *filp)
  435. {
  436. struct acm *acm;
  437. int rv = -EINVAL;
  438. int i;
  439. dbg("Entering acm_tty_open.");
  440. mutex_lock(&open_mutex);
  441. acm = acm_table[tty->index];
  442. if (!acm || !acm->dev)
  443. goto err_out;
  444. else
  445. rv = 0;
  446. set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
  447. tty->driver_data = acm;
  448. acm->tty = tty;
  449. /* force low_latency on so that our tty_push actually forces the data through,
  450. otherwise it is scheduled, and with high data rates data can get lost. */
  451. tty->low_latency = 1;
  452. if (usb_autopm_get_interface(acm->control) < 0)
  453. goto early_bail;
  454. else
  455. acm->control->needs_remote_wakeup = 1;
  456. mutex_lock(&acm->mutex);
  457. if (acm->used++) {
  458. usb_autopm_put_interface(acm->control);
  459. goto done;
  460. }
  461. acm->ctrlurb->dev = acm->dev;
  462. if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
  463. dbg("usb_submit_urb(ctrl irq) failed");
  464. goto bail_out;
  465. }
  466. if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
  467. (acm->ctrl_caps & USB_CDC_CAP_LINE))
  468. goto full_bailout;
  469. usb_autopm_put_interface(acm->control);
  470. INIT_LIST_HEAD(&acm->spare_read_urbs);
  471. INIT_LIST_HEAD(&acm->spare_read_bufs);
  472. INIT_LIST_HEAD(&acm->filled_read_bufs);
  473. for (i = 0; i < acm->rx_buflimit; i++) {
  474. list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
  475. }
  476. for (i = 0; i < acm->rx_buflimit; i++) {
  477. list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
  478. }
  479. acm->throttle = 0;
  480. tasklet_schedule(&acm->urb_task);
  481. done:
  482. err_out:
  483. mutex_unlock(&acm->mutex);
  484. mutex_unlock(&open_mutex);
  485. return rv;
  486. full_bailout:
  487. usb_kill_urb(acm->ctrlurb);
  488. bail_out:
  489. usb_autopm_put_interface(acm->control);
  490. acm->used--;
  491. mutex_unlock(&acm->mutex);
  492. early_bail:
  493. mutex_unlock(&open_mutex);
  494. return -EIO;
  495. }
  496. static void acm_tty_unregister(struct acm *acm)
  497. {
  498. int i,nr;
  499. nr = acm->rx_buflimit;
  500. tty_unregister_device(acm_tty_driver, acm->minor);
  501. usb_put_intf(acm->control);
  502. acm_table[acm->minor] = NULL;
  503. usb_free_urb(acm->ctrlurb);
  504. for (i = 0; i < ACM_NW; i++)
  505. usb_free_urb(acm->wb[i].urb);
  506. for (i = 0; i < nr; i++)
  507. usb_free_urb(acm->ru[i].urb);
  508. kfree(acm->country_codes);
  509. kfree(acm);
  510. }
  511. static void acm_tty_close(struct tty_struct *tty, struct file *filp)
  512. {
  513. struct acm *acm = tty->driver_data;
  514. int i,nr;
  515. if (!acm || !acm->used)
  516. return;
  517. nr = acm->rx_buflimit;
  518. mutex_lock(&open_mutex);
  519. if (!--acm->used) {
  520. if (acm->dev) {
  521. usb_autopm_get_interface(acm->control);
  522. acm_set_control(acm, acm->ctrlout = 0);
  523. usb_kill_urb(acm->ctrlurb);
  524. for (i = 0; i < ACM_NW; i++)
  525. usb_kill_urb(acm->wb[i].urb);
  526. for (i = 0; i < nr; i++)
  527. usb_kill_urb(acm->ru[i].urb);
  528. acm->control->needs_remote_wakeup = 0;
  529. usb_autopm_put_interface(acm->control);
  530. } else
  531. acm_tty_unregister(acm);
  532. }
  533. mutex_unlock(&open_mutex);
  534. }
  535. static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
  536. {
  537. struct acm *acm = tty->driver_data;
  538. int stat;
  539. unsigned long flags;
  540. int wbn;
  541. struct acm_wb *wb;
  542. dbg("Entering acm_tty_write to write %d bytes,", count);
  543. if (!ACM_READY(acm))
  544. return -EINVAL;
  545. if (!count)
  546. return 0;
  547. spin_lock_irqsave(&acm->write_lock, flags);
  548. if ((wbn = acm_wb_alloc(acm)) < 0) {
  549. spin_unlock_irqrestore(&acm->write_lock, flags);
  550. return 0;
  551. }
  552. wb = &acm->wb[wbn];
  553. count = (count > acm->writesize) ? acm->writesize : count;
  554. dbg("Get %d bytes...", count);
  555. memcpy(wb->buf, buf, count);
  556. wb->len = count;
  557. spin_unlock_irqrestore(&acm->write_lock, flags);
  558. if ((stat = acm_write_start(acm, wbn)) < 0)
  559. return stat;
  560. return count;
  561. }
  562. static int acm_tty_write_room(struct tty_struct *tty)
  563. {
  564. struct acm *acm = tty->driver_data;
  565. if (!ACM_READY(acm))
  566. return -EINVAL;
  567. /*
  568. * Do not let the line discipline to know that we have a reserve,
  569. * or it might get too enthusiastic.
  570. */
  571. return acm_wb_is_avail(acm) ? acm->writesize : 0;
  572. }
  573. static int acm_tty_chars_in_buffer(struct tty_struct *tty)
  574. {
  575. struct acm *acm = tty->driver_data;
  576. if (!ACM_READY(acm))
  577. return -EINVAL;
  578. /*
  579. * This is inaccurate (overcounts), but it works.
  580. */
  581. return (ACM_NW - acm_wb_is_avail(acm)) * acm->writesize;
  582. }
  583. static void acm_tty_throttle(struct tty_struct *tty)
  584. {
  585. struct acm *acm = tty->driver_data;
  586. if (!ACM_READY(acm))
  587. return;
  588. spin_lock_bh(&acm->throttle_lock);
  589. acm->throttle = 1;
  590. spin_unlock_bh(&acm->throttle_lock);
  591. }
  592. static void acm_tty_unthrottle(struct tty_struct *tty)
  593. {
  594. struct acm *acm = tty->driver_data;
  595. if (!ACM_READY(acm))
  596. return;
  597. spin_lock_bh(&acm->throttle_lock);
  598. acm->throttle = 0;
  599. spin_unlock_bh(&acm->throttle_lock);
  600. tasklet_schedule(&acm->urb_task);
  601. }
  602. static int acm_tty_break_ctl(struct tty_struct *tty, int state)
  603. {
  604. struct acm *acm = tty->driver_data;
  605. int retval;
  606. if (!ACM_READY(acm))
  607. return -EINVAL;
  608. retval = acm_send_break(acm, state ? 0xffff : 0);
  609. if (retval < 0)
  610. dbg("send break failed");
  611. return retval;
  612. }
  613. static int acm_tty_tiocmget(struct tty_struct *tty, struct file *file)
  614. {
  615. struct acm *acm = tty->driver_data;
  616. if (!ACM_READY(acm))
  617. return -EINVAL;
  618. return (acm->ctrlout & ACM_CTRL_DTR ? TIOCM_DTR : 0) |
  619. (acm->ctrlout & ACM_CTRL_RTS ? TIOCM_RTS : 0) |
  620. (acm->ctrlin & ACM_CTRL_DSR ? TIOCM_DSR : 0) |
  621. (acm->ctrlin & ACM_CTRL_RI ? TIOCM_RI : 0) |
  622. (acm->ctrlin & ACM_CTRL_DCD ? TIOCM_CD : 0) |
  623. TIOCM_CTS;
  624. }
  625. static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
  626. unsigned int set, unsigned int clear)
  627. {
  628. struct acm *acm = tty->driver_data;
  629. unsigned int newctrl;
  630. if (!ACM_READY(acm))
  631. return -EINVAL;
  632. newctrl = acm->ctrlout;
  633. set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
  634. clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
  635. newctrl = (newctrl & ~clear) | set;
  636. if (acm->ctrlout == newctrl)
  637. return 0;
  638. return acm_set_control(acm, acm->ctrlout = newctrl);
  639. }
  640. static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
  641. {
  642. struct acm *acm = tty->driver_data;
  643. if (!ACM_READY(acm))
  644. return -EINVAL;
  645. return -ENOIOCTLCMD;
  646. }
  647. static const __u32 acm_tty_speed[] = {
  648. 0, 50, 75, 110, 134, 150, 200, 300, 600,
  649. 1200, 1800, 2400, 4800, 9600, 19200, 38400,
  650. 57600, 115200, 230400, 460800, 500000, 576000,
  651. 921600, 1000000, 1152000, 1500000, 2000000,
  652. 2500000, 3000000, 3500000, 4000000
  653. };
  654. static const __u8 acm_tty_size[] = {
  655. 5, 6, 7, 8
  656. };
  657. static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
  658. {
  659. struct acm *acm = tty->driver_data;
  660. struct ktermios *termios = tty->termios;
  661. struct usb_cdc_line_coding newline;
  662. int newctrl = acm->ctrlout;
  663. if (!ACM_READY(acm))
  664. return;
  665. newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
  666. (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
  667. newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
  668. newline.bParityType = termios->c_cflag & PARENB ?
  669. (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
  670. newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
  671. acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
  672. if (!newline.dwDTERate) {
  673. newline.dwDTERate = acm->line.dwDTERate;
  674. newctrl &= ~ACM_CTRL_DTR;
  675. } else newctrl |= ACM_CTRL_DTR;
  676. if (newctrl != acm->ctrlout)
  677. acm_set_control(acm, acm->ctrlout = newctrl);
  678. if (memcmp(&acm->line, &newline, sizeof newline)) {
  679. memcpy(&acm->line, &newline, sizeof newline);
  680. dbg("set line: %d %d %d %d", le32_to_cpu(newline.dwDTERate),
  681. newline.bCharFormat, newline.bParityType,
  682. newline.bDataBits);
  683. acm_set_line(acm, &acm->line);
  684. }
  685. }
  686. /*
  687. * USB probe and disconnect routines.
  688. */
  689. /* Little helpers: write/read buffers free */
  690. static void acm_write_buffers_free(struct acm *acm)
  691. {
  692. int i;
  693. struct acm_wb *wb;
  694. for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
  695. usb_buffer_free(acm->dev, acm->writesize, wb->buf, wb->dmah);
  696. }
  697. }
  698. static void acm_read_buffers_free(struct acm *acm)
  699. {
  700. struct usb_device *usb_dev = interface_to_usbdev(acm->control);
  701. int i, n = acm->rx_buflimit;
  702. for (i = 0; i < n; i++)
  703. usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
  704. }
  705. /* Little helper: write buffers allocate */
  706. static int acm_write_buffers_alloc(struct acm *acm)
  707. {
  708. int i;
  709. struct acm_wb *wb;
  710. for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
  711. wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL,
  712. &wb->dmah);
  713. if (!wb->buf) {
  714. while (i != 0) {
  715. --i;
  716. --wb;
  717. usb_buffer_free(acm->dev, acm->writesize,
  718. wb->buf, wb->dmah);
  719. }
  720. return -ENOMEM;
  721. }
  722. }
  723. return 0;
  724. }
  725. static int acm_probe (struct usb_interface *intf,
  726. const struct usb_device_id *id)
  727. {
  728. struct usb_cdc_union_desc *union_header = NULL;
  729. struct usb_cdc_country_functional_desc *cfd = NULL;
  730. unsigned char *buffer = intf->altsetting->extra;
  731. int buflen = intf->altsetting->extralen;
  732. struct usb_interface *control_interface;
  733. struct usb_interface *data_interface;
  734. struct usb_endpoint_descriptor *epctrl;
  735. struct usb_endpoint_descriptor *epread;
  736. struct usb_endpoint_descriptor *epwrite;
  737. struct usb_device *usb_dev = interface_to_usbdev(intf);
  738. struct acm *acm;
  739. int minor;
  740. int ctrlsize,readsize;
  741. u8 *buf;
  742. u8 ac_management_function = 0;
  743. u8 call_management_function = 0;
  744. int call_interface_num = -1;
  745. int data_interface_num;
  746. unsigned long quirks;
  747. int num_rx_buf;
  748. int i;
  749. /* normal quirks */
  750. quirks = (unsigned long)id->driver_info;
  751. num_rx_buf = (quirks == SINGLE_RX_URB) ? 1 : ACM_NR;
  752. /* handle quirks deadly to normal probing*/
  753. if (quirks == NO_UNION_NORMAL) {
  754. data_interface = usb_ifnum_to_if(usb_dev, 1);
  755. control_interface = usb_ifnum_to_if(usb_dev, 0);
  756. goto skip_normal_probe;
  757. }
  758. /* normal probing*/
  759. if (!buffer) {
  760. err("Weird descriptor references\n");
  761. return -EINVAL;
  762. }
  763. if (!buflen) {
  764. if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
  765. dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
  766. buflen = intf->cur_altsetting->endpoint->extralen;
  767. buffer = intf->cur_altsetting->endpoint->extra;
  768. } else {
  769. err("Zero length descriptor references\n");
  770. return -EINVAL;
  771. }
  772. }
  773. while (buflen > 0) {
  774. if (buffer [1] != USB_DT_CS_INTERFACE) {
  775. err("skipping garbage\n");
  776. goto next_desc;
  777. }
  778. switch (buffer [2]) {
  779. case USB_CDC_UNION_TYPE: /* we've found it */
  780. if (union_header) {
  781. err("More than one union descriptor, skipping ...");
  782. goto next_desc;
  783. }
  784. union_header = (struct usb_cdc_union_desc *)
  785. buffer;
  786. break;
  787. case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
  788. cfd = (struct usb_cdc_country_functional_desc *)buffer;
  789. break;
  790. case USB_CDC_HEADER_TYPE: /* maybe check version */
  791. break; /* for now we ignore it */
  792. case USB_CDC_ACM_TYPE:
  793. ac_management_function = buffer[3];
  794. break;
  795. case USB_CDC_CALL_MANAGEMENT_TYPE:
  796. call_management_function = buffer[3];
  797. call_interface_num = buffer[4];
  798. if ((call_management_function & 3) != 3)
  799. err("This device cannot do calls on its own. It is no modem.");
  800. break;
  801. default:
  802. /* there are LOTS more CDC descriptors that
  803. * could legitimately be found here.
  804. */
  805. dev_dbg(&intf->dev, "Ignoring descriptor: "
  806. "type %02x, length %d\n",
  807. buffer[2], buffer[0]);
  808. break;
  809. }
  810. next_desc:
  811. buflen -= buffer[0];
  812. buffer += buffer[0];
  813. }
  814. if (!union_header) {
  815. if (call_interface_num > 0) {
  816. dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
  817. data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
  818. control_interface = intf;
  819. } else {
  820. dev_dbg(&intf->dev,"No union descriptor, giving up\n");
  821. return -ENODEV;
  822. }
  823. } else {
  824. control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
  825. data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
  826. if (!control_interface || !data_interface) {
  827. dev_dbg(&intf->dev,"no interfaces\n");
  828. return -ENODEV;
  829. }
  830. }
  831. if (data_interface_num != call_interface_num)
  832. dev_dbg(&intf->dev,"Separate call control interface. That is not fully supported.\n");
  833. skip_normal_probe:
  834. /*workaround for switched interfaces */
  835. if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
  836. if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
  837. struct usb_interface *t;
  838. dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
  839. t = control_interface;
  840. control_interface = data_interface;
  841. data_interface = t;
  842. } else {
  843. return -EINVAL;
  844. }
  845. }
  846. /* Accept probe requests only for the control interface */
  847. if (intf != control_interface)
  848. return -ENODEV;
  849. if (usb_interface_claimed(data_interface)) { /* valid in this context */
  850. dev_dbg(&intf->dev,"The data interface isn't available\n");
  851. return -EBUSY;
  852. }
  853. if (data_interface->cur_altsetting->desc.bNumEndpoints < 2)
  854. return -EINVAL;
  855. epctrl = &control_interface->cur_altsetting->endpoint[0].desc;
  856. epread = &data_interface->cur_altsetting->endpoint[0].desc;
  857. epwrite = &data_interface->cur_altsetting->endpoint[1].desc;
  858. /* workaround for switched endpoints */
  859. if (!usb_endpoint_dir_in(epread)) {
  860. /* descriptors are swapped */
  861. struct usb_endpoint_descriptor *t;
  862. dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
  863. t = epread;
  864. epread = epwrite;
  865. epwrite = t;
  866. }
  867. dbg("interfaces are valid");
  868. for (minor = 0; minor < ACM_TTY_MINORS && acm_table[minor]; minor++);
  869. if (minor == ACM_TTY_MINORS) {
  870. err("no more free acm devices");
  871. return -ENODEV;
  872. }
  873. if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
  874. dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
  875. goto alloc_fail;
  876. }
  877. ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
  878. readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
  879. acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
  880. acm->control = control_interface;
  881. acm->data = data_interface;
  882. acm->minor = minor;
  883. acm->dev = usb_dev;
  884. acm->ctrl_caps = ac_management_function;
  885. acm->ctrlsize = ctrlsize;
  886. acm->readsize = readsize;
  887. acm->rx_buflimit = num_rx_buf;
  888. acm->urb_task.func = acm_rx_tasklet;
  889. acm->urb_task.data = (unsigned long) acm;
  890. INIT_WORK(&acm->work, acm_softint);
  891. INIT_WORK(&acm->waker, acm_waker);
  892. spin_lock_init(&acm->throttle_lock);
  893. spin_lock_init(&acm->write_lock);
  894. spin_lock_init(&acm->read_lock);
  895. mutex_init(&acm->mutex);
  896. acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
  897. buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
  898. if (!buf) {
  899. dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n");
  900. goto alloc_fail2;
  901. }
  902. acm->ctrl_buffer = buf;
  903. if (acm_write_buffers_alloc(acm) < 0) {
  904. dev_dbg(&intf->dev, "out of memory (write buffer alloc)\n");
  905. goto alloc_fail4;
  906. }
  907. acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
  908. if (!acm->ctrlurb) {
  909. dev_dbg(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
  910. goto alloc_fail5;
  911. }
  912. for (i = 0; i < num_rx_buf; i++) {
  913. struct acm_ru *rcv = &(acm->ru[i]);
  914. if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
  915. dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
  916. goto alloc_fail7;
  917. }
  918. rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  919. rcv->instance = acm;
  920. }
  921. for (i = 0; i < num_rx_buf; i++) {
  922. struct acm_rb *rb = &(acm->rb[i]);
  923. rb->base = usb_buffer_alloc(acm->dev, readsize,
  924. GFP_KERNEL, &rb->dma);
  925. if (!rb->base) {
  926. dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
  927. goto alloc_fail7;
  928. }
  929. }
  930. for(i = 0; i < ACM_NW; i++)
  931. {
  932. struct acm_wb *snd = &(acm->wb[i]);
  933. if (!(snd->urb = usb_alloc_urb(0, GFP_KERNEL))) {
  934. dev_dbg(&intf->dev, "out of memory (write urbs usb_alloc_urb)");
  935. goto alloc_fail7;
  936. }
  937. usb_fill_bulk_urb(snd->urb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
  938. NULL, acm->writesize, acm_write_bulk, snd);
  939. snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  940. snd->instance = acm;
  941. }
  942. usb_set_intfdata (intf, acm);
  943. i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
  944. if (i < 0)
  945. goto alloc_fail8;
  946. if (cfd) { /* export the country data */
  947. acm->country_codes = kmalloc(cfd->bLength - 4, GFP_KERNEL);
  948. if (!acm->country_codes)
  949. goto skip_countries;
  950. acm->country_code_size = cfd->bLength - 4;
  951. memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
  952. acm->country_rel_date = cfd->iCountryCodeRelDate;
  953. i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
  954. if (i < 0) {
  955. kfree(acm->country_codes);
  956. goto skip_countries;
  957. }
  958. i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
  959. if (i < 0) {
  960. kfree(acm->country_codes);
  961. goto skip_countries;
  962. }
  963. }
  964. skip_countries:
  965. usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
  966. acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
  967. acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
  968. acm->ctrlurb->transfer_dma = acm->ctrl_dma;
  969. dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
  970. acm_set_control(acm, acm->ctrlout);
  971. acm->line.dwDTERate = cpu_to_le32(9600);
  972. acm->line.bDataBits = 8;
  973. acm_set_line(acm, &acm->line);
  974. usb_driver_claim_interface(&acm_driver, data_interface, acm);
  975. usb_set_intfdata(data_interface, acm);
  976. usb_get_intf(control_interface);
  977. tty_register_device(acm_tty_driver, minor, &control_interface->dev);
  978. acm_table[minor] = acm;
  979. return 0;
  980. alloc_fail8:
  981. for (i = 0; i < ACM_NW; i++)
  982. usb_free_urb(acm->wb[i].urb);
  983. alloc_fail7:
  984. acm_read_buffers_free(acm);
  985. for (i = 0; i < num_rx_buf; i++)
  986. usb_free_urb(acm->ru[i].urb);
  987. usb_free_urb(acm->ctrlurb);
  988. alloc_fail5:
  989. acm_write_buffers_free(acm);
  990. alloc_fail4:
  991. usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
  992. alloc_fail2:
  993. kfree(acm);
  994. alloc_fail:
  995. return -ENOMEM;
  996. }
  997. static void stop_data_traffic(struct acm *acm)
  998. {
  999. int i;
  1000. dbg("Entering stop_data_traffic");
  1001. tasklet_disable(&acm->urb_task);
  1002. usb_kill_urb(acm->ctrlurb);
  1003. for(i = 0; i < ACM_NW; i++)
  1004. usb_kill_urb(acm->wb[i].urb);
  1005. for (i = 0; i < acm->rx_buflimit; i++)
  1006. usb_kill_urb(acm->ru[i].urb);
  1007. tasklet_enable(&acm->urb_task);
  1008. cancel_work_sync(&acm->work);
  1009. cancel_work_sync(&acm->waker);
  1010. }
  1011. static void acm_disconnect(struct usb_interface *intf)
  1012. {
  1013. struct acm *acm = usb_get_intfdata(intf);
  1014. struct usb_device *usb_dev = interface_to_usbdev(intf);
  1015. /* sibling interface is already cleaning up */
  1016. if (!acm)
  1017. return;
  1018. mutex_lock(&open_mutex);
  1019. if (acm->country_codes){
  1020. device_remove_file(&acm->control->dev,
  1021. &dev_attr_wCountryCodes);
  1022. device_remove_file(&acm->control->dev,
  1023. &dev_attr_iCountryCodeRelDate);
  1024. }
  1025. device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
  1026. acm->dev = NULL;
  1027. usb_set_intfdata(acm->control, NULL);
  1028. usb_set_intfdata(acm->data, NULL);
  1029. stop_data_traffic(acm);
  1030. acm_write_buffers_free(acm);
  1031. usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
  1032. acm_read_buffers_free(acm);
  1033. usb_driver_release_interface(&acm_driver, intf == acm->control ?
  1034. acm->data : acm->control);
  1035. if (!acm->used) {
  1036. acm_tty_unregister(acm);
  1037. mutex_unlock(&open_mutex);
  1038. return;
  1039. }
  1040. mutex_unlock(&open_mutex);
  1041. if (acm->tty)
  1042. tty_hangup(acm->tty);
  1043. }
  1044. #ifdef CONFIG_PM
  1045. static int acm_suspend(struct usb_interface *intf, pm_message_t message)
  1046. {
  1047. struct acm *acm = usb_get_intfdata(intf);
  1048. int cnt;
  1049. if (acm->dev->auto_pm) {
  1050. int b;
  1051. spin_lock_irq(&acm->read_lock);
  1052. spin_lock(&acm->write_lock);
  1053. b = acm->processing + acm->transmitting;
  1054. spin_unlock(&acm->write_lock);
  1055. spin_unlock_irq(&acm->read_lock);
  1056. if (b)
  1057. return -EBUSY;
  1058. }
  1059. spin_lock_irq(&acm->read_lock);
  1060. spin_lock(&acm->write_lock);
  1061. cnt = acm->susp_count++;
  1062. spin_unlock(&acm->write_lock);
  1063. spin_unlock_irq(&acm->read_lock);
  1064. if (cnt)
  1065. return 0;
  1066. /*
  1067. we treat opened interfaces differently,
  1068. we must guard against open
  1069. */
  1070. mutex_lock(&acm->mutex);
  1071. if (acm->used)
  1072. stop_data_traffic(acm);
  1073. mutex_unlock(&acm->mutex);
  1074. return 0;
  1075. }
  1076. static int acm_resume(struct usb_interface *intf)
  1077. {
  1078. struct acm *acm = usb_get_intfdata(intf);
  1079. int rv = 0;
  1080. int cnt;
  1081. spin_lock_irq(&acm->read_lock);
  1082. acm->susp_count -= 1;
  1083. cnt = acm->susp_count;
  1084. spin_unlock_irq(&acm->read_lock);
  1085. if (cnt)
  1086. return 0;
  1087. mutex_lock(&acm->mutex);
  1088. if (acm->used) {
  1089. rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
  1090. if (rv < 0)
  1091. goto err_out;
  1092. tasklet_schedule(&acm->urb_task);
  1093. }
  1094. err_out:
  1095. mutex_unlock(&acm->mutex);
  1096. return rv;
  1097. }
  1098. #endif /* CONFIG_PM */
  1099. /*
  1100. * USB driver structure.
  1101. */
  1102. static struct usb_device_id acm_ids[] = {
  1103. /* quirky and broken devices */
  1104. { USB_DEVICE(0x0870, 0x0001), /* Metricom GS Modem */
  1105. .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
  1106. },
  1107. { USB_DEVICE(0x0e8d, 0x0003), /* FIREFLY, MediaTek Inc; andrey.arapov@gmail.com */
  1108. .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
  1109. },
  1110. { USB_DEVICE(0x0482, 0x0203), /* KYOCERA AH-K3001V */
  1111. .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
  1112. },
  1113. { USB_DEVICE(0x079b, 0x000f), /* BT On-Air USB MODEM */
  1114. .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
  1115. },
  1116. { USB_DEVICE(0x0ace, 0x1608), /* ZyDAS 56K USB MODEM */
  1117. .driver_info = SINGLE_RX_URB, /* firmware bug */
  1118. },
  1119. { USB_DEVICE(0x0ace, 0x1611), /* ZyDAS 56K USB MODEM - new version */
  1120. .driver_info = SINGLE_RX_URB, /* firmware bug */
  1121. },
  1122. { USB_DEVICE(0x22b8, 0x7000), /* Motorola Q Phone */
  1123. .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
  1124. },
  1125. { USB_DEVICE(0x0803, 0x3095), /* Zoom Telephonics Model 3095F USB MODEM */
  1126. .driver_info = NO_UNION_NORMAL, /* has no union descriptor */
  1127. },
  1128. /* control interfaces with various AT-command sets */
  1129. { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
  1130. USB_CDC_ACM_PROTO_AT_V25TER) },
  1131. { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
  1132. USB_CDC_ACM_PROTO_AT_PCCA101) },
  1133. { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
  1134. USB_CDC_ACM_PROTO_AT_PCCA101_WAKE) },
  1135. { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
  1136. USB_CDC_ACM_PROTO_AT_GSM) },
  1137. { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
  1138. USB_CDC_ACM_PROTO_AT_3G ) },
  1139. { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
  1140. USB_CDC_ACM_PROTO_AT_CDMA) },
  1141. /* NOTE: COMM/ACM/0xff is likely MSFT RNDIS ... NOT a modem!! */
  1142. { }
  1143. };
  1144. MODULE_DEVICE_TABLE (usb, acm_ids);
  1145. static struct usb_driver acm_driver = {
  1146. .name = "cdc_acm",
  1147. .probe = acm_probe,
  1148. .disconnect = acm_disconnect,
  1149. #ifdef CONFIG_PM
  1150. .suspend = acm_suspend,
  1151. .resume = acm_resume,
  1152. #endif
  1153. .id_table = acm_ids,
  1154. #ifdef CONFIG_PM
  1155. .supports_autosuspend = 1,
  1156. #endif
  1157. };
  1158. /*
  1159. * TTY driver structures.
  1160. */
  1161. static const struct tty_operations acm_ops = {
  1162. .open = acm_tty_open,
  1163. .close = acm_tty_close,
  1164. .write = acm_tty_write,
  1165. .write_room = acm_tty_write_room,
  1166. .ioctl = acm_tty_ioctl,
  1167. .throttle = acm_tty_throttle,
  1168. .unthrottle = acm_tty_unthrottle,
  1169. .chars_in_buffer = acm_tty_chars_in_buffer,
  1170. .break_ctl = acm_tty_break_ctl,
  1171. .set_termios = acm_tty_set_termios,
  1172. .tiocmget = acm_tty_tiocmget,
  1173. .tiocmset = acm_tty_tiocmset,
  1174. };
  1175. /*
  1176. * Init / exit.
  1177. */
  1178. static int __init acm_init(void)
  1179. {
  1180. int retval;
  1181. acm_tty_driver = alloc_tty_driver(ACM_TTY_MINORS);
  1182. if (!acm_tty_driver)
  1183. return -ENOMEM;
  1184. acm_tty_driver->owner = THIS_MODULE,
  1185. acm_tty_driver->driver_name = "acm",
  1186. acm_tty_driver->name = "ttyACM",
  1187. acm_tty_driver->major = ACM_TTY_MAJOR,
  1188. acm_tty_driver->minor_start = 0,
  1189. acm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL,
  1190. acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
  1191. acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
  1192. acm_tty_driver->init_termios = tty_std_termios;
  1193. acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
  1194. tty_set_operations(acm_tty_driver, &acm_ops);
  1195. retval = tty_register_driver(acm_tty_driver);
  1196. if (retval) {
  1197. put_tty_driver(acm_tty_driver);
  1198. return retval;
  1199. }
  1200. retval = usb_register(&acm_driver);
  1201. if (retval) {
  1202. tty_unregister_driver(acm_tty_driver);
  1203. put_tty_driver(acm_tty_driver);
  1204. return retval;
  1205. }
  1206. info(DRIVER_VERSION ":" DRIVER_DESC);
  1207. return 0;
  1208. }
  1209. static void __exit acm_exit(void)
  1210. {
  1211. usb_deregister(&acm_driver);
  1212. tty_unregister_driver(acm_tty_driver);
  1213. put_tty_driver(acm_tty_driver);
  1214. }
  1215. module_init(acm_init);
  1216. module_exit(acm_exit);
  1217. MODULE_AUTHOR( DRIVER_AUTHOR );
  1218. MODULE_DESCRIPTION( DRIVER_DESC );
  1219. MODULE_LICENSE("GPL");