adutux.c 23 KB

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