mdc800.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * copyright (C) 1999/2000 by Henning Zabel <henning@uni-paderborn.de>
  4. */
  5. /*
  6. * USB-Kernel Driver for the Mustek MDC800 Digital Camera
  7. * (c) 1999/2000 Henning Zabel <henning@uni-paderborn.de>
  8. *
  9. *
  10. * The driver brings the USB functions of the MDC800 to Linux.
  11. * To use the Camera you must support the USB Protocol of the camera
  12. * to the Kernel Node.
  13. * The Driver uses a misc device Node. Create it with :
  14. * mknod /dev/mustek c 180 32
  15. *
  16. * The driver supports only one camera.
  17. *
  18. * Fix: mdc800 used sleep_on and slept with io_lock held.
  19. * Converted sleep_on to waitqueues with schedule_timeout and made io_lock
  20. * a semaphore from a spinlock.
  21. * by Oliver Neukum <oliver@neukum.name>
  22. * (02/12/2001)
  23. *
  24. * Identify version on module load.
  25. * (08/04/2001) gb
  26. *
  27. * version 0.7.5
  28. * Fixed potential SMP races with Spinlocks.
  29. * Thanks to Oliver Neukum <oliver@neukum.name> who
  30. * noticed the race conditions.
  31. * (30/10/2000)
  32. *
  33. * Fixed: Setting urb->dev before submitting urb.
  34. * by Greg KH <greg@kroah.com>
  35. * (13/10/2000)
  36. *
  37. * version 0.7.3
  38. * bugfix : The mdc800->state field gets set to READY after the
  39. * the disconnect function sets it to NOT_CONNECTED. This makes the
  40. * driver running like the camera is connected and causes some
  41. * hang ups.
  42. *
  43. * version 0.7.1
  44. * MOD_INC and MOD_DEC are changed in usb_probe to prevent load/unload
  45. * problems when compiled as Module.
  46. * (04/04/2000)
  47. *
  48. * The mdc800 driver gets assigned the USB Minor 32-47. The Registration
  49. * was updated to use these values.
  50. * (26/03/2000)
  51. *
  52. * The Init und Exit Module Function are updated.
  53. * (01/03/2000)
  54. *
  55. * version 0.7.0
  56. * Rewrite of the driver : The driver now uses URB's. The old stuff
  57. * has been removed.
  58. *
  59. * version 0.6.0
  60. * Rewrite of this driver: The Emulation of the rs232 protocoll
  61. * has been removed from the driver. A special executeCommand function
  62. * for this driver is included to gphoto.
  63. * The driver supports two kind of communication to bulk endpoints.
  64. * Either with the dev->bus->ops->bulk... or with callback function.
  65. * (09/11/1999)
  66. *
  67. * version 0.5.0:
  68. * first Version that gets a version number. Most of the needed
  69. * functions work.
  70. * (20/10/1999)
  71. */
  72. #include <linux/sched/signal.h>
  73. #include <linux/signal.h>
  74. #include <linux/spinlock.h>
  75. #include <linux/errno.h>
  76. #include <linux/random.h>
  77. #include <linux/poll.h>
  78. #include <linux/init.h>
  79. #include <linux/slab.h>
  80. #include <linux/module.h>
  81. #include <linux/wait.h>
  82. #include <linux/mutex.h>
  83. #include <linux/usb.h>
  84. #include <linux/fs.h>
  85. /*
  86. * Version Information
  87. */
  88. #define DRIVER_VERSION "v0.7.5 (30/10/2000)"
  89. #define DRIVER_AUTHOR "Henning Zabel <henning@uni-paderborn.de>"
  90. #define DRIVER_DESC "USB Driver for Mustek MDC800 Digital Camera"
  91. /* Vendor and Product Information */
  92. #define MDC800_VENDOR_ID 0x055f
  93. #define MDC800_PRODUCT_ID 0xa800
  94. /* Timeouts (msec) */
  95. #define TO_DOWNLOAD_GET_READY 1500
  96. #define TO_DOWNLOAD_GET_BUSY 1500
  97. #define TO_WRITE_GET_READY 1000
  98. #define TO_DEFAULT_COMMAND 5000
  99. #define TO_READ_FROM_IRQ TO_DEFAULT_COMMAND
  100. #define TO_GET_READY TO_DEFAULT_COMMAND
  101. /* Minor Number of the device (create with mknod /dev/mustek c 180 32) */
  102. #define MDC800_DEVICE_MINOR_BASE 32
  103. /**************************************************************************
  104. Data and structs
  105. ***************************************************************************/
  106. typedef enum {
  107. NOT_CONNECTED, READY, WORKING, DOWNLOAD
  108. } mdc800_state;
  109. /* Data for the driver */
  110. struct mdc800_data
  111. {
  112. struct usb_device * dev; // Device Data
  113. mdc800_state state;
  114. unsigned int endpoint [4];
  115. struct urb * irq_urb;
  116. wait_queue_head_t irq_wait;
  117. int irq_woken;
  118. char* irq_urb_buffer;
  119. int camera_busy; // is camera busy ?
  120. int camera_request_ready; // Status to synchronize with irq
  121. char camera_response [8]; // last Bytes send after busy
  122. struct urb * write_urb;
  123. char* write_urb_buffer;
  124. wait_queue_head_t write_wait;
  125. int written;
  126. struct urb * download_urb;
  127. char* download_urb_buffer;
  128. wait_queue_head_t download_wait;
  129. int downloaded;
  130. int download_left; // Bytes left to download ?
  131. /* Device Data */
  132. char out [64]; // Answer Buffer
  133. int out_ptr; // Index to the first not readen byte
  134. int out_count; // Bytes in the buffer
  135. int open; // Camera device open ?
  136. struct mutex io_lock; // IO -lock
  137. char in [8]; // Command Input Buffer
  138. int in_count;
  139. int pic_index; // Cache for the Imagesize (-1 for nothing cached )
  140. int pic_len;
  141. int minor;
  142. };
  143. /* Specification of the Endpoints */
  144. static struct usb_endpoint_descriptor mdc800_ed [4] =
  145. {
  146. {
  147. .bLength = 0,
  148. .bDescriptorType = 0,
  149. .bEndpointAddress = 0x01,
  150. .bmAttributes = 0x02,
  151. .wMaxPacketSize = cpu_to_le16(8),
  152. .bInterval = 0,
  153. .bRefresh = 0,
  154. .bSynchAddress = 0,
  155. },
  156. {
  157. .bLength = 0,
  158. .bDescriptorType = 0,
  159. .bEndpointAddress = 0x82,
  160. .bmAttributes = 0x03,
  161. .wMaxPacketSize = cpu_to_le16(8),
  162. .bInterval = 0,
  163. .bRefresh = 0,
  164. .bSynchAddress = 0,
  165. },
  166. {
  167. .bLength = 0,
  168. .bDescriptorType = 0,
  169. .bEndpointAddress = 0x03,
  170. .bmAttributes = 0x02,
  171. .wMaxPacketSize = cpu_to_le16(64),
  172. .bInterval = 0,
  173. .bRefresh = 0,
  174. .bSynchAddress = 0,
  175. },
  176. {
  177. .bLength = 0,
  178. .bDescriptorType = 0,
  179. .bEndpointAddress = 0x84,
  180. .bmAttributes = 0x02,
  181. .wMaxPacketSize = cpu_to_le16(64),
  182. .bInterval = 0,
  183. .bRefresh = 0,
  184. .bSynchAddress = 0,
  185. },
  186. };
  187. /* The Variable used by the driver */
  188. static struct mdc800_data* mdc800;
  189. /***************************************************************************
  190. The USB Part of the driver
  191. ****************************************************************************/
  192. static int mdc800_endpoint_equals (struct usb_endpoint_descriptor *a,struct usb_endpoint_descriptor *b)
  193. {
  194. return (
  195. ( a->bEndpointAddress == b->bEndpointAddress )
  196. && ( a->bmAttributes == b->bmAttributes )
  197. && ( a->wMaxPacketSize == b->wMaxPacketSize )
  198. );
  199. }
  200. /*
  201. * Checks whether the camera responds busy
  202. */
  203. static int mdc800_isBusy (char* ch)
  204. {
  205. int i=0;
  206. while (i<8)
  207. {
  208. if (ch [i] != (char)0x99)
  209. return 0;
  210. i++;
  211. }
  212. return 1;
  213. }
  214. /*
  215. * Checks whether the Camera is ready
  216. */
  217. static int mdc800_isReady (char *ch)
  218. {
  219. int i=0;
  220. while (i<8)
  221. {
  222. if (ch [i] != (char)0xbb)
  223. return 0;
  224. i++;
  225. }
  226. return 1;
  227. }
  228. /*
  229. * USB IRQ Handler for InputLine
  230. */
  231. static void mdc800_usb_irq (struct urb *urb)
  232. {
  233. int data_received=0, wake_up;
  234. unsigned char* b=urb->transfer_buffer;
  235. struct mdc800_data* mdc800=urb->context;
  236. struct device *dev = &mdc800->dev->dev;
  237. int status = urb->status;
  238. if (status >= 0) {
  239. if (mdc800_isBusy (b))
  240. {
  241. if (!mdc800->camera_busy)
  242. {
  243. mdc800->camera_busy=1;
  244. dev_dbg(dev, "gets busy\n");
  245. }
  246. }
  247. else
  248. {
  249. if (mdc800->camera_busy && mdc800_isReady (b))
  250. {
  251. mdc800->camera_busy=0;
  252. dev_dbg(dev, "gets ready\n");
  253. }
  254. }
  255. if (!(mdc800_isBusy (b) || mdc800_isReady (b)))
  256. {
  257. /* Store Data in camera_answer field */
  258. dev_dbg(dev, "%i %i %i %i %i %i %i %i \n",b[0],b[1],b[2],b[3],b[4],b[5],b[6],b[7]);
  259. memcpy (mdc800->camera_response,b,8);
  260. data_received=1;
  261. }
  262. }
  263. wake_up= ( mdc800->camera_request_ready > 0 )
  264. &&
  265. (
  266. ((mdc800->camera_request_ready == 1) && (!mdc800->camera_busy))
  267. ||
  268. ((mdc800->camera_request_ready == 2) && data_received)
  269. ||
  270. ((mdc800->camera_request_ready == 3) && (mdc800->camera_busy))
  271. ||
  272. (status < 0)
  273. );
  274. if (wake_up)
  275. {
  276. mdc800->camera_request_ready=0;
  277. mdc800->irq_woken=1;
  278. wake_up (&mdc800->irq_wait);
  279. }
  280. }
  281. /*
  282. * Waits a while until the irq responds that camera is ready
  283. *
  284. * mode : 0: Wait for camera gets ready
  285. * 1: Wait for receiving data
  286. * 2: Wait for camera gets busy
  287. *
  288. * msec: Time to wait
  289. */
  290. static int mdc800_usb_waitForIRQ (int mode, int msec)
  291. {
  292. mdc800->camera_request_ready=1+mode;
  293. wait_event_timeout(mdc800->irq_wait, mdc800->irq_woken,
  294. msecs_to_jiffies(msec));
  295. mdc800->irq_woken = 0;
  296. if (mdc800->camera_request_ready>0)
  297. {
  298. mdc800->camera_request_ready=0;
  299. dev_err(&mdc800->dev->dev, "timeout waiting for camera.\n");
  300. return -1;
  301. }
  302. if (mdc800->state == NOT_CONNECTED)
  303. {
  304. printk(KERN_WARNING "mdc800: Camera gets disconnected "
  305. "during waiting for irq.\n");
  306. mdc800->camera_request_ready=0;
  307. return -2;
  308. }
  309. return 0;
  310. }
  311. /*
  312. * The write_urb callback function
  313. */
  314. static void mdc800_usb_write_notify (struct urb *urb)
  315. {
  316. struct mdc800_data* mdc800=urb->context;
  317. int status = urb->status;
  318. if (status != 0)
  319. dev_err(&mdc800->dev->dev,
  320. "writing command fails (status=%i)\n", status);
  321. else
  322. mdc800->state=READY;
  323. mdc800->written = 1;
  324. wake_up (&mdc800->write_wait);
  325. }
  326. /*
  327. * The download_urb callback function
  328. */
  329. static void mdc800_usb_download_notify (struct urb *urb)
  330. {
  331. struct mdc800_data* mdc800=urb->context;
  332. int status = urb->status;
  333. if (status == 0) {
  334. /* Fill output buffer with these data */
  335. memcpy (mdc800->out, urb->transfer_buffer, 64);
  336. mdc800->out_count=64;
  337. mdc800->out_ptr=0;
  338. mdc800->download_left-=64;
  339. if (mdc800->download_left == 0)
  340. {
  341. mdc800->state=READY;
  342. }
  343. } else {
  344. dev_err(&mdc800->dev->dev,
  345. "request bytes fails (status:%i)\n", status);
  346. }
  347. mdc800->downloaded = 1;
  348. wake_up (&mdc800->download_wait);
  349. }
  350. /***************************************************************************
  351. Probing for the Camera
  352. ***************************************************************************/
  353. static struct usb_driver mdc800_usb_driver;
  354. static const struct file_operations mdc800_device_ops;
  355. static struct usb_class_driver mdc800_class = {
  356. .name = "mdc800%d",
  357. .fops = &mdc800_device_ops,
  358. .minor_base = MDC800_DEVICE_MINOR_BASE,
  359. };
  360. /*
  361. * Callback to search the Mustek MDC800 on the USB Bus
  362. */
  363. static int mdc800_usb_probe (struct usb_interface *intf,
  364. const struct usb_device_id *id)
  365. {
  366. int i,j;
  367. struct usb_host_interface *intf_desc;
  368. struct usb_device *dev = interface_to_usbdev (intf);
  369. int irq_interval=0;
  370. int retval;
  371. dev_dbg(&intf->dev, "(%s) called.\n", __func__);
  372. if (mdc800->dev != NULL)
  373. {
  374. dev_warn(&intf->dev, "only one Mustek MDC800 is supported.\n");
  375. return -ENODEV;
  376. }
  377. if (dev->descriptor.bNumConfigurations != 1)
  378. {
  379. dev_err(&intf->dev,
  380. "probe fails -> wrong Number of Configuration\n");
  381. return -ENODEV;
  382. }
  383. intf_desc = intf->cur_altsetting;
  384. if (
  385. ( intf_desc->desc.bInterfaceClass != 0xff )
  386. || ( intf_desc->desc.bInterfaceSubClass != 0 )
  387. || ( intf_desc->desc.bInterfaceProtocol != 0 )
  388. || ( intf_desc->desc.bNumEndpoints != 4)
  389. )
  390. {
  391. dev_err(&intf->dev, "probe fails -> wrong Interface\n");
  392. return -ENODEV;
  393. }
  394. /* Check the Endpoints */
  395. for (i=0; i<4; i++)
  396. {
  397. mdc800->endpoint[i]=-1;
  398. for (j=0; j<4; j++)
  399. {
  400. if (mdc800_endpoint_equals (&intf_desc->endpoint [j].desc,&mdc800_ed [i]))
  401. {
  402. mdc800->endpoint[i]=intf_desc->endpoint [j].desc.bEndpointAddress ;
  403. if (i==1)
  404. {
  405. irq_interval=intf_desc->endpoint [j].desc.bInterval;
  406. }
  407. }
  408. }
  409. if (mdc800->endpoint[i] == -1)
  410. {
  411. dev_err(&intf->dev, "probe fails -> Wrong Endpoints.\n");
  412. return -ENODEV;
  413. }
  414. }
  415. dev_info(&intf->dev, "Found Mustek MDC800 on USB.\n");
  416. mutex_lock(&mdc800->io_lock);
  417. retval = usb_register_dev(intf, &mdc800_class);
  418. if (retval) {
  419. dev_err(&intf->dev, "Not able to get a minor for this device.\n");
  420. mutex_unlock(&mdc800->io_lock);
  421. return -ENODEV;
  422. }
  423. mdc800->dev=dev;
  424. mdc800->open=0;
  425. /* Setup URB Structs */
  426. usb_fill_int_urb (
  427. mdc800->irq_urb,
  428. mdc800->dev,
  429. usb_rcvintpipe (mdc800->dev,mdc800->endpoint [1]),
  430. mdc800->irq_urb_buffer,
  431. 8,
  432. mdc800_usb_irq,
  433. mdc800,
  434. irq_interval
  435. );
  436. usb_fill_bulk_urb (
  437. mdc800->write_urb,
  438. mdc800->dev,
  439. usb_sndbulkpipe (mdc800->dev, mdc800->endpoint[0]),
  440. mdc800->write_urb_buffer,
  441. 8,
  442. mdc800_usb_write_notify,
  443. mdc800
  444. );
  445. usb_fill_bulk_urb (
  446. mdc800->download_urb,
  447. mdc800->dev,
  448. usb_rcvbulkpipe (mdc800->dev, mdc800->endpoint [3]),
  449. mdc800->download_urb_buffer,
  450. 64,
  451. mdc800_usb_download_notify,
  452. mdc800
  453. );
  454. mdc800->state=READY;
  455. mutex_unlock(&mdc800->io_lock);
  456. usb_set_intfdata(intf, mdc800);
  457. return 0;
  458. }
  459. /*
  460. * Disconnect USB device (maybe the MDC800)
  461. */
  462. static void mdc800_usb_disconnect (struct usb_interface *intf)
  463. {
  464. struct mdc800_data* mdc800 = usb_get_intfdata(intf);
  465. dev_dbg(&intf->dev, "(%s) called\n", __func__);
  466. if (mdc800) {
  467. if (mdc800->state == NOT_CONNECTED)
  468. return;
  469. usb_deregister_dev(intf, &mdc800_class);
  470. /* must be under lock to make sure no URB
  471. is submitted after usb_kill_urb() */
  472. mutex_lock(&mdc800->io_lock);
  473. mdc800->state=NOT_CONNECTED;
  474. usb_kill_urb(mdc800->irq_urb);
  475. usb_kill_urb(mdc800->write_urb);
  476. usb_kill_urb(mdc800->download_urb);
  477. mutex_unlock(&mdc800->io_lock);
  478. mdc800->dev = NULL;
  479. usb_set_intfdata(intf, NULL);
  480. }
  481. dev_info(&intf->dev, "Mustek MDC800 disconnected from USB.\n");
  482. }
  483. /***************************************************************************
  484. The Misc device Part (file_operations)
  485. ****************************************************************************/
  486. /*
  487. * This Function calc the Answersize for a command.
  488. */
  489. static int mdc800_getAnswerSize (char command)
  490. {
  491. switch ((unsigned char) command)
  492. {
  493. case 0x2a:
  494. case 0x49:
  495. case 0x51:
  496. case 0x0d:
  497. case 0x20:
  498. case 0x07:
  499. case 0x01:
  500. case 0x25:
  501. case 0x00:
  502. return 8;
  503. case 0x05:
  504. case 0x3e:
  505. return mdc800->pic_len;
  506. case 0x09:
  507. return 4096;
  508. default:
  509. return 0;
  510. }
  511. }
  512. /*
  513. * Init the device: (1) alloc mem (2) Increase MOD Count ..
  514. */
  515. static int mdc800_device_open (struct inode* inode, struct file *file)
  516. {
  517. int retval=0;
  518. int errn=0;
  519. mutex_lock(&mdc800->io_lock);
  520. if (mdc800->state == NOT_CONNECTED)
  521. {
  522. errn=-EBUSY;
  523. goto error_out;
  524. }
  525. if (mdc800->open)
  526. {
  527. errn=-EBUSY;
  528. goto error_out;
  529. }
  530. mdc800->in_count=0;
  531. mdc800->out_count=0;
  532. mdc800->out_ptr=0;
  533. mdc800->pic_index=0;
  534. mdc800->pic_len=-1;
  535. mdc800->download_left=0;
  536. mdc800->camera_busy=0;
  537. mdc800->camera_request_ready=0;
  538. retval=0;
  539. mdc800->irq_urb->dev = mdc800->dev;
  540. retval = usb_submit_urb (mdc800->irq_urb, GFP_KERNEL);
  541. if (retval) {
  542. dev_err(&mdc800->dev->dev,
  543. "request USB irq fails (submit_retval=%i).\n", retval);
  544. errn = -EIO;
  545. goto error_out;
  546. }
  547. mdc800->open=1;
  548. dev_dbg(&mdc800->dev->dev, "Mustek MDC800 device opened.\n");
  549. error_out:
  550. mutex_unlock(&mdc800->io_lock);
  551. return errn;
  552. }
  553. /*
  554. * Close the Camera and release Memory
  555. */
  556. static int mdc800_device_release (struct inode* inode, struct file *file)
  557. {
  558. int retval=0;
  559. mutex_lock(&mdc800->io_lock);
  560. if (mdc800->open && (mdc800->state != NOT_CONNECTED))
  561. {
  562. usb_kill_urb(mdc800->irq_urb);
  563. usb_kill_urb(mdc800->write_urb);
  564. usb_kill_urb(mdc800->download_urb);
  565. mdc800->open=0;
  566. }
  567. else
  568. {
  569. retval=-EIO;
  570. }
  571. mutex_unlock(&mdc800->io_lock);
  572. return retval;
  573. }
  574. /*
  575. * The Device read callback Function
  576. */
  577. static ssize_t mdc800_device_read (struct file *file, char __user *buf, size_t len, loff_t *pos)
  578. {
  579. size_t left=len, sts=len; /* single transfer size */
  580. char __user *ptr = buf;
  581. int retval;
  582. mutex_lock(&mdc800->io_lock);
  583. if (mdc800->state == NOT_CONNECTED)
  584. {
  585. mutex_unlock(&mdc800->io_lock);
  586. return -EBUSY;
  587. }
  588. if (mdc800->state == WORKING)
  589. {
  590. printk(KERN_WARNING "mdc800: Illegal State \"working\""
  591. "reached during read ?!\n");
  592. mutex_unlock(&mdc800->io_lock);
  593. return -EBUSY;
  594. }
  595. if (!mdc800->open)
  596. {
  597. mutex_unlock(&mdc800->io_lock);
  598. return -EBUSY;
  599. }
  600. while (left)
  601. {
  602. if (signal_pending (current))
  603. {
  604. mutex_unlock(&mdc800->io_lock);
  605. return -EINTR;
  606. }
  607. sts=left > (mdc800->out_count-mdc800->out_ptr)?mdc800->out_count-mdc800->out_ptr:left;
  608. if (sts <= 0)
  609. {
  610. /* Too less Data in buffer */
  611. if (mdc800->state == DOWNLOAD)
  612. {
  613. mdc800->out_count=0;
  614. mdc800->out_ptr=0;
  615. /* Download -> Request new bytes */
  616. mdc800->download_urb->dev = mdc800->dev;
  617. retval = usb_submit_urb (mdc800->download_urb, GFP_KERNEL);
  618. if (retval) {
  619. dev_err(&mdc800->dev->dev,
  620. "Can't submit download urb "
  621. "(retval=%i)\n", retval);
  622. mutex_unlock(&mdc800->io_lock);
  623. return len-left;
  624. }
  625. wait_event_timeout(mdc800->download_wait,
  626. mdc800->downloaded,
  627. msecs_to_jiffies(TO_DOWNLOAD_GET_READY));
  628. mdc800->downloaded = 0;
  629. if (mdc800->download_urb->status != 0)
  630. {
  631. dev_err(&mdc800->dev->dev,
  632. "request download-bytes fails "
  633. "(status=%i)\n",
  634. mdc800->download_urb->status);
  635. mutex_unlock(&mdc800->io_lock);
  636. return len-left;
  637. }
  638. }
  639. else
  640. {
  641. /* No more bytes -> that's an error*/
  642. mutex_unlock(&mdc800->io_lock);
  643. return -EIO;
  644. }
  645. }
  646. else
  647. {
  648. /* Copy Bytes */
  649. if (copy_to_user(ptr, &mdc800->out [mdc800->out_ptr],
  650. sts)) {
  651. mutex_unlock(&mdc800->io_lock);
  652. return -EFAULT;
  653. }
  654. ptr+=sts;
  655. left-=sts;
  656. mdc800->out_ptr+=sts;
  657. }
  658. }
  659. mutex_unlock(&mdc800->io_lock);
  660. return len-left;
  661. }
  662. /*
  663. * The Device write callback Function
  664. * If a 8Byte Command is received, it will be send to the camera.
  665. * After this the driver initiates the request for the answer or
  666. * just waits until the camera becomes ready.
  667. */
  668. static ssize_t mdc800_device_write (struct file *file, const char __user *buf, size_t len, loff_t *pos)
  669. {
  670. size_t i=0;
  671. int retval;
  672. mutex_lock(&mdc800->io_lock);
  673. if (mdc800->state != READY)
  674. {
  675. mutex_unlock(&mdc800->io_lock);
  676. return -EBUSY;
  677. }
  678. if (!mdc800->open )
  679. {
  680. mutex_unlock(&mdc800->io_lock);
  681. return -EBUSY;
  682. }
  683. while (i<len)
  684. {
  685. unsigned char c;
  686. if (signal_pending (current))
  687. {
  688. mutex_unlock(&mdc800->io_lock);
  689. return -EINTR;
  690. }
  691. if(get_user(c, buf+i))
  692. {
  693. mutex_unlock(&mdc800->io_lock);
  694. return -EFAULT;
  695. }
  696. /* check for command start */
  697. if (c == 0x55)
  698. {
  699. mdc800->in_count=0;
  700. mdc800->out_count=0;
  701. mdc800->out_ptr=0;
  702. mdc800->download_left=0;
  703. }
  704. /* save command byte */
  705. if (mdc800->in_count < 8)
  706. {
  707. mdc800->in[mdc800->in_count] = c;
  708. mdc800->in_count++;
  709. }
  710. else
  711. {
  712. mutex_unlock(&mdc800->io_lock);
  713. return -EIO;
  714. }
  715. /* Command Buffer full ? -> send it to camera */
  716. if (mdc800->in_count == 8)
  717. {
  718. int answersize;
  719. if (mdc800_usb_waitForIRQ (0,TO_GET_READY))
  720. {
  721. dev_err(&mdc800->dev->dev,
  722. "Camera didn't get ready.\n");
  723. mutex_unlock(&mdc800->io_lock);
  724. return -EIO;
  725. }
  726. answersize=mdc800_getAnswerSize (mdc800->in[1]);
  727. mdc800->state=WORKING;
  728. memcpy (mdc800->write_urb->transfer_buffer, mdc800->in,8);
  729. mdc800->write_urb->dev = mdc800->dev;
  730. retval = usb_submit_urb (mdc800->write_urb, GFP_KERNEL);
  731. if (retval) {
  732. dev_err(&mdc800->dev->dev,
  733. "submitting write urb fails "
  734. "(retval=%i)\n", retval);
  735. mutex_unlock(&mdc800->io_lock);
  736. return -EIO;
  737. }
  738. wait_event_timeout(mdc800->write_wait, mdc800->written,
  739. msecs_to_jiffies(TO_WRITE_GET_READY));
  740. mdc800->written = 0;
  741. if (mdc800->state == WORKING)
  742. {
  743. usb_kill_urb(mdc800->write_urb);
  744. mutex_unlock(&mdc800->io_lock);
  745. return -EIO;
  746. }
  747. switch ((unsigned char) mdc800->in[1])
  748. {
  749. case 0x05: /* Download Image */
  750. case 0x3e: /* Take shot in Fine Mode (WCam Mode) */
  751. if (mdc800->pic_len < 0)
  752. {
  753. dev_err(&mdc800->dev->dev,
  754. "call 0x07 before "
  755. "0x05,0x3e\n");
  756. mdc800->state=READY;
  757. mutex_unlock(&mdc800->io_lock);
  758. return -EIO;
  759. }
  760. mdc800->pic_len=-1;
  761. fallthrough;
  762. case 0x09: /* Download Thumbnail */
  763. mdc800->download_left=answersize+64;
  764. mdc800->state=DOWNLOAD;
  765. mdc800_usb_waitForIRQ (0,TO_DOWNLOAD_GET_BUSY);
  766. break;
  767. default:
  768. if (answersize)
  769. {
  770. if (mdc800_usb_waitForIRQ (1,TO_READ_FROM_IRQ))
  771. {
  772. dev_err(&mdc800->dev->dev, "requesting answer from irq fails\n");
  773. mutex_unlock(&mdc800->io_lock);
  774. return -EIO;
  775. }
  776. /* Write dummy data, (this is ugly but part of the USB Protocol */
  777. /* if you use endpoint 1 as bulk and not as irq) */
  778. memcpy (mdc800->out, mdc800->camera_response,8);
  779. /* This is the interpreted answer */
  780. memcpy (&mdc800->out[8], mdc800->camera_response,8);
  781. mdc800->out_ptr=0;
  782. mdc800->out_count=16;
  783. /* Cache the Imagesize, if command was getImageSize */
  784. if (mdc800->in [1] == (char) 0x07)
  785. {
  786. mdc800->pic_len=(int) 65536*(unsigned char) mdc800->camera_response[0]+256*(unsigned char) mdc800->camera_response[1]+(unsigned char) mdc800->camera_response[2];
  787. dev_dbg(&mdc800->dev->dev, "cached imagesize = %i\n", mdc800->pic_len);
  788. }
  789. }
  790. else
  791. {
  792. if (mdc800_usb_waitForIRQ (0,TO_DEFAULT_COMMAND))
  793. {
  794. dev_err(&mdc800->dev->dev, "Command Timeout.\n");
  795. mutex_unlock(&mdc800->io_lock);
  796. return -EIO;
  797. }
  798. }
  799. mdc800->state=READY;
  800. break;
  801. }
  802. }
  803. i++;
  804. }
  805. mutex_unlock(&mdc800->io_lock);
  806. return i;
  807. }
  808. /***************************************************************************
  809. Init and Cleanup this driver (Structs and types)
  810. ****************************************************************************/
  811. /* File Operations of this drivers */
  812. static const struct file_operations mdc800_device_ops =
  813. {
  814. .owner = THIS_MODULE,
  815. .read = mdc800_device_read,
  816. .write = mdc800_device_write,
  817. .open = mdc800_device_open,
  818. .release = mdc800_device_release,
  819. .llseek = noop_llseek,
  820. };
  821. static const struct usb_device_id mdc800_table[] = {
  822. { USB_DEVICE(MDC800_VENDOR_ID, MDC800_PRODUCT_ID) },
  823. { } /* Terminating entry */
  824. };
  825. MODULE_DEVICE_TABLE (usb, mdc800_table);
  826. /*
  827. * USB Driver Struct for this device
  828. */
  829. static struct usb_driver mdc800_usb_driver =
  830. {
  831. .name = "mdc800",
  832. .probe = mdc800_usb_probe,
  833. .disconnect = mdc800_usb_disconnect,
  834. .id_table = mdc800_table
  835. };
  836. /************************************************************************
  837. Init and Cleanup this driver (Main Functions)
  838. *************************************************************************/
  839. static int __init usb_mdc800_init (void)
  840. {
  841. int retval = -ENODEV;
  842. /* Allocate Memory */
  843. mdc800=kzalloc (sizeof (struct mdc800_data), GFP_KERNEL);
  844. if (!mdc800)
  845. goto cleanup_on_fail;
  846. mdc800->dev = NULL;
  847. mdc800->state=NOT_CONNECTED;
  848. mutex_init (&mdc800->io_lock);
  849. init_waitqueue_head (&mdc800->irq_wait);
  850. init_waitqueue_head (&mdc800->write_wait);
  851. init_waitqueue_head (&mdc800->download_wait);
  852. mdc800->irq_woken = 0;
  853. mdc800->downloaded = 0;
  854. mdc800->written = 0;
  855. mdc800->irq_urb_buffer=kmalloc (8, GFP_KERNEL);
  856. if (!mdc800->irq_urb_buffer)
  857. goto cleanup_on_fail;
  858. mdc800->write_urb_buffer=kmalloc (8, GFP_KERNEL);
  859. if (!mdc800->write_urb_buffer)
  860. goto cleanup_on_fail;
  861. mdc800->download_urb_buffer=kmalloc (64, GFP_KERNEL);
  862. if (!mdc800->download_urb_buffer)
  863. goto cleanup_on_fail;
  864. mdc800->irq_urb=usb_alloc_urb (0, GFP_KERNEL);
  865. if (!mdc800->irq_urb)
  866. goto cleanup_on_fail;
  867. mdc800->download_urb=usb_alloc_urb (0, GFP_KERNEL);
  868. if (!mdc800->download_urb)
  869. goto cleanup_on_fail;
  870. mdc800->write_urb=usb_alloc_urb (0, GFP_KERNEL);
  871. if (!mdc800->write_urb)
  872. goto cleanup_on_fail;
  873. /* Register the driver */
  874. retval = usb_register(&mdc800_usb_driver);
  875. if (retval)
  876. goto cleanup_on_fail;
  877. printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
  878. DRIVER_DESC "\n");
  879. return 0;
  880. /* Clean driver up, when something fails */
  881. cleanup_on_fail:
  882. if (mdc800 != NULL)
  883. {
  884. printk(KERN_ERR "mdc800: can't alloc memory!\n");
  885. kfree(mdc800->download_urb_buffer);
  886. kfree(mdc800->write_urb_buffer);
  887. kfree(mdc800->irq_urb_buffer);
  888. usb_free_urb(mdc800->write_urb);
  889. usb_free_urb(mdc800->download_urb);
  890. usb_free_urb(mdc800->irq_urb);
  891. kfree (mdc800);
  892. }
  893. mdc800 = NULL;
  894. return retval;
  895. }
  896. static void __exit usb_mdc800_cleanup (void)
  897. {
  898. usb_deregister (&mdc800_usb_driver);
  899. usb_free_urb (mdc800->irq_urb);
  900. usb_free_urb (mdc800->download_urb);
  901. usb_free_urb (mdc800->write_urb);
  902. kfree (mdc800->irq_urb_buffer);
  903. kfree (mdc800->write_urb_buffer);
  904. kfree (mdc800->download_urb_buffer);
  905. kfree (mdc800);
  906. mdc800 = NULL;
  907. }
  908. module_init (usb_mdc800_init);
  909. module_exit (usb_mdc800_cleanup);
  910. MODULE_AUTHOR( DRIVER_AUTHOR );
  911. MODULE_DESCRIPTION( DRIVER_DESC );
  912. MODULE_LICENSE("GPL");