usbtmc.c 61 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * drivers/usb/class/usbtmc.c - USB Test & Measurement class driver
  4. *
  5. * Copyright (C) 2007 Stefan Kopp, Gechingen, Germany
  6. * Copyright (C) 2008 Novell, Inc.
  7. * Copyright (C) 2008 Greg Kroah-Hartman <[email protected]>
  8. * Copyright (C) 2018 IVI Foundation, Inc.
  9. */
  10. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11. #include <linux/module.h>
  12. #include <linux/kernel.h>
  13. #include <linux/fs.h>
  14. #include <linux/uaccess.h>
  15. #include <linux/kref.h>
  16. #include <linux/slab.h>
  17. #include <linux/poll.h>
  18. #include <linux/mutex.h>
  19. #include <linux/usb.h>
  20. #include <linux/compat.h>
  21. #include <linux/usb/tmc.h>
  22. /* Increment API VERSION when changing tmc.h with new flags or ioctls
  23. * or when changing a significant behavior of the driver.
  24. */
  25. #define USBTMC_API_VERSION (3)
  26. #define USBTMC_HEADER_SIZE 12
  27. #define USBTMC_MINOR_BASE 176
  28. /* Minimum USB timeout (in milliseconds) */
  29. #define USBTMC_MIN_TIMEOUT 100
  30. /* Default USB timeout (in milliseconds) */
  31. #define USBTMC_TIMEOUT 5000
  32. /* Max number of urbs used in write transfers */
  33. #define MAX_URBS_IN_FLIGHT 16
  34. /* I/O buffer size used in generic read/write functions */
  35. #define USBTMC_BUFSIZE (4096)
  36. /*
  37. * Maximum number of read cycles to empty bulk in endpoint during CLEAR and
  38. * ABORT_BULK_IN requests. Ends the loop if (for whatever reason) a short
  39. * packet is never read.
  40. */
  41. #define USBTMC_MAX_READS_TO_CLEAR_BULK_IN 100
  42. static const struct usb_device_id usbtmc_devices[] = {
  43. { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 0), },
  44. { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 1), },
  45. { 0, } /* terminating entry */
  46. };
  47. MODULE_DEVICE_TABLE(usb, usbtmc_devices);
  48. /*
  49. * This structure is the capabilities for the device
  50. * See section 4.2.1.8 of the USBTMC specification,
  51. * and section 4.2.2 of the USBTMC usb488 subclass
  52. * specification for details.
  53. */
  54. struct usbtmc_dev_capabilities {
  55. __u8 interface_capabilities;
  56. __u8 device_capabilities;
  57. __u8 usb488_interface_capabilities;
  58. __u8 usb488_device_capabilities;
  59. };
  60. /* This structure holds private data for each USBTMC device. One copy is
  61. * allocated for each USBTMC device in the driver's probe function.
  62. */
  63. struct usbtmc_device_data {
  64. const struct usb_device_id *id;
  65. struct usb_device *usb_dev;
  66. struct usb_interface *intf;
  67. struct list_head file_list;
  68. unsigned int bulk_in;
  69. unsigned int bulk_out;
  70. u8 bTag;
  71. u8 bTag_last_write; /* needed for abort */
  72. u8 bTag_last_read; /* needed for abort */
  73. /* packet size of IN bulk */
  74. u16 wMaxPacketSize;
  75. /* data for interrupt in endpoint handling */
  76. u8 bNotify1;
  77. u8 bNotify2;
  78. u16 ifnum;
  79. u8 iin_bTag;
  80. u8 *iin_buffer;
  81. atomic_t iin_data_valid;
  82. unsigned int iin_ep;
  83. int iin_ep_present;
  84. int iin_interval;
  85. struct urb *iin_urb;
  86. u16 iin_wMaxPacketSize;
  87. /* coalesced usb488_caps from usbtmc_dev_capabilities */
  88. __u8 usb488_caps;
  89. bool zombie; /* fd of disconnected device */
  90. struct usbtmc_dev_capabilities capabilities;
  91. struct kref kref;
  92. struct mutex io_mutex; /* only one i/o function running at a time */
  93. wait_queue_head_t waitq;
  94. struct fasync_struct *fasync;
  95. spinlock_t dev_lock; /* lock for file_list */
  96. };
  97. #define to_usbtmc_data(d) container_of(d, struct usbtmc_device_data, kref)
  98. /*
  99. * This structure holds private data for each USBTMC file handle.
  100. */
  101. struct usbtmc_file_data {
  102. struct usbtmc_device_data *data;
  103. struct list_head file_elem;
  104. u32 timeout;
  105. u8 srq_byte;
  106. atomic_t srq_asserted;
  107. atomic_t closing;
  108. u8 bmTransferAttributes; /* member of DEV_DEP_MSG_IN */
  109. u8 eom_val;
  110. u8 term_char;
  111. bool term_char_enabled;
  112. bool auto_abort;
  113. spinlock_t err_lock; /* lock for errors */
  114. struct usb_anchor submitted;
  115. /* data for generic_write */
  116. struct semaphore limit_write_sem;
  117. u32 out_transfer_size;
  118. int out_status;
  119. /* data for generic_read */
  120. u32 in_transfer_size;
  121. int in_status;
  122. int in_urbs_used;
  123. struct usb_anchor in_anchor;
  124. wait_queue_head_t wait_bulk_in;
  125. };
  126. /* Forward declarations */
  127. static struct usb_driver usbtmc_driver;
  128. static void usbtmc_draw_down(struct usbtmc_file_data *file_data);
  129. static void usbtmc_delete(struct kref *kref)
  130. {
  131. struct usbtmc_device_data *data = to_usbtmc_data(kref);
  132. usb_put_dev(data->usb_dev);
  133. kfree(data);
  134. }
  135. static int usbtmc_open(struct inode *inode, struct file *filp)
  136. {
  137. struct usb_interface *intf;
  138. struct usbtmc_device_data *data;
  139. struct usbtmc_file_data *file_data;
  140. intf = usb_find_interface(&usbtmc_driver, iminor(inode));
  141. if (!intf) {
  142. pr_err("can not find device for minor %d", iminor(inode));
  143. return -ENODEV;
  144. }
  145. file_data = kzalloc(sizeof(*file_data), GFP_KERNEL);
  146. if (!file_data)
  147. return -ENOMEM;
  148. spin_lock_init(&file_data->err_lock);
  149. sema_init(&file_data->limit_write_sem, MAX_URBS_IN_FLIGHT);
  150. init_usb_anchor(&file_data->submitted);
  151. init_usb_anchor(&file_data->in_anchor);
  152. init_waitqueue_head(&file_data->wait_bulk_in);
  153. data = usb_get_intfdata(intf);
  154. /* Protect reference to data from file structure until release */
  155. kref_get(&data->kref);
  156. mutex_lock(&data->io_mutex);
  157. file_data->data = data;
  158. atomic_set(&file_data->closing, 0);
  159. file_data->timeout = USBTMC_TIMEOUT;
  160. file_data->term_char = '\n';
  161. file_data->term_char_enabled = 0;
  162. file_data->auto_abort = 0;
  163. file_data->eom_val = 1;
  164. INIT_LIST_HEAD(&file_data->file_elem);
  165. spin_lock_irq(&data->dev_lock);
  166. list_add_tail(&file_data->file_elem, &data->file_list);
  167. spin_unlock_irq(&data->dev_lock);
  168. mutex_unlock(&data->io_mutex);
  169. /* Store pointer in file structure's private data field */
  170. filp->private_data = file_data;
  171. return 0;
  172. }
  173. /*
  174. * usbtmc_flush - called before file handle is closed
  175. */
  176. static int usbtmc_flush(struct file *file, fl_owner_t id)
  177. {
  178. struct usbtmc_file_data *file_data;
  179. struct usbtmc_device_data *data;
  180. file_data = file->private_data;
  181. if (file_data == NULL)
  182. return -ENODEV;
  183. atomic_set(&file_data->closing, 1);
  184. data = file_data->data;
  185. /* wait for io to stop */
  186. mutex_lock(&data->io_mutex);
  187. usbtmc_draw_down(file_data);
  188. spin_lock_irq(&file_data->err_lock);
  189. file_data->in_status = 0;
  190. file_data->in_transfer_size = 0;
  191. file_data->in_urbs_used = 0;
  192. file_data->out_status = 0;
  193. file_data->out_transfer_size = 0;
  194. spin_unlock_irq(&file_data->err_lock);
  195. wake_up_interruptible_all(&data->waitq);
  196. mutex_unlock(&data->io_mutex);
  197. return 0;
  198. }
  199. static int usbtmc_release(struct inode *inode, struct file *file)
  200. {
  201. struct usbtmc_file_data *file_data = file->private_data;
  202. /* prevent IO _AND_ usbtmc_interrupt */
  203. mutex_lock(&file_data->data->io_mutex);
  204. spin_lock_irq(&file_data->data->dev_lock);
  205. list_del(&file_data->file_elem);
  206. spin_unlock_irq(&file_data->data->dev_lock);
  207. mutex_unlock(&file_data->data->io_mutex);
  208. kref_put(&file_data->data->kref, usbtmc_delete);
  209. file_data->data = NULL;
  210. kfree(file_data);
  211. return 0;
  212. }
  213. static int usbtmc_ioctl_abort_bulk_in_tag(struct usbtmc_device_data *data,
  214. u8 tag)
  215. {
  216. u8 *buffer;
  217. struct device *dev;
  218. int rv;
  219. int n;
  220. int actual;
  221. dev = &data->intf->dev;
  222. buffer = kmalloc(USBTMC_BUFSIZE, GFP_KERNEL);
  223. if (!buffer)
  224. return -ENOMEM;
  225. rv = usb_control_msg(data->usb_dev,
  226. usb_rcvctrlpipe(data->usb_dev, 0),
  227. USBTMC_REQUEST_INITIATE_ABORT_BULK_IN,
  228. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
  229. tag, data->bulk_in,
  230. buffer, 2, USB_CTRL_GET_TIMEOUT);
  231. if (rv < 0) {
  232. dev_err(dev, "usb_control_msg returned %d\n", rv);
  233. goto exit;
  234. }
  235. dev_dbg(dev, "INITIATE_ABORT_BULK_IN returned %x with tag %02x\n",
  236. buffer[0], buffer[1]);
  237. if (buffer[0] == USBTMC_STATUS_FAILED) {
  238. /* No transfer in progress and the Bulk-OUT FIFO is empty. */
  239. rv = 0;
  240. goto exit;
  241. }
  242. if (buffer[0] == USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS) {
  243. /* The device returns this status if either:
  244. * - There is a transfer in progress, but the specified bTag
  245. * does not match.
  246. * - There is no transfer in progress, but the Bulk-OUT FIFO
  247. * is not empty.
  248. */
  249. rv = -ENOMSG;
  250. goto exit;
  251. }
  252. if (buffer[0] != USBTMC_STATUS_SUCCESS) {
  253. dev_err(dev, "INITIATE_ABORT_BULK_IN returned %x\n",
  254. buffer[0]);
  255. rv = -EPERM;
  256. goto exit;
  257. }
  258. n = 0;
  259. usbtmc_abort_bulk_in_status:
  260. dev_dbg(dev, "Reading from bulk in EP\n");
  261. /* Data must be present. So use low timeout 300 ms */
  262. actual = 0;
  263. rv = usb_bulk_msg(data->usb_dev,
  264. usb_rcvbulkpipe(data->usb_dev,
  265. data->bulk_in),
  266. buffer, USBTMC_BUFSIZE,
  267. &actual, 300);
  268. print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE, 16, 1,
  269. buffer, actual, true);
  270. n++;
  271. if (rv < 0) {
  272. dev_err(dev, "usb_bulk_msg returned %d\n", rv);
  273. if (rv != -ETIMEDOUT)
  274. goto exit;
  275. }
  276. if (actual == USBTMC_BUFSIZE)
  277. goto usbtmc_abort_bulk_in_status;
  278. if (n >= USBTMC_MAX_READS_TO_CLEAR_BULK_IN) {
  279. dev_err(dev, "Couldn't clear device buffer within %d cycles\n",
  280. USBTMC_MAX_READS_TO_CLEAR_BULK_IN);
  281. rv = -EPERM;
  282. goto exit;
  283. }
  284. rv = usb_control_msg(data->usb_dev,
  285. usb_rcvctrlpipe(data->usb_dev, 0),
  286. USBTMC_REQUEST_CHECK_ABORT_BULK_IN_STATUS,
  287. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
  288. 0, data->bulk_in, buffer, 0x08,
  289. USB_CTRL_GET_TIMEOUT);
  290. if (rv < 0) {
  291. dev_err(dev, "usb_control_msg returned %d\n", rv);
  292. goto exit;
  293. }
  294. dev_dbg(dev, "CHECK_ABORT_BULK_IN returned %x\n", buffer[0]);
  295. if (buffer[0] == USBTMC_STATUS_SUCCESS) {
  296. rv = 0;
  297. goto exit;
  298. }
  299. if (buffer[0] != USBTMC_STATUS_PENDING) {
  300. dev_err(dev, "CHECK_ABORT_BULK_IN returned %x\n", buffer[0]);
  301. rv = -EPERM;
  302. goto exit;
  303. }
  304. if ((buffer[1] & 1) > 0) {
  305. /* The device has 1 or more queued packets the Host can read */
  306. goto usbtmc_abort_bulk_in_status;
  307. }
  308. /* The Host must send CHECK_ABORT_BULK_IN_STATUS at a later time. */
  309. rv = -EAGAIN;
  310. exit:
  311. kfree(buffer);
  312. return rv;
  313. }
  314. static int usbtmc_ioctl_abort_bulk_in(struct usbtmc_device_data *data)
  315. {
  316. return usbtmc_ioctl_abort_bulk_in_tag(data, data->bTag_last_read);
  317. }
  318. static int usbtmc_ioctl_abort_bulk_out_tag(struct usbtmc_device_data *data,
  319. u8 tag)
  320. {
  321. struct device *dev;
  322. u8 *buffer;
  323. int rv;
  324. int n;
  325. dev = &data->intf->dev;
  326. buffer = kmalloc(8, GFP_KERNEL);
  327. if (!buffer)
  328. return -ENOMEM;
  329. rv = usb_control_msg(data->usb_dev,
  330. usb_rcvctrlpipe(data->usb_dev, 0),
  331. USBTMC_REQUEST_INITIATE_ABORT_BULK_OUT,
  332. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
  333. tag, data->bulk_out,
  334. buffer, 2, USB_CTRL_GET_TIMEOUT);
  335. if (rv < 0) {
  336. dev_err(dev, "usb_control_msg returned %d\n", rv);
  337. goto exit;
  338. }
  339. dev_dbg(dev, "INITIATE_ABORT_BULK_OUT returned %x\n", buffer[0]);
  340. if (buffer[0] != USBTMC_STATUS_SUCCESS) {
  341. dev_err(dev, "INITIATE_ABORT_BULK_OUT returned %x\n",
  342. buffer[0]);
  343. rv = -EPERM;
  344. goto exit;
  345. }
  346. n = 0;
  347. usbtmc_abort_bulk_out_check_status:
  348. /* do not stress device with subsequent requests */
  349. msleep(50);
  350. rv = usb_control_msg(data->usb_dev,
  351. usb_rcvctrlpipe(data->usb_dev, 0),
  352. USBTMC_REQUEST_CHECK_ABORT_BULK_OUT_STATUS,
  353. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
  354. 0, data->bulk_out, buffer, 0x08,
  355. USB_CTRL_GET_TIMEOUT);
  356. n++;
  357. if (rv < 0) {
  358. dev_err(dev, "usb_control_msg returned %d\n", rv);
  359. goto exit;
  360. }
  361. dev_dbg(dev, "CHECK_ABORT_BULK_OUT returned %x\n", buffer[0]);
  362. if (buffer[0] == USBTMC_STATUS_SUCCESS)
  363. goto usbtmc_abort_bulk_out_clear_halt;
  364. if ((buffer[0] == USBTMC_STATUS_PENDING) &&
  365. (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN))
  366. goto usbtmc_abort_bulk_out_check_status;
  367. rv = -EPERM;
  368. goto exit;
  369. usbtmc_abort_bulk_out_clear_halt:
  370. rv = usb_clear_halt(data->usb_dev,
  371. usb_sndbulkpipe(data->usb_dev, data->bulk_out));
  372. if (rv < 0) {
  373. dev_err(dev, "usb_control_msg returned %d\n", rv);
  374. goto exit;
  375. }
  376. rv = 0;
  377. exit:
  378. kfree(buffer);
  379. return rv;
  380. }
  381. static int usbtmc_ioctl_abort_bulk_out(struct usbtmc_device_data *data)
  382. {
  383. return usbtmc_ioctl_abort_bulk_out_tag(data, data->bTag_last_write);
  384. }
  385. static int usbtmc_get_stb(struct usbtmc_file_data *file_data, __u8 *stb)
  386. {
  387. struct usbtmc_device_data *data = file_data->data;
  388. struct device *dev = &data->intf->dev;
  389. u8 *buffer;
  390. u8 tag;
  391. int rv;
  392. dev_dbg(dev, "Enter ioctl_read_stb iin_ep_present: %d\n",
  393. data->iin_ep_present);
  394. buffer = kmalloc(8, GFP_KERNEL);
  395. if (!buffer)
  396. return -ENOMEM;
  397. atomic_set(&data->iin_data_valid, 0);
  398. rv = usb_control_msg(data->usb_dev,
  399. usb_rcvctrlpipe(data->usb_dev, 0),
  400. USBTMC488_REQUEST_READ_STATUS_BYTE,
  401. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  402. data->iin_bTag,
  403. data->ifnum,
  404. buffer, 0x03, USB_CTRL_GET_TIMEOUT);
  405. if (rv < 0) {
  406. dev_err(dev, "stb usb_control_msg returned %d\n", rv);
  407. goto exit;
  408. }
  409. if (buffer[0] != USBTMC_STATUS_SUCCESS) {
  410. dev_err(dev, "control status returned %x\n", buffer[0]);
  411. rv = -EIO;
  412. goto exit;
  413. }
  414. if (data->iin_ep_present) {
  415. rv = wait_event_interruptible_timeout(
  416. data->waitq,
  417. atomic_read(&data->iin_data_valid) != 0,
  418. file_data->timeout);
  419. if (rv < 0) {
  420. dev_dbg(dev, "wait interrupted %d\n", rv);
  421. goto exit;
  422. }
  423. if (rv == 0) {
  424. dev_dbg(dev, "wait timed out\n");
  425. rv = -ETIMEDOUT;
  426. goto exit;
  427. }
  428. tag = data->bNotify1 & 0x7f;
  429. if (tag != data->iin_bTag) {
  430. dev_err(dev, "expected bTag %x got %x\n",
  431. data->iin_bTag, tag);
  432. }
  433. *stb = data->bNotify2;
  434. } else {
  435. *stb = buffer[2];
  436. }
  437. dev_dbg(dev, "stb:0x%02x received %d\n", (unsigned int)*stb, rv);
  438. exit:
  439. /* bump interrupt bTag */
  440. data->iin_bTag += 1;
  441. if (data->iin_bTag > 127)
  442. /* 1 is for SRQ see USBTMC-USB488 subclass spec section 4.3.1 */
  443. data->iin_bTag = 2;
  444. kfree(buffer);
  445. return rv;
  446. }
  447. static int usbtmc488_ioctl_read_stb(struct usbtmc_file_data *file_data,
  448. void __user *arg)
  449. {
  450. int srq_asserted = 0;
  451. __u8 stb;
  452. int rv;
  453. rv = usbtmc_get_stb(file_data, &stb);
  454. if (rv > 0) {
  455. srq_asserted = atomic_xchg(&file_data->srq_asserted,
  456. srq_asserted);
  457. if (srq_asserted)
  458. stb |= 0x40; /* Set RQS bit */
  459. rv = put_user(stb, (__u8 __user *)arg);
  460. }
  461. return rv;
  462. }
  463. static int usbtmc_ioctl_get_srq_stb(struct usbtmc_file_data *file_data,
  464. void __user *arg)
  465. {
  466. struct usbtmc_device_data *data = file_data->data;
  467. struct device *dev = &data->intf->dev;
  468. int srq_asserted = 0;
  469. __u8 stb = 0;
  470. int rv;
  471. spin_lock_irq(&data->dev_lock);
  472. srq_asserted = atomic_xchg(&file_data->srq_asserted, srq_asserted);
  473. if (srq_asserted) {
  474. stb = file_data->srq_byte;
  475. spin_unlock_irq(&data->dev_lock);
  476. rv = put_user(stb, (__u8 __user *)arg);
  477. } else {
  478. spin_unlock_irq(&data->dev_lock);
  479. rv = -ENOMSG;
  480. }
  481. dev_dbg(dev, "stb:0x%02x with srq received %d\n", (unsigned int)stb, rv);
  482. return rv;
  483. }
  484. static int usbtmc488_ioctl_wait_srq(struct usbtmc_file_data *file_data,
  485. __u32 __user *arg)
  486. {
  487. struct usbtmc_device_data *data = file_data->data;
  488. struct device *dev = &data->intf->dev;
  489. int rv;
  490. u32 timeout;
  491. unsigned long expire;
  492. if (!data->iin_ep_present) {
  493. dev_dbg(dev, "no interrupt endpoint present\n");
  494. return -EFAULT;
  495. }
  496. if (get_user(timeout, arg))
  497. return -EFAULT;
  498. expire = msecs_to_jiffies(timeout);
  499. mutex_unlock(&data->io_mutex);
  500. rv = wait_event_interruptible_timeout(
  501. data->waitq,
  502. atomic_read(&file_data->srq_asserted) != 0 ||
  503. atomic_read(&file_data->closing),
  504. expire);
  505. mutex_lock(&data->io_mutex);
  506. /* Note! disconnect or close could be called in the meantime */
  507. if (atomic_read(&file_data->closing) || data->zombie)
  508. rv = -ENODEV;
  509. if (rv < 0) {
  510. /* dev can be invalid now! */
  511. pr_debug("%s - wait interrupted %d\n", __func__, rv);
  512. return rv;
  513. }
  514. if (rv == 0) {
  515. dev_dbg(dev, "%s - wait timed out\n", __func__);
  516. return -ETIMEDOUT;
  517. }
  518. dev_dbg(dev, "%s - srq asserted\n", __func__);
  519. return 0;
  520. }
  521. static int usbtmc488_ioctl_simple(struct usbtmc_device_data *data,
  522. void __user *arg, unsigned int cmd)
  523. {
  524. struct device *dev = &data->intf->dev;
  525. __u8 val;
  526. u8 *buffer;
  527. u16 wValue;
  528. int rv;
  529. if (!(data->usb488_caps & USBTMC488_CAPABILITY_SIMPLE))
  530. return -EINVAL;
  531. buffer = kmalloc(8, GFP_KERNEL);
  532. if (!buffer)
  533. return -ENOMEM;
  534. if (cmd == USBTMC488_REQUEST_REN_CONTROL) {
  535. rv = copy_from_user(&val, arg, sizeof(val));
  536. if (rv) {
  537. rv = -EFAULT;
  538. goto exit;
  539. }
  540. wValue = val ? 1 : 0;
  541. } else {
  542. wValue = 0;
  543. }
  544. rv = usb_control_msg(data->usb_dev,
  545. usb_rcvctrlpipe(data->usb_dev, 0),
  546. cmd,
  547. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  548. wValue,
  549. data->ifnum,
  550. buffer, 0x01, USB_CTRL_GET_TIMEOUT);
  551. if (rv < 0) {
  552. dev_err(dev, "simple usb_control_msg failed %d\n", rv);
  553. goto exit;
  554. } else if (rv != 1) {
  555. dev_warn(dev, "simple usb_control_msg returned %d\n", rv);
  556. rv = -EIO;
  557. goto exit;
  558. }
  559. if (buffer[0] != USBTMC_STATUS_SUCCESS) {
  560. dev_err(dev, "simple control status returned %x\n", buffer[0]);
  561. rv = -EIO;
  562. goto exit;
  563. }
  564. rv = 0;
  565. exit:
  566. kfree(buffer);
  567. return rv;
  568. }
  569. /*
  570. * Sends a TRIGGER Bulk-OUT command message
  571. * See the USBTMC-USB488 specification, Table 2.
  572. *
  573. * Also updates bTag_last_write.
  574. */
  575. static int usbtmc488_ioctl_trigger(struct usbtmc_file_data *file_data)
  576. {
  577. struct usbtmc_device_data *data = file_data->data;
  578. int retval;
  579. u8 *buffer;
  580. int actual;
  581. buffer = kzalloc(USBTMC_HEADER_SIZE, GFP_KERNEL);
  582. if (!buffer)
  583. return -ENOMEM;
  584. buffer[0] = 128;
  585. buffer[1] = data->bTag;
  586. buffer[2] = ~data->bTag;
  587. retval = usb_bulk_msg(data->usb_dev,
  588. usb_sndbulkpipe(data->usb_dev,
  589. data->bulk_out),
  590. buffer, USBTMC_HEADER_SIZE,
  591. &actual, file_data->timeout);
  592. /* Store bTag (in case we need to abort) */
  593. data->bTag_last_write = data->bTag;
  594. /* Increment bTag -- and increment again if zero */
  595. data->bTag++;
  596. if (!data->bTag)
  597. data->bTag++;
  598. kfree(buffer);
  599. if (retval < 0) {
  600. dev_err(&data->intf->dev, "%s returned %d\n",
  601. __func__, retval);
  602. return retval;
  603. }
  604. return 0;
  605. }
  606. static struct urb *usbtmc_create_urb(void)
  607. {
  608. const size_t bufsize = USBTMC_BUFSIZE;
  609. u8 *dmabuf = NULL;
  610. struct urb *urb = usb_alloc_urb(0, GFP_KERNEL);
  611. if (!urb)
  612. return NULL;
  613. dmabuf = kmalloc(bufsize, GFP_KERNEL);
  614. if (!dmabuf) {
  615. usb_free_urb(urb);
  616. return NULL;
  617. }
  618. urb->transfer_buffer = dmabuf;
  619. urb->transfer_buffer_length = bufsize;
  620. urb->transfer_flags |= URB_FREE_BUFFER;
  621. return urb;
  622. }
  623. static void usbtmc_read_bulk_cb(struct urb *urb)
  624. {
  625. struct usbtmc_file_data *file_data = urb->context;
  626. int status = urb->status;
  627. unsigned long flags;
  628. /* sync/async unlink faults aren't errors */
  629. if (status) {
  630. if (!(/* status == -ENOENT || */
  631. status == -ECONNRESET ||
  632. status == -EREMOTEIO || /* Short packet */
  633. status == -ESHUTDOWN))
  634. dev_err(&file_data->data->intf->dev,
  635. "%s - nonzero read bulk status received: %d\n",
  636. __func__, status);
  637. spin_lock_irqsave(&file_data->err_lock, flags);
  638. if (!file_data->in_status)
  639. file_data->in_status = status;
  640. spin_unlock_irqrestore(&file_data->err_lock, flags);
  641. }
  642. spin_lock_irqsave(&file_data->err_lock, flags);
  643. file_data->in_transfer_size += urb->actual_length;
  644. dev_dbg(&file_data->data->intf->dev,
  645. "%s - total size: %u current: %d status: %d\n",
  646. __func__, file_data->in_transfer_size,
  647. urb->actual_length, status);
  648. spin_unlock_irqrestore(&file_data->err_lock, flags);
  649. usb_anchor_urb(urb, &file_data->in_anchor);
  650. wake_up_interruptible(&file_data->wait_bulk_in);
  651. wake_up_interruptible(&file_data->data->waitq);
  652. }
  653. static inline bool usbtmc_do_transfer(struct usbtmc_file_data *file_data)
  654. {
  655. bool data_or_error;
  656. spin_lock_irq(&file_data->err_lock);
  657. data_or_error = !usb_anchor_empty(&file_data->in_anchor)
  658. || file_data->in_status;
  659. spin_unlock_irq(&file_data->err_lock);
  660. dev_dbg(&file_data->data->intf->dev, "%s: returns %d\n", __func__,
  661. data_or_error);
  662. return data_or_error;
  663. }
  664. static ssize_t usbtmc_generic_read(struct usbtmc_file_data *file_data,
  665. void __user *user_buffer,
  666. u32 transfer_size,
  667. u32 *transferred,
  668. u32 flags)
  669. {
  670. struct usbtmc_device_data *data = file_data->data;
  671. struct device *dev = &data->intf->dev;
  672. u32 done = 0;
  673. u32 remaining;
  674. const u32 bufsize = USBTMC_BUFSIZE;
  675. int retval = 0;
  676. u32 max_transfer_size;
  677. unsigned long expire;
  678. int bufcount = 1;
  679. int again = 0;
  680. /* mutex already locked */
  681. *transferred = done;
  682. max_transfer_size = transfer_size;
  683. if (flags & USBTMC_FLAG_IGNORE_TRAILER) {
  684. /* The device may send extra alignment bytes (up to
  685. * wMaxPacketSize – 1) to avoid sending a zero-length
  686. * packet
  687. */
  688. remaining = transfer_size;
  689. if ((max_transfer_size % data->wMaxPacketSize) == 0)
  690. max_transfer_size += (data->wMaxPacketSize - 1);
  691. } else {
  692. /* round down to bufsize to avoid truncated data left */
  693. if (max_transfer_size > bufsize) {
  694. max_transfer_size =
  695. roundup(max_transfer_size + 1 - bufsize,
  696. bufsize);
  697. }
  698. remaining = max_transfer_size;
  699. }
  700. spin_lock_irq(&file_data->err_lock);
  701. if (file_data->in_status) {
  702. /* return the very first error */
  703. retval = file_data->in_status;
  704. spin_unlock_irq(&file_data->err_lock);
  705. goto error;
  706. }
  707. if (flags & USBTMC_FLAG_ASYNC) {
  708. if (usb_anchor_empty(&file_data->in_anchor))
  709. again = 1;
  710. if (file_data->in_urbs_used == 0) {
  711. file_data->in_transfer_size = 0;
  712. file_data->in_status = 0;
  713. }
  714. } else {
  715. file_data->in_transfer_size = 0;
  716. file_data->in_status = 0;
  717. }
  718. if (max_transfer_size == 0) {
  719. bufcount = 0;
  720. } else {
  721. bufcount = roundup(max_transfer_size, bufsize) / bufsize;
  722. if (bufcount > file_data->in_urbs_used)
  723. bufcount -= file_data->in_urbs_used;
  724. else
  725. bufcount = 0;
  726. if (bufcount + file_data->in_urbs_used > MAX_URBS_IN_FLIGHT) {
  727. bufcount = MAX_URBS_IN_FLIGHT -
  728. file_data->in_urbs_used;
  729. }
  730. }
  731. spin_unlock_irq(&file_data->err_lock);
  732. dev_dbg(dev, "%s: requested=%u flags=0x%X size=%u bufs=%d used=%d\n",
  733. __func__, transfer_size, flags,
  734. max_transfer_size, bufcount, file_data->in_urbs_used);
  735. while (bufcount > 0) {
  736. u8 *dmabuf = NULL;
  737. struct urb *urb = usbtmc_create_urb();
  738. if (!urb) {
  739. retval = -ENOMEM;
  740. goto error;
  741. }
  742. dmabuf = urb->transfer_buffer;
  743. usb_fill_bulk_urb(urb, data->usb_dev,
  744. usb_rcvbulkpipe(data->usb_dev, data->bulk_in),
  745. dmabuf, bufsize,
  746. usbtmc_read_bulk_cb, file_data);
  747. usb_anchor_urb(urb, &file_data->submitted);
  748. retval = usb_submit_urb(urb, GFP_KERNEL);
  749. /* urb is anchored. We can release our reference. */
  750. usb_free_urb(urb);
  751. if (unlikely(retval)) {
  752. usb_unanchor_urb(urb);
  753. goto error;
  754. }
  755. file_data->in_urbs_used++;
  756. bufcount--;
  757. }
  758. if (again) {
  759. dev_dbg(dev, "%s: ret=again\n", __func__);
  760. return -EAGAIN;
  761. }
  762. if (user_buffer == NULL)
  763. return -EINVAL;
  764. expire = msecs_to_jiffies(file_data->timeout);
  765. while (max_transfer_size > 0) {
  766. u32 this_part;
  767. struct urb *urb = NULL;
  768. if (!(flags & USBTMC_FLAG_ASYNC)) {
  769. dev_dbg(dev, "%s: before wait time %lu\n",
  770. __func__, expire);
  771. retval = wait_event_interruptible_timeout(
  772. file_data->wait_bulk_in,
  773. usbtmc_do_transfer(file_data),
  774. expire);
  775. dev_dbg(dev, "%s: wait returned %d\n",
  776. __func__, retval);
  777. if (retval <= 0) {
  778. if (retval == 0)
  779. retval = -ETIMEDOUT;
  780. goto error;
  781. }
  782. }
  783. urb = usb_get_from_anchor(&file_data->in_anchor);
  784. if (!urb) {
  785. if (!(flags & USBTMC_FLAG_ASYNC)) {
  786. /* synchronous case: must not happen */
  787. retval = -EFAULT;
  788. goto error;
  789. }
  790. /* asynchronous case: ready, do not block or wait */
  791. *transferred = done;
  792. dev_dbg(dev, "%s: (async) done=%u ret=0\n",
  793. __func__, done);
  794. return 0;
  795. }
  796. file_data->in_urbs_used--;
  797. if (max_transfer_size > urb->actual_length)
  798. max_transfer_size -= urb->actual_length;
  799. else
  800. max_transfer_size = 0;
  801. if (remaining > urb->actual_length)
  802. this_part = urb->actual_length;
  803. else
  804. this_part = remaining;
  805. print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE, 16, 1,
  806. urb->transfer_buffer, urb->actual_length, true);
  807. if (copy_to_user(user_buffer + done,
  808. urb->transfer_buffer, this_part)) {
  809. usb_free_urb(urb);
  810. retval = -EFAULT;
  811. goto error;
  812. }
  813. remaining -= this_part;
  814. done += this_part;
  815. spin_lock_irq(&file_data->err_lock);
  816. if (urb->status) {
  817. /* return the very first error */
  818. retval = file_data->in_status;
  819. spin_unlock_irq(&file_data->err_lock);
  820. usb_free_urb(urb);
  821. goto error;
  822. }
  823. spin_unlock_irq(&file_data->err_lock);
  824. if (urb->actual_length < bufsize) {
  825. /* short packet or ZLP received => ready */
  826. usb_free_urb(urb);
  827. retval = 1;
  828. break;
  829. }
  830. if (!(flags & USBTMC_FLAG_ASYNC) &&
  831. max_transfer_size > (bufsize * file_data->in_urbs_used)) {
  832. /* resubmit, since other buffers still not enough */
  833. usb_anchor_urb(urb, &file_data->submitted);
  834. retval = usb_submit_urb(urb, GFP_KERNEL);
  835. if (unlikely(retval)) {
  836. usb_unanchor_urb(urb);
  837. usb_free_urb(urb);
  838. goto error;
  839. }
  840. file_data->in_urbs_used++;
  841. }
  842. usb_free_urb(urb);
  843. retval = 0;
  844. }
  845. error:
  846. *transferred = done;
  847. dev_dbg(dev, "%s: before kill\n", __func__);
  848. /* Attention: killing urbs can take long time (2 ms) */
  849. usb_kill_anchored_urbs(&file_data->submitted);
  850. dev_dbg(dev, "%s: after kill\n", __func__);
  851. usb_scuttle_anchored_urbs(&file_data->in_anchor);
  852. file_data->in_urbs_used = 0;
  853. file_data->in_status = 0; /* no spinlock needed here */
  854. dev_dbg(dev, "%s: done=%u ret=%d\n", __func__, done, retval);
  855. return retval;
  856. }
  857. static ssize_t usbtmc_ioctl_generic_read(struct usbtmc_file_data *file_data,
  858. void __user *arg)
  859. {
  860. struct usbtmc_message msg;
  861. ssize_t retval = 0;
  862. /* mutex already locked */
  863. if (copy_from_user(&msg, arg, sizeof(struct usbtmc_message)))
  864. return -EFAULT;
  865. retval = usbtmc_generic_read(file_data, msg.message,
  866. msg.transfer_size, &msg.transferred,
  867. msg.flags);
  868. if (put_user(msg.transferred,
  869. &((struct usbtmc_message __user *)arg)->transferred))
  870. return -EFAULT;
  871. return retval;
  872. }
  873. static void usbtmc_write_bulk_cb(struct urb *urb)
  874. {
  875. struct usbtmc_file_data *file_data = urb->context;
  876. int wakeup = 0;
  877. unsigned long flags;
  878. spin_lock_irqsave(&file_data->err_lock, flags);
  879. file_data->out_transfer_size += urb->actual_length;
  880. /* sync/async unlink faults aren't errors */
  881. if (urb->status) {
  882. if (!(urb->status == -ENOENT ||
  883. urb->status == -ECONNRESET ||
  884. urb->status == -ESHUTDOWN))
  885. dev_err(&file_data->data->intf->dev,
  886. "%s - nonzero write bulk status received: %d\n",
  887. __func__, urb->status);
  888. if (!file_data->out_status) {
  889. file_data->out_status = urb->status;
  890. wakeup = 1;
  891. }
  892. }
  893. spin_unlock_irqrestore(&file_data->err_lock, flags);
  894. dev_dbg(&file_data->data->intf->dev,
  895. "%s - write bulk total size: %u\n",
  896. __func__, file_data->out_transfer_size);
  897. up(&file_data->limit_write_sem);
  898. if (usb_anchor_empty(&file_data->submitted) || wakeup)
  899. wake_up_interruptible(&file_data->data->waitq);
  900. }
  901. static ssize_t usbtmc_generic_write(struct usbtmc_file_data *file_data,
  902. const void __user *user_buffer,
  903. u32 transfer_size,
  904. u32 *transferred,
  905. u32 flags)
  906. {
  907. struct usbtmc_device_data *data = file_data->data;
  908. struct device *dev;
  909. u32 done = 0;
  910. u32 remaining;
  911. unsigned long expire;
  912. const u32 bufsize = USBTMC_BUFSIZE;
  913. struct urb *urb = NULL;
  914. int retval = 0;
  915. u32 timeout;
  916. *transferred = 0;
  917. /* Get pointer to private data structure */
  918. dev = &data->intf->dev;
  919. dev_dbg(dev, "%s: size=%u flags=0x%X sema=%u\n",
  920. __func__, transfer_size, flags,
  921. file_data->limit_write_sem.count);
  922. if (flags & USBTMC_FLAG_APPEND) {
  923. spin_lock_irq(&file_data->err_lock);
  924. retval = file_data->out_status;
  925. spin_unlock_irq(&file_data->err_lock);
  926. if (retval < 0)
  927. return retval;
  928. } else {
  929. spin_lock_irq(&file_data->err_lock);
  930. file_data->out_transfer_size = 0;
  931. file_data->out_status = 0;
  932. spin_unlock_irq(&file_data->err_lock);
  933. }
  934. remaining = transfer_size;
  935. if (remaining > INT_MAX)
  936. remaining = INT_MAX;
  937. timeout = file_data->timeout;
  938. expire = msecs_to_jiffies(timeout);
  939. while (remaining > 0) {
  940. u32 this_part, aligned;
  941. u8 *buffer = NULL;
  942. if (flags & USBTMC_FLAG_ASYNC) {
  943. if (down_trylock(&file_data->limit_write_sem)) {
  944. retval = (done)?(0):(-EAGAIN);
  945. goto exit;
  946. }
  947. } else {
  948. retval = down_timeout(&file_data->limit_write_sem,
  949. expire);
  950. if (retval < 0) {
  951. retval = -ETIMEDOUT;
  952. goto error;
  953. }
  954. }
  955. spin_lock_irq(&file_data->err_lock);
  956. retval = file_data->out_status;
  957. spin_unlock_irq(&file_data->err_lock);
  958. if (retval < 0) {
  959. up(&file_data->limit_write_sem);
  960. goto error;
  961. }
  962. /* prepare next urb to send */
  963. urb = usbtmc_create_urb();
  964. if (!urb) {
  965. retval = -ENOMEM;
  966. up(&file_data->limit_write_sem);
  967. goto error;
  968. }
  969. buffer = urb->transfer_buffer;
  970. if (remaining > bufsize)
  971. this_part = bufsize;
  972. else
  973. this_part = remaining;
  974. if (copy_from_user(buffer, user_buffer + done, this_part)) {
  975. retval = -EFAULT;
  976. up(&file_data->limit_write_sem);
  977. goto error;
  978. }
  979. print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE,
  980. 16, 1, buffer, this_part, true);
  981. /* fill bulk with 32 bit alignment to meet USBTMC specification
  982. * (size + 3 & ~3) rounds up and simplifies user code
  983. */
  984. aligned = (this_part + 3) & ~3;
  985. dev_dbg(dev, "write(size:%u align:%u done:%u)\n",
  986. (unsigned int)this_part,
  987. (unsigned int)aligned,
  988. (unsigned int)done);
  989. usb_fill_bulk_urb(urb, data->usb_dev,
  990. usb_sndbulkpipe(data->usb_dev, data->bulk_out),
  991. urb->transfer_buffer, aligned,
  992. usbtmc_write_bulk_cb, file_data);
  993. usb_anchor_urb(urb, &file_data->submitted);
  994. retval = usb_submit_urb(urb, GFP_KERNEL);
  995. if (unlikely(retval)) {
  996. usb_unanchor_urb(urb);
  997. up(&file_data->limit_write_sem);
  998. goto error;
  999. }
  1000. usb_free_urb(urb);
  1001. urb = NULL; /* urb will be finally released by usb driver */
  1002. remaining -= this_part;
  1003. done += this_part;
  1004. }
  1005. /* All urbs are on the fly */
  1006. if (!(flags & USBTMC_FLAG_ASYNC)) {
  1007. if (!usb_wait_anchor_empty_timeout(&file_data->submitted,
  1008. timeout)) {
  1009. retval = -ETIMEDOUT;
  1010. goto error;
  1011. }
  1012. }
  1013. retval = 0;
  1014. goto exit;
  1015. error:
  1016. usb_kill_anchored_urbs(&file_data->submitted);
  1017. exit:
  1018. usb_free_urb(urb);
  1019. spin_lock_irq(&file_data->err_lock);
  1020. if (!(flags & USBTMC_FLAG_ASYNC))
  1021. done = file_data->out_transfer_size;
  1022. if (!retval && file_data->out_status)
  1023. retval = file_data->out_status;
  1024. spin_unlock_irq(&file_data->err_lock);
  1025. *transferred = done;
  1026. dev_dbg(dev, "%s: done=%u, retval=%d, urbstat=%d\n",
  1027. __func__, done, retval, file_data->out_status);
  1028. return retval;
  1029. }
  1030. static ssize_t usbtmc_ioctl_generic_write(struct usbtmc_file_data *file_data,
  1031. void __user *arg)
  1032. {
  1033. struct usbtmc_message msg;
  1034. ssize_t retval = 0;
  1035. /* mutex already locked */
  1036. if (copy_from_user(&msg, arg, sizeof(struct usbtmc_message)))
  1037. return -EFAULT;
  1038. retval = usbtmc_generic_write(file_data, msg.message,
  1039. msg.transfer_size, &msg.transferred,
  1040. msg.flags);
  1041. if (put_user(msg.transferred,
  1042. &((struct usbtmc_message __user *)arg)->transferred))
  1043. return -EFAULT;
  1044. return retval;
  1045. }
  1046. /*
  1047. * Get the generic write result
  1048. */
  1049. static ssize_t usbtmc_ioctl_write_result(struct usbtmc_file_data *file_data,
  1050. void __user *arg)
  1051. {
  1052. u32 transferred;
  1053. int retval;
  1054. spin_lock_irq(&file_data->err_lock);
  1055. transferred = file_data->out_transfer_size;
  1056. retval = file_data->out_status;
  1057. spin_unlock_irq(&file_data->err_lock);
  1058. if (put_user(transferred, (__u32 __user *)arg))
  1059. return -EFAULT;
  1060. return retval;
  1061. }
  1062. /*
  1063. * Sends a REQUEST_DEV_DEP_MSG_IN message on the Bulk-OUT endpoint.
  1064. * @transfer_size: number of bytes to request from the device.
  1065. *
  1066. * See the USBTMC specification, Table 4.
  1067. *
  1068. * Also updates bTag_last_write.
  1069. */
  1070. static int send_request_dev_dep_msg_in(struct usbtmc_file_data *file_data,
  1071. u32 transfer_size)
  1072. {
  1073. struct usbtmc_device_data *data = file_data->data;
  1074. int retval;
  1075. u8 *buffer;
  1076. int actual;
  1077. buffer = kmalloc(USBTMC_HEADER_SIZE, GFP_KERNEL);
  1078. if (!buffer)
  1079. return -ENOMEM;
  1080. /* Setup IO buffer for REQUEST_DEV_DEP_MSG_IN message
  1081. * Refer to class specs for details
  1082. */
  1083. buffer[0] = 2;
  1084. buffer[1] = data->bTag;
  1085. buffer[2] = ~data->bTag;
  1086. buffer[3] = 0; /* Reserved */
  1087. buffer[4] = transfer_size >> 0;
  1088. buffer[5] = transfer_size >> 8;
  1089. buffer[6] = transfer_size >> 16;
  1090. buffer[7] = transfer_size >> 24;
  1091. buffer[8] = file_data->term_char_enabled * 2;
  1092. /* Use term character? */
  1093. buffer[9] = file_data->term_char;
  1094. buffer[10] = 0; /* Reserved */
  1095. buffer[11] = 0; /* Reserved */
  1096. /* Send bulk URB */
  1097. retval = usb_bulk_msg(data->usb_dev,
  1098. usb_sndbulkpipe(data->usb_dev,
  1099. data->bulk_out),
  1100. buffer, USBTMC_HEADER_SIZE,
  1101. &actual, file_data->timeout);
  1102. /* Store bTag (in case we need to abort) */
  1103. data->bTag_last_write = data->bTag;
  1104. /* Increment bTag -- and increment again if zero */
  1105. data->bTag++;
  1106. if (!data->bTag)
  1107. data->bTag++;
  1108. kfree(buffer);
  1109. if (retval < 0)
  1110. dev_err(&data->intf->dev, "%s returned %d\n",
  1111. __func__, retval);
  1112. return retval;
  1113. }
  1114. static ssize_t usbtmc_read(struct file *filp, char __user *buf,
  1115. size_t count, loff_t *f_pos)
  1116. {
  1117. struct usbtmc_file_data *file_data;
  1118. struct usbtmc_device_data *data;
  1119. struct device *dev;
  1120. const u32 bufsize = USBTMC_BUFSIZE;
  1121. u32 n_characters;
  1122. u8 *buffer;
  1123. int actual;
  1124. u32 done = 0;
  1125. u32 remaining;
  1126. int retval;
  1127. /* Get pointer to private data structure */
  1128. file_data = filp->private_data;
  1129. data = file_data->data;
  1130. dev = &data->intf->dev;
  1131. buffer = kmalloc(bufsize, GFP_KERNEL);
  1132. if (!buffer)
  1133. return -ENOMEM;
  1134. mutex_lock(&data->io_mutex);
  1135. if (data->zombie) {
  1136. retval = -ENODEV;
  1137. goto exit;
  1138. }
  1139. if (count > INT_MAX)
  1140. count = INT_MAX;
  1141. dev_dbg(dev, "%s(count:%zu)\n", __func__, count);
  1142. retval = send_request_dev_dep_msg_in(file_data, count);
  1143. if (retval < 0) {
  1144. if (file_data->auto_abort)
  1145. usbtmc_ioctl_abort_bulk_out(data);
  1146. goto exit;
  1147. }
  1148. /* Loop until we have fetched everything we requested */
  1149. remaining = count;
  1150. actual = 0;
  1151. /* Send bulk URB */
  1152. retval = usb_bulk_msg(data->usb_dev,
  1153. usb_rcvbulkpipe(data->usb_dev,
  1154. data->bulk_in),
  1155. buffer, bufsize, &actual,
  1156. file_data->timeout);
  1157. dev_dbg(dev, "%s: bulk_msg retval(%u), actual(%d)\n",
  1158. __func__, retval, actual);
  1159. /* Store bTag (in case we need to abort) */
  1160. data->bTag_last_read = data->bTag;
  1161. if (retval < 0) {
  1162. if (file_data->auto_abort)
  1163. usbtmc_ioctl_abort_bulk_in(data);
  1164. goto exit;
  1165. }
  1166. /* Sanity checks for the header */
  1167. if (actual < USBTMC_HEADER_SIZE) {
  1168. dev_err(dev, "Device sent too small first packet: %u < %u\n",
  1169. actual, USBTMC_HEADER_SIZE);
  1170. if (file_data->auto_abort)
  1171. usbtmc_ioctl_abort_bulk_in(data);
  1172. goto exit;
  1173. }
  1174. if (buffer[0] != 2) {
  1175. dev_err(dev, "Device sent reply with wrong MsgID: %u != 2\n",
  1176. buffer[0]);
  1177. if (file_data->auto_abort)
  1178. usbtmc_ioctl_abort_bulk_in(data);
  1179. goto exit;
  1180. }
  1181. if (buffer[1] != data->bTag_last_write) {
  1182. dev_err(dev, "Device sent reply with wrong bTag: %u != %u\n",
  1183. buffer[1], data->bTag_last_write);
  1184. if (file_data->auto_abort)
  1185. usbtmc_ioctl_abort_bulk_in(data);
  1186. goto exit;
  1187. }
  1188. /* How many characters did the instrument send? */
  1189. n_characters = buffer[4] +
  1190. (buffer[5] << 8) +
  1191. (buffer[6] << 16) +
  1192. (buffer[7] << 24);
  1193. file_data->bmTransferAttributes = buffer[8];
  1194. dev_dbg(dev, "Bulk-IN header: N_characters(%u), bTransAttr(%u)\n",
  1195. n_characters, buffer[8]);
  1196. if (n_characters > remaining) {
  1197. dev_err(dev, "Device wants to return more data than requested: %u > %zu\n",
  1198. n_characters, count);
  1199. if (file_data->auto_abort)
  1200. usbtmc_ioctl_abort_bulk_in(data);
  1201. goto exit;
  1202. }
  1203. print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE,
  1204. 16, 1, buffer, actual, true);
  1205. remaining = n_characters;
  1206. /* Remove the USBTMC header */
  1207. actual -= USBTMC_HEADER_SIZE;
  1208. /* Remove padding if it exists */
  1209. if (actual > remaining)
  1210. actual = remaining;
  1211. remaining -= actual;
  1212. /* Copy buffer to user space */
  1213. if (copy_to_user(buf, &buffer[USBTMC_HEADER_SIZE], actual)) {
  1214. /* There must have been an addressing problem */
  1215. retval = -EFAULT;
  1216. goto exit;
  1217. }
  1218. if ((actual + USBTMC_HEADER_SIZE) == bufsize) {
  1219. retval = usbtmc_generic_read(file_data, buf + actual,
  1220. remaining,
  1221. &done,
  1222. USBTMC_FLAG_IGNORE_TRAILER);
  1223. if (retval < 0)
  1224. goto exit;
  1225. }
  1226. done += actual;
  1227. /* Update file position value */
  1228. *f_pos = *f_pos + done;
  1229. retval = done;
  1230. exit:
  1231. mutex_unlock(&data->io_mutex);
  1232. kfree(buffer);
  1233. return retval;
  1234. }
  1235. static ssize_t usbtmc_write(struct file *filp, const char __user *buf,
  1236. size_t count, loff_t *f_pos)
  1237. {
  1238. struct usbtmc_file_data *file_data;
  1239. struct usbtmc_device_data *data;
  1240. struct urb *urb = NULL;
  1241. ssize_t retval = 0;
  1242. u8 *buffer;
  1243. u32 remaining, done;
  1244. u32 transfersize, aligned, buflen;
  1245. file_data = filp->private_data;
  1246. data = file_data->data;
  1247. mutex_lock(&data->io_mutex);
  1248. if (data->zombie) {
  1249. retval = -ENODEV;
  1250. goto exit;
  1251. }
  1252. done = 0;
  1253. spin_lock_irq(&file_data->err_lock);
  1254. file_data->out_transfer_size = 0;
  1255. file_data->out_status = 0;
  1256. spin_unlock_irq(&file_data->err_lock);
  1257. if (!count)
  1258. goto exit;
  1259. if (down_trylock(&file_data->limit_write_sem)) {
  1260. /* previous calls were async */
  1261. retval = -EBUSY;
  1262. goto exit;
  1263. }
  1264. urb = usbtmc_create_urb();
  1265. if (!urb) {
  1266. retval = -ENOMEM;
  1267. up(&file_data->limit_write_sem);
  1268. goto exit;
  1269. }
  1270. buffer = urb->transfer_buffer;
  1271. buflen = urb->transfer_buffer_length;
  1272. if (count > INT_MAX) {
  1273. transfersize = INT_MAX;
  1274. buffer[8] = 0;
  1275. } else {
  1276. transfersize = count;
  1277. buffer[8] = file_data->eom_val;
  1278. }
  1279. /* Setup IO buffer for DEV_DEP_MSG_OUT message */
  1280. buffer[0] = 1;
  1281. buffer[1] = data->bTag;
  1282. buffer[2] = ~data->bTag;
  1283. buffer[3] = 0; /* Reserved */
  1284. buffer[4] = transfersize >> 0;
  1285. buffer[5] = transfersize >> 8;
  1286. buffer[6] = transfersize >> 16;
  1287. buffer[7] = transfersize >> 24;
  1288. /* buffer[8] is set above... */
  1289. buffer[9] = 0; /* Reserved */
  1290. buffer[10] = 0; /* Reserved */
  1291. buffer[11] = 0; /* Reserved */
  1292. remaining = transfersize;
  1293. if (transfersize + USBTMC_HEADER_SIZE > buflen) {
  1294. transfersize = buflen - USBTMC_HEADER_SIZE;
  1295. aligned = buflen;
  1296. } else {
  1297. aligned = (transfersize + (USBTMC_HEADER_SIZE + 3)) & ~3;
  1298. }
  1299. if (copy_from_user(&buffer[USBTMC_HEADER_SIZE], buf, transfersize)) {
  1300. retval = -EFAULT;
  1301. up(&file_data->limit_write_sem);
  1302. goto exit;
  1303. }
  1304. dev_dbg(&data->intf->dev, "%s(size:%u align:%u)\n", __func__,
  1305. (unsigned int)transfersize, (unsigned int)aligned);
  1306. print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE,
  1307. 16, 1, buffer, aligned, true);
  1308. usb_fill_bulk_urb(urb, data->usb_dev,
  1309. usb_sndbulkpipe(data->usb_dev, data->bulk_out),
  1310. urb->transfer_buffer, aligned,
  1311. usbtmc_write_bulk_cb, file_data);
  1312. usb_anchor_urb(urb, &file_data->submitted);
  1313. retval = usb_submit_urb(urb, GFP_KERNEL);
  1314. if (unlikely(retval)) {
  1315. usb_unanchor_urb(urb);
  1316. up(&file_data->limit_write_sem);
  1317. goto exit;
  1318. }
  1319. remaining -= transfersize;
  1320. data->bTag_last_write = data->bTag;
  1321. data->bTag++;
  1322. if (!data->bTag)
  1323. data->bTag++;
  1324. /* call generic_write even when remaining = 0 */
  1325. retval = usbtmc_generic_write(file_data, buf + transfersize, remaining,
  1326. &done, USBTMC_FLAG_APPEND);
  1327. /* truncate alignment bytes */
  1328. if (done > remaining)
  1329. done = remaining;
  1330. /*add size of first urb*/
  1331. done += transfersize;
  1332. if (retval < 0) {
  1333. usb_kill_anchored_urbs(&file_data->submitted);
  1334. dev_err(&data->intf->dev,
  1335. "Unable to send data, error %d\n", (int)retval);
  1336. if (file_data->auto_abort)
  1337. usbtmc_ioctl_abort_bulk_out(data);
  1338. goto exit;
  1339. }
  1340. retval = done;
  1341. exit:
  1342. usb_free_urb(urb);
  1343. mutex_unlock(&data->io_mutex);
  1344. return retval;
  1345. }
  1346. static int usbtmc_ioctl_clear(struct usbtmc_device_data *data)
  1347. {
  1348. struct device *dev;
  1349. u8 *buffer;
  1350. int rv;
  1351. int n;
  1352. int actual = 0;
  1353. dev = &data->intf->dev;
  1354. dev_dbg(dev, "Sending INITIATE_CLEAR request\n");
  1355. buffer = kmalloc(USBTMC_BUFSIZE, GFP_KERNEL);
  1356. if (!buffer)
  1357. return -ENOMEM;
  1358. rv = usb_control_msg(data->usb_dev,
  1359. usb_rcvctrlpipe(data->usb_dev, 0),
  1360. USBTMC_REQUEST_INITIATE_CLEAR,
  1361. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  1362. 0, 0, buffer, 1, USB_CTRL_GET_TIMEOUT);
  1363. if (rv < 0) {
  1364. dev_err(dev, "usb_control_msg returned %d\n", rv);
  1365. goto exit;
  1366. }
  1367. dev_dbg(dev, "INITIATE_CLEAR returned %x\n", buffer[0]);
  1368. if (buffer[0] != USBTMC_STATUS_SUCCESS) {
  1369. dev_err(dev, "INITIATE_CLEAR returned %x\n", buffer[0]);
  1370. rv = -EPERM;
  1371. goto exit;
  1372. }
  1373. n = 0;
  1374. usbtmc_clear_check_status:
  1375. dev_dbg(dev, "Sending CHECK_CLEAR_STATUS request\n");
  1376. rv = usb_control_msg(data->usb_dev,
  1377. usb_rcvctrlpipe(data->usb_dev, 0),
  1378. USBTMC_REQUEST_CHECK_CLEAR_STATUS,
  1379. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  1380. 0, 0, buffer, 2, USB_CTRL_GET_TIMEOUT);
  1381. if (rv < 0) {
  1382. dev_err(dev, "usb_control_msg returned %d\n", rv);
  1383. goto exit;
  1384. }
  1385. dev_dbg(dev, "CHECK_CLEAR_STATUS returned %x\n", buffer[0]);
  1386. if (buffer[0] == USBTMC_STATUS_SUCCESS)
  1387. goto usbtmc_clear_bulk_out_halt;
  1388. if (buffer[0] != USBTMC_STATUS_PENDING) {
  1389. dev_err(dev, "CHECK_CLEAR_STATUS returned %x\n", buffer[0]);
  1390. rv = -EPERM;
  1391. goto exit;
  1392. }
  1393. if ((buffer[1] & 1) != 0) {
  1394. do {
  1395. dev_dbg(dev, "Reading from bulk in EP\n");
  1396. actual = 0;
  1397. rv = usb_bulk_msg(data->usb_dev,
  1398. usb_rcvbulkpipe(data->usb_dev,
  1399. data->bulk_in),
  1400. buffer, USBTMC_BUFSIZE,
  1401. &actual, USB_CTRL_GET_TIMEOUT);
  1402. print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE,
  1403. 16, 1, buffer, actual, true);
  1404. n++;
  1405. if (rv < 0) {
  1406. dev_err(dev, "usb_control_msg returned %d\n",
  1407. rv);
  1408. goto exit;
  1409. }
  1410. } while ((actual == USBTMC_BUFSIZE) &&
  1411. (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));
  1412. } else {
  1413. /* do not stress device with subsequent requests */
  1414. msleep(50);
  1415. n++;
  1416. }
  1417. if (n >= USBTMC_MAX_READS_TO_CLEAR_BULK_IN) {
  1418. dev_err(dev, "Couldn't clear device buffer within %d cycles\n",
  1419. USBTMC_MAX_READS_TO_CLEAR_BULK_IN);
  1420. rv = -EPERM;
  1421. goto exit;
  1422. }
  1423. goto usbtmc_clear_check_status;
  1424. usbtmc_clear_bulk_out_halt:
  1425. rv = usb_clear_halt(data->usb_dev,
  1426. usb_sndbulkpipe(data->usb_dev, data->bulk_out));
  1427. if (rv < 0) {
  1428. dev_err(dev, "usb_clear_halt returned %d\n", rv);
  1429. goto exit;
  1430. }
  1431. rv = 0;
  1432. exit:
  1433. kfree(buffer);
  1434. return rv;
  1435. }
  1436. static int usbtmc_ioctl_clear_out_halt(struct usbtmc_device_data *data)
  1437. {
  1438. int rv;
  1439. rv = usb_clear_halt(data->usb_dev,
  1440. usb_sndbulkpipe(data->usb_dev, data->bulk_out));
  1441. if (rv < 0)
  1442. dev_err(&data->usb_dev->dev, "%s returned %d\n", __func__, rv);
  1443. return rv;
  1444. }
  1445. static int usbtmc_ioctl_clear_in_halt(struct usbtmc_device_data *data)
  1446. {
  1447. int rv;
  1448. rv = usb_clear_halt(data->usb_dev,
  1449. usb_rcvbulkpipe(data->usb_dev, data->bulk_in));
  1450. if (rv < 0)
  1451. dev_err(&data->usb_dev->dev, "%s returned %d\n", __func__, rv);
  1452. return rv;
  1453. }
  1454. static int usbtmc_ioctl_cancel_io(struct usbtmc_file_data *file_data)
  1455. {
  1456. spin_lock_irq(&file_data->err_lock);
  1457. file_data->in_status = -ECANCELED;
  1458. file_data->out_status = -ECANCELED;
  1459. spin_unlock_irq(&file_data->err_lock);
  1460. usb_kill_anchored_urbs(&file_data->submitted);
  1461. return 0;
  1462. }
  1463. static int usbtmc_ioctl_cleanup_io(struct usbtmc_file_data *file_data)
  1464. {
  1465. usb_kill_anchored_urbs(&file_data->submitted);
  1466. usb_scuttle_anchored_urbs(&file_data->in_anchor);
  1467. spin_lock_irq(&file_data->err_lock);
  1468. file_data->in_status = 0;
  1469. file_data->in_transfer_size = 0;
  1470. file_data->out_status = 0;
  1471. file_data->out_transfer_size = 0;
  1472. spin_unlock_irq(&file_data->err_lock);
  1473. file_data->in_urbs_used = 0;
  1474. return 0;
  1475. }
  1476. static int get_capabilities(struct usbtmc_device_data *data)
  1477. {
  1478. struct device *dev = &data->usb_dev->dev;
  1479. char *buffer;
  1480. int rv = 0;
  1481. buffer = kmalloc(0x18, GFP_KERNEL);
  1482. if (!buffer)
  1483. return -ENOMEM;
  1484. rv = usb_control_msg(data->usb_dev, usb_rcvctrlpipe(data->usb_dev, 0),
  1485. USBTMC_REQUEST_GET_CAPABILITIES,
  1486. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  1487. 0, 0, buffer, 0x18, USB_CTRL_GET_TIMEOUT);
  1488. if (rv < 0) {
  1489. dev_err(dev, "usb_control_msg returned %d\n", rv);
  1490. goto err_out;
  1491. }
  1492. dev_dbg(dev, "GET_CAPABILITIES returned %x\n", buffer[0]);
  1493. if (buffer[0] != USBTMC_STATUS_SUCCESS) {
  1494. dev_err(dev, "GET_CAPABILITIES returned %x\n", buffer[0]);
  1495. rv = -EPERM;
  1496. goto err_out;
  1497. }
  1498. dev_dbg(dev, "Interface capabilities are %x\n", buffer[4]);
  1499. dev_dbg(dev, "Device capabilities are %x\n", buffer[5]);
  1500. dev_dbg(dev, "USB488 interface capabilities are %x\n", buffer[14]);
  1501. dev_dbg(dev, "USB488 device capabilities are %x\n", buffer[15]);
  1502. data->capabilities.interface_capabilities = buffer[4];
  1503. data->capabilities.device_capabilities = buffer[5];
  1504. data->capabilities.usb488_interface_capabilities = buffer[14];
  1505. data->capabilities.usb488_device_capabilities = buffer[15];
  1506. data->usb488_caps = (buffer[14] & 0x07) | ((buffer[15] & 0x0f) << 4);
  1507. rv = 0;
  1508. err_out:
  1509. kfree(buffer);
  1510. return rv;
  1511. }
  1512. #define capability_attribute(name) \
  1513. static ssize_t name##_show(struct device *dev, \
  1514. struct device_attribute *attr, char *buf) \
  1515. { \
  1516. struct usb_interface *intf = to_usb_interface(dev); \
  1517. struct usbtmc_device_data *data = usb_get_intfdata(intf); \
  1518. \
  1519. return sprintf(buf, "%d\n", data->capabilities.name); \
  1520. } \
  1521. static DEVICE_ATTR_RO(name)
  1522. capability_attribute(interface_capabilities);
  1523. capability_attribute(device_capabilities);
  1524. capability_attribute(usb488_interface_capabilities);
  1525. capability_attribute(usb488_device_capabilities);
  1526. static struct attribute *usbtmc_attrs[] = {
  1527. &dev_attr_interface_capabilities.attr,
  1528. &dev_attr_device_capabilities.attr,
  1529. &dev_attr_usb488_interface_capabilities.attr,
  1530. &dev_attr_usb488_device_capabilities.attr,
  1531. NULL,
  1532. };
  1533. ATTRIBUTE_GROUPS(usbtmc);
  1534. static int usbtmc_ioctl_indicator_pulse(struct usbtmc_device_data *data)
  1535. {
  1536. struct device *dev;
  1537. u8 *buffer;
  1538. int rv;
  1539. dev = &data->intf->dev;
  1540. buffer = kmalloc(2, GFP_KERNEL);
  1541. if (!buffer)
  1542. return -ENOMEM;
  1543. rv = usb_control_msg(data->usb_dev,
  1544. usb_rcvctrlpipe(data->usb_dev, 0),
  1545. USBTMC_REQUEST_INDICATOR_PULSE,
  1546. USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  1547. 0, 0, buffer, 0x01, USB_CTRL_GET_TIMEOUT);
  1548. if (rv < 0) {
  1549. dev_err(dev, "usb_control_msg returned %d\n", rv);
  1550. goto exit;
  1551. }
  1552. dev_dbg(dev, "INDICATOR_PULSE returned %x\n", buffer[0]);
  1553. if (buffer[0] != USBTMC_STATUS_SUCCESS) {
  1554. dev_err(dev, "INDICATOR_PULSE returned %x\n", buffer[0]);
  1555. rv = -EPERM;
  1556. goto exit;
  1557. }
  1558. rv = 0;
  1559. exit:
  1560. kfree(buffer);
  1561. return rv;
  1562. }
  1563. static int usbtmc_ioctl_request(struct usbtmc_device_data *data,
  1564. void __user *arg)
  1565. {
  1566. struct device *dev = &data->intf->dev;
  1567. struct usbtmc_ctrlrequest request;
  1568. u8 *buffer = NULL;
  1569. int rv;
  1570. unsigned int is_in, pipe;
  1571. unsigned long res;
  1572. res = copy_from_user(&request, arg, sizeof(struct usbtmc_ctrlrequest));
  1573. if (res)
  1574. return -EFAULT;
  1575. if (request.req.wLength > USBTMC_BUFSIZE)
  1576. return -EMSGSIZE;
  1577. if (request.req.wLength == 0) /* Length-0 requests are never IN */
  1578. request.req.bRequestType &= ~USB_DIR_IN;
  1579. is_in = request.req.bRequestType & USB_DIR_IN;
  1580. if (request.req.wLength) {
  1581. buffer = kmalloc(request.req.wLength, GFP_KERNEL);
  1582. if (!buffer)
  1583. return -ENOMEM;
  1584. if (!is_in) {
  1585. /* Send control data to device */
  1586. res = copy_from_user(buffer, request.data,
  1587. request.req.wLength);
  1588. if (res) {
  1589. rv = -EFAULT;
  1590. goto exit;
  1591. }
  1592. }
  1593. }
  1594. if (is_in)
  1595. pipe = usb_rcvctrlpipe(data->usb_dev, 0);
  1596. else
  1597. pipe = usb_sndctrlpipe(data->usb_dev, 0);
  1598. rv = usb_control_msg(data->usb_dev,
  1599. pipe,
  1600. request.req.bRequest,
  1601. request.req.bRequestType,
  1602. request.req.wValue,
  1603. request.req.wIndex,
  1604. buffer, request.req.wLength, USB_CTRL_GET_TIMEOUT);
  1605. if (rv < 0) {
  1606. dev_err(dev, "%s failed %d\n", __func__, rv);
  1607. goto exit;
  1608. }
  1609. if (rv && is_in) {
  1610. /* Read control data from device */
  1611. res = copy_to_user(request.data, buffer, rv);
  1612. if (res)
  1613. rv = -EFAULT;
  1614. }
  1615. exit:
  1616. kfree(buffer);
  1617. return rv;
  1618. }
  1619. /*
  1620. * Get the usb timeout value
  1621. */
  1622. static int usbtmc_ioctl_get_timeout(struct usbtmc_file_data *file_data,
  1623. void __user *arg)
  1624. {
  1625. u32 timeout;
  1626. timeout = file_data->timeout;
  1627. return put_user(timeout, (__u32 __user *)arg);
  1628. }
  1629. /*
  1630. * Set the usb timeout value
  1631. */
  1632. static int usbtmc_ioctl_set_timeout(struct usbtmc_file_data *file_data,
  1633. void __user *arg)
  1634. {
  1635. u32 timeout;
  1636. if (get_user(timeout, (__u32 __user *)arg))
  1637. return -EFAULT;
  1638. /* Note that timeout = 0 means
  1639. * MAX_SCHEDULE_TIMEOUT in usb_control_msg
  1640. */
  1641. if (timeout < USBTMC_MIN_TIMEOUT)
  1642. return -EINVAL;
  1643. file_data->timeout = timeout;
  1644. return 0;
  1645. }
  1646. /*
  1647. * enables/disables sending EOM on write
  1648. */
  1649. static int usbtmc_ioctl_eom_enable(struct usbtmc_file_data *file_data,
  1650. void __user *arg)
  1651. {
  1652. u8 eom_enable;
  1653. if (copy_from_user(&eom_enable, arg, sizeof(eom_enable)))
  1654. return -EFAULT;
  1655. if (eom_enable > 1)
  1656. return -EINVAL;
  1657. file_data->eom_val = eom_enable;
  1658. return 0;
  1659. }
  1660. /*
  1661. * Configure termination character for read()
  1662. */
  1663. static int usbtmc_ioctl_config_termc(struct usbtmc_file_data *file_data,
  1664. void __user *arg)
  1665. {
  1666. struct usbtmc_termchar termc;
  1667. if (copy_from_user(&termc, arg, sizeof(termc)))
  1668. return -EFAULT;
  1669. if ((termc.term_char_enabled > 1) ||
  1670. (termc.term_char_enabled &&
  1671. !(file_data->data->capabilities.device_capabilities & 1)))
  1672. return -EINVAL;
  1673. file_data->term_char = termc.term_char;
  1674. file_data->term_char_enabled = termc.term_char_enabled;
  1675. return 0;
  1676. }
  1677. static long usbtmc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
  1678. {
  1679. struct usbtmc_file_data *file_data;
  1680. struct usbtmc_device_data *data;
  1681. int retval = -EBADRQC;
  1682. __u8 tmp_byte;
  1683. file_data = file->private_data;
  1684. data = file_data->data;
  1685. mutex_lock(&data->io_mutex);
  1686. if (data->zombie) {
  1687. retval = -ENODEV;
  1688. goto skip_io_on_zombie;
  1689. }
  1690. switch (cmd) {
  1691. case USBTMC_IOCTL_CLEAR_OUT_HALT:
  1692. retval = usbtmc_ioctl_clear_out_halt(data);
  1693. break;
  1694. case USBTMC_IOCTL_CLEAR_IN_HALT:
  1695. retval = usbtmc_ioctl_clear_in_halt(data);
  1696. break;
  1697. case USBTMC_IOCTL_INDICATOR_PULSE:
  1698. retval = usbtmc_ioctl_indicator_pulse(data);
  1699. break;
  1700. case USBTMC_IOCTL_CLEAR:
  1701. retval = usbtmc_ioctl_clear(data);
  1702. break;
  1703. case USBTMC_IOCTL_ABORT_BULK_OUT:
  1704. retval = usbtmc_ioctl_abort_bulk_out(data);
  1705. break;
  1706. case USBTMC_IOCTL_ABORT_BULK_IN:
  1707. retval = usbtmc_ioctl_abort_bulk_in(data);
  1708. break;
  1709. case USBTMC_IOCTL_CTRL_REQUEST:
  1710. retval = usbtmc_ioctl_request(data, (void __user *)arg);
  1711. break;
  1712. case USBTMC_IOCTL_GET_TIMEOUT:
  1713. retval = usbtmc_ioctl_get_timeout(file_data,
  1714. (void __user *)arg);
  1715. break;
  1716. case USBTMC_IOCTL_SET_TIMEOUT:
  1717. retval = usbtmc_ioctl_set_timeout(file_data,
  1718. (void __user *)arg);
  1719. break;
  1720. case USBTMC_IOCTL_EOM_ENABLE:
  1721. retval = usbtmc_ioctl_eom_enable(file_data,
  1722. (void __user *)arg);
  1723. break;
  1724. case USBTMC_IOCTL_CONFIG_TERMCHAR:
  1725. retval = usbtmc_ioctl_config_termc(file_data,
  1726. (void __user *)arg);
  1727. break;
  1728. case USBTMC_IOCTL_WRITE:
  1729. retval = usbtmc_ioctl_generic_write(file_data,
  1730. (void __user *)arg);
  1731. break;
  1732. case USBTMC_IOCTL_READ:
  1733. retval = usbtmc_ioctl_generic_read(file_data,
  1734. (void __user *)arg);
  1735. break;
  1736. case USBTMC_IOCTL_WRITE_RESULT:
  1737. retval = usbtmc_ioctl_write_result(file_data,
  1738. (void __user *)arg);
  1739. break;
  1740. case USBTMC_IOCTL_API_VERSION:
  1741. retval = put_user(USBTMC_API_VERSION,
  1742. (__u32 __user *)arg);
  1743. break;
  1744. case USBTMC488_IOCTL_GET_CAPS:
  1745. retval = put_user(data->usb488_caps,
  1746. (unsigned char __user *)arg);
  1747. break;
  1748. case USBTMC488_IOCTL_READ_STB:
  1749. retval = usbtmc488_ioctl_read_stb(file_data,
  1750. (void __user *)arg);
  1751. break;
  1752. case USBTMC488_IOCTL_REN_CONTROL:
  1753. retval = usbtmc488_ioctl_simple(data, (void __user *)arg,
  1754. USBTMC488_REQUEST_REN_CONTROL);
  1755. break;
  1756. case USBTMC488_IOCTL_GOTO_LOCAL:
  1757. retval = usbtmc488_ioctl_simple(data, (void __user *)arg,
  1758. USBTMC488_REQUEST_GOTO_LOCAL);
  1759. break;
  1760. case USBTMC488_IOCTL_LOCAL_LOCKOUT:
  1761. retval = usbtmc488_ioctl_simple(data, (void __user *)arg,
  1762. USBTMC488_REQUEST_LOCAL_LOCKOUT);
  1763. break;
  1764. case USBTMC488_IOCTL_TRIGGER:
  1765. retval = usbtmc488_ioctl_trigger(file_data);
  1766. break;
  1767. case USBTMC488_IOCTL_WAIT_SRQ:
  1768. retval = usbtmc488_ioctl_wait_srq(file_data,
  1769. (__u32 __user *)arg);
  1770. break;
  1771. case USBTMC_IOCTL_MSG_IN_ATTR:
  1772. retval = put_user(file_data->bmTransferAttributes,
  1773. (__u8 __user *)arg);
  1774. break;
  1775. case USBTMC_IOCTL_AUTO_ABORT:
  1776. retval = get_user(tmp_byte, (unsigned char __user *)arg);
  1777. if (retval == 0)
  1778. file_data->auto_abort = !!tmp_byte;
  1779. break;
  1780. case USBTMC_IOCTL_GET_STB:
  1781. retval = usbtmc_get_stb(file_data, &tmp_byte);
  1782. if (retval > 0)
  1783. retval = put_user(tmp_byte, (__u8 __user *)arg);
  1784. break;
  1785. case USBTMC_IOCTL_GET_SRQ_STB:
  1786. retval = usbtmc_ioctl_get_srq_stb(file_data,
  1787. (void __user *)arg);
  1788. break;
  1789. case USBTMC_IOCTL_CANCEL_IO:
  1790. retval = usbtmc_ioctl_cancel_io(file_data);
  1791. break;
  1792. case USBTMC_IOCTL_CLEANUP_IO:
  1793. retval = usbtmc_ioctl_cleanup_io(file_data);
  1794. break;
  1795. }
  1796. skip_io_on_zombie:
  1797. mutex_unlock(&data->io_mutex);
  1798. return retval;
  1799. }
  1800. static int usbtmc_fasync(int fd, struct file *file, int on)
  1801. {
  1802. struct usbtmc_file_data *file_data = file->private_data;
  1803. return fasync_helper(fd, file, on, &file_data->data->fasync);
  1804. }
  1805. static __poll_t usbtmc_poll(struct file *file, poll_table *wait)
  1806. {
  1807. struct usbtmc_file_data *file_data = file->private_data;
  1808. struct usbtmc_device_data *data = file_data->data;
  1809. __poll_t mask;
  1810. mutex_lock(&data->io_mutex);
  1811. if (data->zombie) {
  1812. mask = EPOLLHUP | EPOLLERR;
  1813. goto no_poll;
  1814. }
  1815. poll_wait(file, &data->waitq, wait);
  1816. /* Note that EPOLLPRI is now assigned to SRQ, and
  1817. * EPOLLIN|EPOLLRDNORM to normal read data.
  1818. */
  1819. mask = 0;
  1820. if (atomic_read(&file_data->srq_asserted))
  1821. mask |= EPOLLPRI;
  1822. /* Note that the anchor submitted includes all urbs for BULK IN
  1823. * and OUT. So EPOLLOUT is signaled when BULK OUT is empty and
  1824. * all BULK IN urbs are completed and moved to in_anchor.
  1825. */
  1826. if (usb_anchor_empty(&file_data->submitted))
  1827. mask |= (EPOLLOUT | EPOLLWRNORM);
  1828. if (!usb_anchor_empty(&file_data->in_anchor))
  1829. mask |= (EPOLLIN | EPOLLRDNORM);
  1830. spin_lock_irq(&file_data->err_lock);
  1831. if (file_data->in_status || file_data->out_status)
  1832. mask |= EPOLLERR;
  1833. spin_unlock_irq(&file_data->err_lock);
  1834. dev_dbg(&data->intf->dev, "poll mask = %x\n", mask);
  1835. no_poll:
  1836. mutex_unlock(&data->io_mutex);
  1837. return mask;
  1838. }
  1839. static const struct file_operations fops = {
  1840. .owner = THIS_MODULE,
  1841. .read = usbtmc_read,
  1842. .write = usbtmc_write,
  1843. .open = usbtmc_open,
  1844. .release = usbtmc_release,
  1845. .flush = usbtmc_flush,
  1846. .unlocked_ioctl = usbtmc_ioctl,
  1847. .compat_ioctl = compat_ptr_ioctl,
  1848. .fasync = usbtmc_fasync,
  1849. .poll = usbtmc_poll,
  1850. .llseek = default_llseek,
  1851. };
  1852. static struct usb_class_driver usbtmc_class = {
  1853. .name = "usbtmc%d",
  1854. .fops = &fops,
  1855. .minor_base = USBTMC_MINOR_BASE,
  1856. };
  1857. static void usbtmc_interrupt(struct urb *urb)
  1858. {
  1859. struct usbtmc_device_data *data = urb->context;
  1860. struct device *dev = &data->intf->dev;
  1861. int status = urb->status;
  1862. int rv;
  1863. dev_dbg(&data->intf->dev, "int status: %d len %d\n",
  1864. status, urb->actual_length);
  1865. switch (status) {
  1866. case 0: /* SUCCESS */
  1867. /* check for valid STB notification */
  1868. if (data->iin_buffer[0] > 0x81) {
  1869. data->bNotify1 = data->iin_buffer[0];
  1870. data->bNotify2 = data->iin_buffer[1];
  1871. atomic_set(&data->iin_data_valid, 1);
  1872. wake_up_interruptible(&data->waitq);
  1873. goto exit;
  1874. }
  1875. /* check for SRQ notification */
  1876. if (data->iin_buffer[0] == 0x81) {
  1877. unsigned long flags;
  1878. struct list_head *elem;
  1879. if (data->fasync)
  1880. kill_fasync(&data->fasync,
  1881. SIGIO, POLL_PRI);
  1882. spin_lock_irqsave(&data->dev_lock, flags);
  1883. list_for_each(elem, &data->file_list) {
  1884. struct usbtmc_file_data *file_data;
  1885. file_data = list_entry(elem,
  1886. struct usbtmc_file_data,
  1887. file_elem);
  1888. file_data->srq_byte = data->iin_buffer[1];
  1889. atomic_set(&file_data->srq_asserted, 1);
  1890. }
  1891. spin_unlock_irqrestore(&data->dev_lock, flags);
  1892. dev_dbg(dev, "srq received bTag %x stb %x\n",
  1893. (unsigned int)data->iin_buffer[0],
  1894. (unsigned int)data->iin_buffer[1]);
  1895. wake_up_interruptible_all(&data->waitq);
  1896. goto exit;
  1897. }
  1898. dev_warn(dev, "invalid notification: %x\n",
  1899. data->iin_buffer[0]);
  1900. break;
  1901. case -EOVERFLOW:
  1902. dev_err(dev, "overflow with length %d, actual length is %d\n",
  1903. data->iin_wMaxPacketSize, urb->actual_length);
  1904. fallthrough;
  1905. default:
  1906. /* urb terminated, clean up */
  1907. dev_dbg(dev, "urb terminated, status: %d\n", status);
  1908. return;
  1909. }
  1910. exit:
  1911. rv = usb_submit_urb(urb, GFP_ATOMIC);
  1912. if (rv)
  1913. dev_err(dev, "usb_submit_urb failed: %d\n", rv);
  1914. }
  1915. static void usbtmc_free_int(struct usbtmc_device_data *data)
  1916. {
  1917. if (!data->iin_ep_present || !data->iin_urb)
  1918. return;
  1919. usb_kill_urb(data->iin_urb);
  1920. kfree(data->iin_buffer);
  1921. data->iin_buffer = NULL;
  1922. usb_free_urb(data->iin_urb);
  1923. data->iin_urb = NULL;
  1924. kref_put(&data->kref, usbtmc_delete);
  1925. }
  1926. static int usbtmc_probe(struct usb_interface *intf,
  1927. const struct usb_device_id *id)
  1928. {
  1929. struct usbtmc_device_data *data;
  1930. struct usb_host_interface *iface_desc;
  1931. struct usb_endpoint_descriptor *bulk_in, *bulk_out, *int_in;
  1932. int retcode;
  1933. dev_dbg(&intf->dev, "%s called\n", __func__);
  1934. data = kzalloc(sizeof(*data), GFP_KERNEL);
  1935. if (!data)
  1936. return -ENOMEM;
  1937. data->intf = intf;
  1938. data->id = id;
  1939. data->usb_dev = usb_get_dev(interface_to_usbdev(intf));
  1940. usb_set_intfdata(intf, data);
  1941. kref_init(&data->kref);
  1942. mutex_init(&data->io_mutex);
  1943. init_waitqueue_head(&data->waitq);
  1944. atomic_set(&data->iin_data_valid, 0);
  1945. INIT_LIST_HEAD(&data->file_list);
  1946. spin_lock_init(&data->dev_lock);
  1947. data->zombie = 0;
  1948. /* Initialize USBTMC bTag and other fields */
  1949. data->bTag = 1;
  1950. /* 2 <= bTag <= 127 USBTMC-USB488 subclass specification 4.3.1 */
  1951. data->iin_bTag = 2;
  1952. /* USBTMC devices have only one setting, so use that */
  1953. iface_desc = data->intf->cur_altsetting;
  1954. data->ifnum = iface_desc->desc.bInterfaceNumber;
  1955. /* Find bulk endpoints */
  1956. retcode = usb_find_common_endpoints(iface_desc,
  1957. &bulk_in, &bulk_out, NULL, NULL);
  1958. if (retcode) {
  1959. dev_err(&intf->dev, "bulk endpoints not found\n");
  1960. goto err_put;
  1961. }
  1962. retcode = -EINVAL;
  1963. data->bulk_in = bulk_in->bEndpointAddress;
  1964. data->wMaxPacketSize = usb_endpoint_maxp(bulk_in);
  1965. if (!data->wMaxPacketSize)
  1966. goto err_put;
  1967. dev_dbg(&intf->dev, "Found bulk in endpoint at %u\n", data->bulk_in);
  1968. data->bulk_out = bulk_out->bEndpointAddress;
  1969. dev_dbg(&intf->dev, "Found Bulk out endpoint at %u\n", data->bulk_out);
  1970. /* Find int endpoint */
  1971. retcode = usb_find_int_in_endpoint(iface_desc, &int_in);
  1972. if (!retcode) {
  1973. data->iin_ep_present = 1;
  1974. data->iin_ep = int_in->bEndpointAddress;
  1975. data->iin_wMaxPacketSize = usb_endpoint_maxp(int_in);
  1976. data->iin_interval = int_in->bInterval;
  1977. dev_dbg(&intf->dev, "Found Int in endpoint at %u\n",
  1978. data->iin_ep);
  1979. }
  1980. retcode = get_capabilities(data);
  1981. if (retcode)
  1982. dev_err(&intf->dev, "can't read capabilities\n");
  1983. if (data->iin_ep_present) {
  1984. /* allocate int urb */
  1985. data->iin_urb = usb_alloc_urb(0, GFP_KERNEL);
  1986. if (!data->iin_urb) {
  1987. retcode = -ENOMEM;
  1988. goto error_register;
  1989. }
  1990. /* Protect interrupt in endpoint data until iin_urb is freed */
  1991. kref_get(&data->kref);
  1992. /* allocate buffer for interrupt in */
  1993. data->iin_buffer = kmalloc(data->iin_wMaxPacketSize,
  1994. GFP_KERNEL);
  1995. if (!data->iin_buffer) {
  1996. retcode = -ENOMEM;
  1997. goto error_register;
  1998. }
  1999. /* fill interrupt urb */
  2000. usb_fill_int_urb(data->iin_urb, data->usb_dev,
  2001. usb_rcvintpipe(data->usb_dev, data->iin_ep),
  2002. data->iin_buffer, data->iin_wMaxPacketSize,
  2003. usbtmc_interrupt,
  2004. data, data->iin_interval);
  2005. retcode = usb_submit_urb(data->iin_urb, GFP_KERNEL);
  2006. if (retcode) {
  2007. dev_err(&intf->dev, "Failed to submit iin_urb\n");
  2008. goto error_register;
  2009. }
  2010. }
  2011. retcode = usb_register_dev(intf, &usbtmc_class);
  2012. if (retcode) {
  2013. dev_err(&intf->dev, "Not able to get a minor (base %u, slice default): %d\n",
  2014. USBTMC_MINOR_BASE,
  2015. retcode);
  2016. goto error_register;
  2017. }
  2018. dev_dbg(&intf->dev, "Using minor number %d\n", intf->minor);
  2019. return 0;
  2020. error_register:
  2021. usbtmc_free_int(data);
  2022. err_put:
  2023. kref_put(&data->kref, usbtmc_delete);
  2024. return retcode;
  2025. }
  2026. static void usbtmc_disconnect(struct usb_interface *intf)
  2027. {
  2028. struct usbtmc_device_data *data = usb_get_intfdata(intf);
  2029. struct list_head *elem;
  2030. usb_deregister_dev(intf, &usbtmc_class);
  2031. mutex_lock(&data->io_mutex);
  2032. data->zombie = 1;
  2033. wake_up_interruptible_all(&data->waitq);
  2034. list_for_each(elem, &data->file_list) {
  2035. struct usbtmc_file_data *file_data;
  2036. file_data = list_entry(elem,
  2037. struct usbtmc_file_data,
  2038. file_elem);
  2039. usb_kill_anchored_urbs(&file_data->submitted);
  2040. usb_scuttle_anchored_urbs(&file_data->in_anchor);
  2041. }
  2042. mutex_unlock(&data->io_mutex);
  2043. usbtmc_free_int(data);
  2044. kref_put(&data->kref, usbtmc_delete);
  2045. }
  2046. static void usbtmc_draw_down(struct usbtmc_file_data *file_data)
  2047. {
  2048. int time;
  2049. time = usb_wait_anchor_empty_timeout(&file_data->submitted, 1000);
  2050. if (!time)
  2051. usb_kill_anchored_urbs(&file_data->submitted);
  2052. usb_scuttle_anchored_urbs(&file_data->in_anchor);
  2053. }
  2054. static int usbtmc_suspend(struct usb_interface *intf, pm_message_t message)
  2055. {
  2056. struct usbtmc_device_data *data = usb_get_intfdata(intf);
  2057. struct list_head *elem;
  2058. if (!data)
  2059. return 0;
  2060. mutex_lock(&data->io_mutex);
  2061. list_for_each(elem, &data->file_list) {
  2062. struct usbtmc_file_data *file_data;
  2063. file_data = list_entry(elem,
  2064. struct usbtmc_file_data,
  2065. file_elem);
  2066. usbtmc_draw_down(file_data);
  2067. }
  2068. if (data->iin_ep_present && data->iin_urb)
  2069. usb_kill_urb(data->iin_urb);
  2070. mutex_unlock(&data->io_mutex);
  2071. return 0;
  2072. }
  2073. static int usbtmc_resume(struct usb_interface *intf)
  2074. {
  2075. struct usbtmc_device_data *data = usb_get_intfdata(intf);
  2076. int retcode = 0;
  2077. if (data->iin_ep_present && data->iin_urb)
  2078. retcode = usb_submit_urb(data->iin_urb, GFP_KERNEL);
  2079. if (retcode)
  2080. dev_err(&intf->dev, "Failed to submit iin_urb\n");
  2081. return retcode;
  2082. }
  2083. static int usbtmc_pre_reset(struct usb_interface *intf)
  2084. {
  2085. struct usbtmc_device_data *data = usb_get_intfdata(intf);
  2086. struct list_head *elem;
  2087. if (!data)
  2088. return 0;
  2089. mutex_lock(&data->io_mutex);
  2090. list_for_each(elem, &data->file_list) {
  2091. struct usbtmc_file_data *file_data;
  2092. file_data = list_entry(elem,
  2093. struct usbtmc_file_data,
  2094. file_elem);
  2095. usbtmc_ioctl_cancel_io(file_data);
  2096. }
  2097. return 0;
  2098. }
  2099. static int usbtmc_post_reset(struct usb_interface *intf)
  2100. {
  2101. struct usbtmc_device_data *data = usb_get_intfdata(intf);
  2102. mutex_unlock(&data->io_mutex);
  2103. return 0;
  2104. }
  2105. static struct usb_driver usbtmc_driver = {
  2106. .name = "usbtmc",
  2107. .id_table = usbtmc_devices,
  2108. .probe = usbtmc_probe,
  2109. .disconnect = usbtmc_disconnect,
  2110. .suspend = usbtmc_suspend,
  2111. .resume = usbtmc_resume,
  2112. .pre_reset = usbtmc_pre_reset,
  2113. .post_reset = usbtmc_post_reset,
  2114. .dev_groups = usbtmc_groups,
  2115. };
  2116. module_usb_driver(usbtmc_driver);
  2117. MODULE_LICENSE("GPL");