adutux.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893
  1. /*
  2. * adutux - driver for ADU devices from Ontrak Control Systems
  3. * This is an experimental driver. Use at your own risk.
  4. * This driver is not supported by Ontrak Control Systems.
  5. *
  6. * Copyright (c) 2003 John Homppi (SCO, leave this notice here)
  7. *
  8. * This program is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU General Public License as
  10. * published by the Free Software Foundation; either version 2 of
  11. * the License, or (at your option) any later version.
  12. *
  13. * derived from the Lego USB Tower driver 0.56:
  14. * Copyright (c) 2003 David Glance <davidgsf@sourceforge.net>
  15. * 2001 Juergen Stuber <stuber@loria.fr>
  16. * that was derived from USB Skeleton driver - 0.5
  17. * Copyright (c) 2001 Greg Kroah-Hartman (greg@kroah.com)
  18. *
  19. */
  20. #include <linux/kernel.h>
  21. #include <linux/errno.h>
  22. #include <linux/init.h>
  23. #include <linux/slab.h>
  24. #include <linux/module.h>
  25. #include <linux/usb.h>
  26. #include <linux/mutex.h>
  27. #include <linux/uaccess.h>
  28. #ifdef CONFIG_USB_DEBUG
  29. static int debug = 5;
  30. #else
  31. static int debug = 1;
  32. #endif
  33. /* Use our own dbg macro */
  34. #undef dbg
  35. #define dbg(lvl, format, arg...) \
  36. do { \
  37. if (debug >= lvl) \
  38. printk(KERN_DEBUG "%s: " format "\n", __FILE__, ##arg); \
  39. } while (0)
  40. /* Version Information */
  41. #define DRIVER_VERSION "v0.0.13"
  42. #define DRIVER_AUTHOR "John Homppi"
  43. #define DRIVER_DESC "adutux (see www.ontrak.net)"
  44. /* Module parameters */
  45. module_param(debug, int, S_IRUGO | S_IWUSR);
  46. MODULE_PARM_DESC(debug, "Debug enabled or not");
  47. /* Define these values to match your device */
  48. #define ADU_VENDOR_ID 0x0a07
  49. #define ADU_PRODUCT_ID 0x0064
  50. /* table of devices that work with this driver */
  51. static const struct usb_device_id device_table[] = {
  52. { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID) }, /* ADU100 */
  53. { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+20) }, /* ADU120 */
  54. { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+30) }, /* ADU130 */
  55. { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+100) }, /* ADU200 */
  56. { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+108) }, /* ADU208 */
  57. { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+118) }, /* ADU218 */
  58. { } /* Terminating entry */
  59. };
  60. MODULE_DEVICE_TABLE(usb, device_table);
  61. #ifdef CONFIG_USB_DYNAMIC_MINORS
  62. #define ADU_MINOR_BASE 0
  63. #else
  64. #define ADU_MINOR_BASE 67
  65. #endif
  66. /* we can have up to this number of device plugged in at once */
  67. #define MAX_DEVICES 16
  68. #define COMMAND_TIMEOUT (2*HZ) /* 60 second timeout for a command */
  69. /*
  70. * The locking scheme is a vanilla 3-lock:
  71. * adu_device.buflock: A spinlock, covers what IRQs touch.
  72. * adutux_mutex: A Static lock to cover open_count. It would also cover
  73. * any globals, but we don't have them in 2.6.
  74. * adu_device.mtx: A mutex to hold across sleepers like copy_from_user.
  75. * It covers all of adu_device, except the open_count
  76. * and what .buflock covers.
  77. */
  78. /* Structure to hold all of our device specific stuff */
  79. struct adu_device {
  80. struct mutex mtx;
  81. struct usb_device *udev; /* save off the usb device pointer */
  82. struct usb_interface *interface;
  83. unsigned int minor; /* the starting minor number for this device */
  84. char serial_number[8];
  85. int open_count; /* number of times this port has been opened */
  86. char *read_buffer_primary;
  87. int read_buffer_length;
  88. char *read_buffer_secondary;
  89. int secondary_head;
  90. int secondary_tail;
  91. spinlock_t buflock;
  92. wait_queue_head_t read_wait;
  93. wait_queue_head_t write_wait;
  94. char *interrupt_in_buffer;
  95. struct usb_endpoint_descriptor *interrupt_in_endpoint;
  96. struct urb *interrupt_in_urb;
  97. int read_urb_finished;
  98. char *interrupt_out_buffer;
  99. struct usb_endpoint_descriptor *interrupt_out_endpoint;
  100. struct urb *interrupt_out_urb;
  101. int out_urb_finished;
  102. };
  103. static DEFINE_MUTEX(adutux_mutex);
  104. static struct usb_driver adu_driver;
  105. static void adu_debug_data(int level, const char *function, int size,
  106. const unsigned char *data)
  107. {
  108. int i;
  109. if (debug < level)
  110. return;
  111. printk(KERN_DEBUG "%s: %s - length = %d, data = ",
  112. __FILE__, function, size);
  113. for (i = 0; i < size; ++i)
  114. printk("%.2x ", data[i]);
  115. printk("\n");
  116. }
  117. /**
  118. * adu_abort_transfers
  119. * aborts transfers and frees associated data structures
  120. */
  121. static void adu_abort_transfers(struct adu_device *dev)
  122. {
  123. unsigned long flags;
  124. dbg(2, " %s : enter", __func__);
  125. if (dev->udev == NULL) {
  126. dbg(1, " %s : udev is null", __func__);
  127. goto exit;
  128. }
  129. /* shutdown transfer */
  130. /* XXX Anchor these instead */
  131. spin_lock_irqsave(&dev->buflock, flags);
  132. if (!dev->read_urb_finished) {
  133. spin_unlock_irqrestore(&dev->buflock, flags);
  134. usb_kill_urb(dev->interrupt_in_urb);
  135. } else
  136. spin_unlock_irqrestore(&dev->buflock, flags);
  137. spin_lock_irqsave(&dev->buflock, flags);
  138. if (!dev->out_urb_finished) {
  139. spin_unlock_irqrestore(&dev->buflock, flags);
  140. usb_kill_urb(dev->interrupt_out_urb);
  141. } else
  142. spin_unlock_irqrestore(&dev->buflock, flags);
  143. exit:
  144. dbg(2, " %s : leave", __func__);
  145. }
  146. static void adu_delete(struct adu_device *dev)
  147. {
  148. dbg(2, "%s enter", __func__);
  149. /* free data structures */
  150. usb_free_urb(dev->interrupt_in_urb);
  151. usb_free_urb(dev->interrupt_out_urb);
  152. kfree(dev->read_buffer_primary);
  153. kfree(dev->read_buffer_secondary);
  154. kfree(dev->interrupt_in_buffer);
  155. kfree(dev->interrupt_out_buffer);
  156. kfree(dev);
  157. dbg(2, "%s : leave", __func__);
  158. }
  159. static void adu_interrupt_in_callback(struct urb *urb)
  160. {
  161. struct adu_device *dev = urb->context;
  162. int status = urb->status;
  163. dbg(4, " %s : enter, status %d", __func__, status);
  164. adu_debug_data(5, __func__, urb->actual_length,
  165. urb->transfer_buffer);
  166. spin_lock(&dev->buflock);
  167. if (status != 0) {
  168. if ((status != -ENOENT) && (status != -ECONNRESET) &&
  169. (status != -ESHUTDOWN)) {
  170. dbg(1, " %s : nonzero status received: %d",
  171. __func__, status);
  172. }
  173. goto exit;
  174. }
  175. if (urb->actual_length > 0 && dev->interrupt_in_buffer[0] != 0x00) {
  176. if (dev->read_buffer_length <
  177. (4 * usb_endpoint_maxp(dev->interrupt_in_endpoint)) -
  178. (urb->actual_length)) {
  179. memcpy (dev->read_buffer_primary +
  180. dev->read_buffer_length,
  181. dev->interrupt_in_buffer, urb->actual_length);
  182. dev->read_buffer_length += urb->actual_length;
  183. dbg(2, " %s reading %d ", __func__,
  184. urb->actual_length);
  185. } else {
  186. dbg(1, " %s : read_buffer overflow", __func__);
  187. }
  188. }
  189. exit:
  190. dev->read_urb_finished = 1;
  191. spin_unlock(&dev->buflock);
  192. /* always wake up so we recover from errors */
  193. wake_up_interruptible(&dev->read_wait);
  194. adu_debug_data(5, __func__, urb->actual_length,
  195. urb->transfer_buffer);
  196. dbg(4, " %s : leave, status %d", __func__, status);
  197. }
  198. static void adu_interrupt_out_callback(struct urb *urb)
  199. {
  200. struct adu_device *dev = urb->context;
  201. int status = urb->status;
  202. dbg(4, " %s : enter, status %d", __func__, status);
  203. adu_debug_data(5, __func__, urb->actual_length, urb->transfer_buffer);
  204. if (status != 0) {
  205. if ((status != -ENOENT) &&
  206. (status != -ECONNRESET)) {
  207. dbg(1, " %s :nonzero status received: %d",
  208. __func__, status);
  209. }
  210. goto exit;
  211. }
  212. spin_lock(&dev->buflock);
  213. dev->out_urb_finished = 1;
  214. wake_up(&dev->write_wait);
  215. spin_unlock(&dev->buflock);
  216. exit:
  217. adu_debug_data(5, __func__, urb->actual_length,
  218. urb->transfer_buffer);
  219. dbg(4, " %s : leave, status %d", __func__, status);
  220. }
  221. static int adu_open(struct inode *inode, struct file *file)
  222. {
  223. struct adu_device *dev = NULL;
  224. struct usb_interface *interface;
  225. int subminor;
  226. int retval;
  227. dbg(2, "%s : enter", __func__);
  228. subminor = iminor(inode);
  229. retval = mutex_lock_interruptible(&adutux_mutex);
  230. if (retval) {
  231. dbg(2, "%s : mutex lock failed", __func__);
  232. goto exit_no_lock;
  233. }
  234. interface = usb_find_interface(&adu_driver, subminor);
  235. if (!interface) {
  236. printk(KERN_ERR "adutux: %s - error, can't find device for "
  237. "minor %d\n", __func__, subminor);
  238. retval = -ENODEV;
  239. goto exit_no_device;
  240. }
  241. dev = usb_get_intfdata(interface);
  242. if (!dev || !dev->udev) {
  243. retval = -ENODEV;
  244. goto exit_no_device;
  245. }
  246. /* check that nobody else is using the device */
  247. if (dev->open_count) {
  248. retval = -EBUSY;
  249. goto exit_no_device;
  250. }
  251. ++dev->open_count;
  252. dbg(2, "%s : open count %d", __func__, dev->open_count);
  253. /* save device in the file's private structure */
  254. file->private_data = dev;
  255. /* initialize in direction */
  256. dev->read_buffer_length = 0;
  257. /* fixup first read by having urb waiting for it */
  258. usb_fill_int_urb(dev->interrupt_in_urb, dev->udev,
  259. usb_rcvintpipe(dev->udev,
  260. dev->interrupt_in_endpoint->bEndpointAddress),
  261. dev->interrupt_in_buffer,
  262. usb_endpoint_maxp(dev->interrupt_in_endpoint),
  263. adu_interrupt_in_callback, dev,
  264. dev->interrupt_in_endpoint->bInterval);
  265. dev->read_urb_finished = 0;
  266. if (usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL))
  267. dev->read_urb_finished = 1;
  268. /* we ignore failure */
  269. /* end of fixup for first read */
  270. /* initialize out direction */
  271. dev->out_urb_finished = 1;
  272. retval = 0;
  273. exit_no_device:
  274. mutex_unlock(&adutux_mutex);
  275. exit_no_lock:
  276. dbg(2, "%s : leave, return value %d ", __func__, retval);
  277. return retval;
  278. }
  279. static void adu_release_internal(struct adu_device *dev)
  280. {
  281. dbg(2, " %s : enter", __func__);
  282. /* decrement our usage count for the device */
  283. --dev->open_count;
  284. dbg(2, " %s : open count %d", __func__, dev->open_count);
  285. if (dev->open_count <= 0) {
  286. adu_abort_transfers(dev);
  287. dev->open_count = 0;
  288. }
  289. dbg(2, " %s : leave", __func__);
  290. }
  291. static int adu_release(struct inode *inode, struct file *file)
  292. {
  293. struct adu_device *dev;
  294. int retval = 0;
  295. dbg(2, " %s : enter", __func__);
  296. if (file == NULL) {
  297. dbg(1, " %s : file is NULL", __func__);
  298. retval = -ENODEV;
  299. goto exit;
  300. }
  301. dev = file->private_data;
  302. if (dev == NULL) {
  303. dbg(1, " %s : object is NULL", __func__);
  304. retval = -ENODEV;
  305. goto exit;
  306. }
  307. mutex_lock(&adutux_mutex); /* not interruptible */
  308. if (dev->open_count <= 0) {
  309. dbg(1, " %s : device not opened", __func__);
  310. retval = -ENODEV;
  311. goto unlock;
  312. }
  313. adu_release_internal(dev);
  314. if (dev->udev == NULL) {
  315. /* the device was unplugged before the file was released */
  316. if (!dev->open_count) /* ... and we're the last user */
  317. adu_delete(dev);
  318. }
  319. unlock:
  320. mutex_unlock(&adutux_mutex);
  321. exit:
  322. dbg(2, " %s : leave, return value %d", __func__, retval);
  323. return retval;
  324. }
  325. static ssize_t adu_read(struct file *file, __user char *buffer, size_t count,
  326. loff_t *ppos)
  327. {
  328. struct adu_device *dev;
  329. size_t bytes_read = 0;
  330. size_t bytes_to_read = count;
  331. int i;
  332. int retval = 0;
  333. int timeout = 0;
  334. int should_submit = 0;
  335. unsigned long flags;
  336. DECLARE_WAITQUEUE(wait, current);
  337. dbg(2, " %s : enter, count = %Zd, file=%p", __func__, count, file);
  338. dev = file->private_data;
  339. dbg(2, " %s : dev=%p", __func__, dev);
  340. if (mutex_lock_interruptible(&dev->mtx))
  341. return -ERESTARTSYS;
  342. /* verify that the device wasn't unplugged */
  343. if (dev->udev == NULL) {
  344. retval = -ENODEV;
  345. printk(KERN_ERR "adutux: No device or device unplugged %d\n",
  346. retval);
  347. goto exit;
  348. }
  349. /* verify that some data was requested */
  350. if (count == 0) {
  351. dbg(1, " %s : read request of 0 bytes", __func__);
  352. goto exit;
  353. }
  354. timeout = COMMAND_TIMEOUT;
  355. dbg(2, " %s : about to start looping", __func__);
  356. while (bytes_to_read) {
  357. int data_in_secondary = dev->secondary_tail - dev->secondary_head;
  358. dbg(2, " %s : while, data_in_secondary=%d, status=%d",
  359. __func__, data_in_secondary,
  360. dev->interrupt_in_urb->status);
  361. if (data_in_secondary) {
  362. /* drain secondary buffer */
  363. int amount = bytes_to_read < data_in_secondary ? bytes_to_read : data_in_secondary;
  364. i = copy_to_user(buffer, dev->read_buffer_secondary+dev->secondary_head, amount);
  365. if (i) {
  366. retval = -EFAULT;
  367. goto exit;
  368. }
  369. dev->secondary_head += (amount - i);
  370. bytes_read += (amount - i);
  371. bytes_to_read -= (amount - i);
  372. if (i) {
  373. retval = bytes_read ? bytes_read : -EFAULT;
  374. goto exit;
  375. }
  376. } else {
  377. /* we check the primary buffer */
  378. spin_lock_irqsave (&dev->buflock, flags);
  379. if (dev->read_buffer_length) {
  380. /* we secure access to the primary */
  381. char *tmp;
  382. dbg(2, " %s : swap, read_buffer_length = %d",
  383. __func__, dev->read_buffer_length);
  384. tmp = dev->read_buffer_secondary;
  385. dev->read_buffer_secondary = dev->read_buffer_primary;
  386. dev->read_buffer_primary = tmp;
  387. dev->secondary_head = 0;
  388. dev->secondary_tail = dev->read_buffer_length;
  389. dev->read_buffer_length = 0;
  390. spin_unlock_irqrestore(&dev->buflock, flags);
  391. /* we have a free buffer so use it */
  392. should_submit = 1;
  393. } else {
  394. /* even the primary was empty - we may need to do IO */
  395. if (!dev->read_urb_finished) {
  396. /* somebody is doing IO */
  397. spin_unlock_irqrestore(&dev->buflock, flags);
  398. dbg(2, " %s : submitted already", __func__);
  399. } else {
  400. /* we must initiate input */
  401. dbg(2, " %s : initiate input", __func__);
  402. dev->read_urb_finished = 0;
  403. spin_unlock_irqrestore(&dev->buflock, flags);
  404. usb_fill_int_urb(dev->interrupt_in_urb, dev->udev,
  405. usb_rcvintpipe(dev->udev,
  406. dev->interrupt_in_endpoint->bEndpointAddress),
  407. dev->interrupt_in_buffer,
  408. usb_endpoint_maxp(dev->interrupt_in_endpoint),
  409. adu_interrupt_in_callback,
  410. dev,
  411. dev->interrupt_in_endpoint->bInterval);
  412. retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
  413. if (retval) {
  414. dev->read_urb_finished = 1;
  415. if (retval == -ENOMEM) {
  416. retval = bytes_read ? bytes_read : -ENOMEM;
  417. }
  418. dbg(2, " %s : submit failed", __func__);
  419. goto exit;
  420. }
  421. }
  422. /* we wait for I/O to complete */
  423. set_current_state(TASK_INTERRUPTIBLE);
  424. add_wait_queue(&dev->read_wait, &wait);
  425. spin_lock_irqsave(&dev->buflock, flags);
  426. if (!dev->read_urb_finished) {
  427. spin_unlock_irqrestore(&dev->buflock, flags);
  428. timeout = schedule_timeout(COMMAND_TIMEOUT);
  429. } else {
  430. spin_unlock_irqrestore(&dev->buflock, flags);
  431. set_current_state(TASK_RUNNING);
  432. }
  433. remove_wait_queue(&dev->read_wait, &wait);
  434. if (timeout <= 0) {
  435. dbg(2, " %s : timeout", __func__);
  436. retval = bytes_read ? bytes_read : -ETIMEDOUT;
  437. goto exit;
  438. }
  439. if (signal_pending(current)) {
  440. dbg(2, " %s : signal pending", __func__);
  441. retval = bytes_read ? bytes_read : -EINTR;
  442. goto exit;
  443. }
  444. }
  445. }
  446. }
  447. retval = bytes_read;
  448. /* if the primary buffer is empty then use it */
  449. spin_lock_irqsave(&dev->buflock, flags);
  450. if (should_submit && dev->read_urb_finished) {
  451. dev->read_urb_finished = 0;
  452. spin_unlock_irqrestore(&dev->buflock, flags);
  453. usb_fill_int_urb(dev->interrupt_in_urb, dev->udev,
  454. usb_rcvintpipe(dev->udev,
  455. dev->interrupt_in_endpoint->bEndpointAddress),
  456. dev->interrupt_in_buffer,
  457. usb_endpoint_maxp(dev->interrupt_in_endpoint),
  458. adu_interrupt_in_callback,
  459. dev,
  460. dev->interrupt_in_endpoint->bInterval);
  461. if (usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL) != 0)
  462. dev->read_urb_finished = 1;
  463. /* we ignore failure */
  464. } else {
  465. spin_unlock_irqrestore(&dev->buflock, flags);
  466. }
  467. exit:
  468. /* unlock the device */
  469. mutex_unlock(&dev->mtx);
  470. dbg(2, " %s : leave, return value %d", __func__, retval);
  471. return retval;
  472. }
  473. static ssize_t adu_write(struct file *file, const __user char *buffer,
  474. size_t count, loff_t *ppos)
  475. {
  476. DECLARE_WAITQUEUE(waita, current);
  477. struct adu_device *dev;
  478. size_t bytes_written = 0;
  479. size_t bytes_to_write;
  480. size_t buffer_size;
  481. unsigned long flags;
  482. int retval;
  483. dbg(2, " %s : enter, count = %Zd", __func__, count);
  484. dev = file->private_data;
  485. retval = mutex_lock_interruptible(&dev->mtx);
  486. if (retval)
  487. goto exit_nolock;
  488. /* verify that the device wasn't unplugged */
  489. if (dev->udev == NULL) {
  490. retval = -ENODEV;
  491. printk(KERN_ERR "adutux: No device or device unplugged %d\n",
  492. retval);
  493. goto exit;
  494. }
  495. /* verify that we actually have some data to write */
  496. if (count == 0) {
  497. dbg(1, " %s : write request of 0 bytes", __func__);
  498. goto exit;
  499. }
  500. while (count > 0) {
  501. add_wait_queue(&dev->write_wait, &waita);
  502. set_current_state(TASK_INTERRUPTIBLE);
  503. spin_lock_irqsave(&dev->buflock, flags);
  504. if (!dev->out_urb_finished) {
  505. spin_unlock_irqrestore(&dev->buflock, flags);
  506. mutex_unlock(&dev->mtx);
  507. if (signal_pending(current)) {
  508. dbg(1, " %s : interrupted", __func__);
  509. set_current_state(TASK_RUNNING);
  510. retval = -EINTR;
  511. goto exit_onqueue;
  512. }
  513. if (schedule_timeout(COMMAND_TIMEOUT) == 0) {
  514. dbg(1, "%s - command timed out.", __func__);
  515. retval = -ETIMEDOUT;
  516. goto exit_onqueue;
  517. }
  518. remove_wait_queue(&dev->write_wait, &waita);
  519. retval = mutex_lock_interruptible(&dev->mtx);
  520. if (retval) {
  521. retval = bytes_written ? bytes_written : retval;
  522. goto exit_nolock;
  523. }
  524. dbg(4, " %s : in progress, count = %Zd", __func__, count);
  525. } else {
  526. spin_unlock_irqrestore(&dev->buflock, flags);
  527. set_current_state(TASK_RUNNING);
  528. remove_wait_queue(&dev->write_wait, &waita);
  529. dbg(4, " %s : sending, count = %Zd", __func__, count);
  530. /* write the data into interrupt_out_buffer from userspace */
  531. buffer_size = usb_endpoint_maxp(dev->interrupt_out_endpoint);
  532. bytes_to_write = count > buffer_size ? buffer_size : count;
  533. dbg(4, " %s : buffer_size = %Zd, count = %Zd, bytes_to_write = %Zd",
  534. __func__, buffer_size, count, bytes_to_write);
  535. if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) {
  536. retval = -EFAULT;
  537. goto exit;
  538. }
  539. /* send off the urb */
  540. usb_fill_int_urb(
  541. dev->interrupt_out_urb,
  542. dev->udev,
  543. usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),
  544. dev->interrupt_out_buffer,
  545. bytes_to_write,
  546. adu_interrupt_out_callback,
  547. dev,
  548. dev->interrupt_out_endpoint->bInterval);
  549. dev->interrupt_out_urb->actual_length = bytes_to_write;
  550. dev->out_urb_finished = 0;
  551. retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
  552. if (retval < 0) {
  553. dev->out_urb_finished = 1;
  554. dev_err(&dev->udev->dev, "Couldn't submit "
  555. "interrupt_out_urb %d\n", retval);
  556. goto exit;
  557. }
  558. buffer += bytes_to_write;
  559. count -= bytes_to_write;
  560. bytes_written += bytes_to_write;
  561. }
  562. }
  563. mutex_unlock(&dev->mtx);
  564. return bytes_written;
  565. exit:
  566. mutex_unlock(&dev->mtx);
  567. exit_nolock:
  568. dbg(2, " %s : leave, return value %d", __func__, retval);
  569. return retval;
  570. exit_onqueue:
  571. remove_wait_queue(&dev->write_wait, &waita);
  572. return retval;
  573. }
  574. /* file operations needed when we register this driver */
  575. static const struct file_operations adu_fops = {
  576. .owner = THIS_MODULE,
  577. .read = adu_read,
  578. .write = adu_write,
  579. .open = adu_open,
  580. .release = adu_release,
  581. .llseek = noop_llseek,
  582. };
  583. /*
  584. * usb class driver info in order to get a minor number from the usb core,
  585. * and to have the device registered with devfs and the driver core
  586. */
  587. static struct usb_class_driver adu_class = {
  588. .name = "usb/adutux%d",
  589. .fops = &adu_fops,
  590. .minor_base = ADU_MINOR_BASE,
  591. };
  592. /**
  593. * adu_probe
  594. *
  595. * Called by the usb core when a new device is connected that it thinks
  596. * this driver might be interested in.
  597. */
  598. static int adu_probe(struct usb_interface *interface,
  599. const struct usb_device_id *id)
  600. {
  601. struct usb_device *udev = interface_to_usbdev(interface);
  602. struct adu_device *dev = NULL;
  603. struct usb_host_interface *iface_desc;
  604. struct usb_endpoint_descriptor *endpoint;
  605. int retval = -ENODEV;
  606. int in_end_size;
  607. int out_end_size;
  608. int i;
  609. dbg(2, " %s : enter", __func__);
  610. if (udev == NULL) {
  611. dev_err(&interface->dev, "udev is NULL.\n");
  612. goto exit;
  613. }
  614. /* allocate memory for our device state and initialize it */
  615. dev = kzalloc(sizeof(struct adu_device), GFP_KERNEL);
  616. if (dev == NULL) {
  617. dev_err(&interface->dev, "Out of memory\n");
  618. retval = -ENOMEM;
  619. goto exit;
  620. }
  621. mutex_init(&dev->mtx);
  622. spin_lock_init(&dev->buflock);
  623. dev->udev = udev;
  624. init_waitqueue_head(&dev->read_wait);
  625. init_waitqueue_head(&dev->write_wait);
  626. iface_desc = &interface->altsetting[0];
  627. /* set up the endpoint information */
  628. for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
  629. endpoint = &iface_desc->endpoint[i].desc;
  630. if (usb_endpoint_is_int_in(endpoint))
  631. dev->interrupt_in_endpoint = endpoint;
  632. if (usb_endpoint_is_int_out(endpoint))
  633. dev->interrupt_out_endpoint = endpoint;
  634. }
  635. if (dev->interrupt_in_endpoint == NULL) {
  636. dev_err(&interface->dev, "interrupt in endpoint not found\n");
  637. goto error;
  638. }
  639. if (dev->interrupt_out_endpoint == NULL) {
  640. dev_err(&interface->dev, "interrupt out endpoint not found\n");
  641. goto error;
  642. }
  643. in_end_size = usb_endpoint_maxp(dev->interrupt_in_endpoint);
  644. out_end_size = usb_endpoint_maxp(dev->interrupt_out_endpoint);
  645. dev->read_buffer_primary = kmalloc((4 * in_end_size), GFP_KERNEL);
  646. if (!dev->read_buffer_primary) {
  647. dev_err(&interface->dev, "Couldn't allocate read_buffer_primary\n");
  648. retval = -ENOMEM;
  649. goto error;
  650. }
  651. /* debug code prime the buffer */
  652. memset(dev->read_buffer_primary, 'a', in_end_size);
  653. memset(dev->read_buffer_primary + in_end_size, 'b', in_end_size);
  654. memset(dev->read_buffer_primary + (2 * in_end_size), 'c', in_end_size);
  655. memset(dev->read_buffer_primary + (3 * in_end_size), 'd', in_end_size);
  656. dev->read_buffer_secondary = kmalloc((4 * in_end_size), GFP_KERNEL);
  657. if (!dev->read_buffer_secondary) {
  658. dev_err(&interface->dev, "Couldn't allocate read_buffer_secondary\n");
  659. retval = -ENOMEM;
  660. goto error;
  661. }
  662. /* debug code prime the buffer */
  663. memset(dev->read_buffer_secondary, 'e', in_end_size);
  664. memset(dev->read_buffer_secondary + in_end_size, 'f', in_end_size);
  665. memset(dev->read_buffer_secondary + (2 * in_end_size), 'g', in_end_size);
  666. memset(dev->read_buffer_secondary + (3 * in_end_size), 'h', in_end_size);
  667. dev->interrupt_in_buffer = kmalloc(in_end_size, GFP_KERNEL);
  668. if (!dev->interrupt_in_buffer) {
  669. dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
  670. goto error;
  671. }
  672. /* debug code prime the buffer */
  673. memset(dev->interrupt_in_buffer, 'i', in_end_size);
  674. dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
  675. if (!dev->interrupt_in_urb) {
  676. dev_err(&interface->dev, "Couldn't allocate interrupt_in_urb\n");
  677. goto error;
  678. }
  679. dev->interrupt_out_buffer = kmalloc(out_end_size, GFP_KERNEL);
  680. if (!dev->interrupt_out_buffer) {
  681. dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n");
  682. goto error;
  683. }
  684. dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
  685. if (!dev->interrupt_out_urb) {
  686. dev_err(&interface->dev, "Couldn't allocate interrupt_out_urb\n");
  687. goto error;
  688. }
  689. if (!usb_string(udev, udev->descriptor.iSerialNumber, dev->serial_number,
  690. sizeof(dev->serial_number))) {
  691. dev_err(&interface->dev, "Could not retrieve serial number\n");
  692. goto error;
  693. }
  694. dbg(2, " %s : serial_number=%s", __func__, dev->serial_number);
  695. /* we can register the device now, as it is ready */
  696. usb_set_intfdata(interface, dev);
  697. retval = usb_register_dev(interface, &adu_class);
  698. if (retval) {
  699. /* something prevented us from registering this driver */
  700. dev_err(&interface->dev, "Not able to get a minor for this device.\n");
  701. usb_set_intfdata(interface, NULL);
  702. goto error;
  703. }
  704. dev->minor = interface->minor;
  705. /* let the user know what node this device is now attached to */
  706. dev_info(&interface->dev, "ADU%d %s now attached to /dev/usb/adutux%d\n",
  707. udev->descriptor.idProduct, dev->serial_number,
  708. (dev->minor - ADU_MINOR_BASE));
  709. exit:
  710. dbg(2, " %s : leave, return value %p (dev)", __func__, dev);
  711. return retval;
  712. error:
  713. adu_delete(dev);
  714. return retval;
  715. }
  716. /**
  717. * adu_disconnect
  718. *
  719. * Called by the usb core when the device is removed from the system.
  720. */
  721. static void adu_disconnect(struct usb_interface *interface)
  722. {
  723. struct adu_device *dev;
  724. int minor;
  725. dbg(2, " %s : enter", __func__);
  726. dev = usb_get_intfdata(interface);
  727. mutex_lock(&dev->mtx); /* not interruptible */
  728. dev->udev = NULL; /* poison */
  729. minor = dev->minor;
  730. usb_deregister_dev(interface, &adu_class);
  731. mutex_unlock(&dev->mtx);
  732. mutex_lock(&adutux_mutex);
  733. usb_set_intfdata(interface, NULL);
  734. /* if the device is not opened, then we clean up right now */
  735. dbg(2, " %s : open count %d", __func__, dev->open_count);
  736. if (!dev->open_count)
  737. adu_delete(dev);
  738. mutex_unlock(&adutux_mutex);
  739. dev_info(&interface->dev, "ADU device adutux%d now disconnected\n",
  740. (minor - ADU_MINOR_BASE));
  741. dbg(2, " %s : leave", __func__);
  742. }
  743. /* usb specific object needed to register this driver with the usb subsystem */
  744. static struct usb_driver adu_driver = {
  745. .name = "adutux",
  746. .probe = adu_probe,
  747. .disconnect = adu_disconnect,
  748. .id_table = device_table,
  749. };
  750. module_usb_driver(adu_driver);
  751. MODULE_AUTHOR(DRIVER_AUTHOR);
  752. MODULE_DESCRIPTION(DRIVER_DESC);
  753. MODULE_LICENSE("GPL");