digi_acceleport.c 57 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867
  1. /*
  2. * Digi AccelePort USB-4 and USB-2 Serial Converters
  3. *
  4. * Copyright 2000 by Digi International
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * Shamelessly based on Brian Warner's keyspan_pda.c and Greg Kroah-Hartman's
  12. * usb-serial driver.
  13. *
  14. * Peter Berger (pberger@brimson.com)
  15. * Al Borchers (borchers@steinerpoint.com)
  16. *
  17. * (12/03/2001) gkh
  18. * switched to using port->port.count instead of private version.
  19. * Removed port->active
  20. *
  21. * (04/08/2001) gb
  22. * Identify version on module load.
  23. *
  24. * (11/01/2000) Adam J. Richter
  25. * usb_device_id table support
  26. *
  27. * (11/01/2000) pberger and borchers
  28. * -- Turned off the USB_DISABLE_SPD flag for write bulk urbs--it caused
  29. * USB 4 ports to hang on startup.
  30. * -- Serialized access to write urbs by adding the dp_write_urb_in_use
  31. * flag; otherwise, the driver caused SMP system hangs. Watching the
  32. * urb status is not sufficient.
  33. *
  34. * (10/05/2000) gkh
  35. * -- Fixed bug with urb->dev not being set properly, now that the usb
  36. * core needs it.
  37. *
  38. * (8/8/2000) pberger and borchers
  39. * -- Fixed close so that
  40. * - it can timeout while waiting for transmit idle, if needed;
  41. * - it ignores interrupts when flushing the port, turning
  42. * of modem signalling, and so on;
  43. * - it waits for the flush to really complete before returning.
  44. * -- Read_bulk_callback and write_bulk_callback check for a closed
  45. * port before using the tty struct or writing to the port.
  46. * -- The two changes above fix the oops caused by interrupted closes.
  47. * -- Added interruptible args to write_oob_command and set_modem_signals
  48. * and added a timeout arg to transmit_idle; needed for fixes to
  49. * close.
  50. * -- Added code for rx_throttle and rx_unthrottle so that input flow
  51. * control works.
  52. * -- Added code to set overrun, parity, framing, and break errors
  53. * (untested).
  54. * -- Set USB_DISABLE_SPD flag for write bulk urbs, so no 0 length
  55. * bulk writes are done. These hung the Digi USB device. The
  56. * 0 length bulk writes were a new feature of usb-uhci added in
  57. * the 2.4.0-test6 kernels.
  58. * -- Fixed mod inc race in open; do mod inc before sleeping to wait
  59. * for a close to finish.
  60. *
  61. * (7/31/2000) pberger
  62. * -- Fixed bugs with hardware handshaking:
  63. * - Added code to set/clear tty->hw_stopped in digi_read_oob_callback()
  64. * and digi_set_termios()
  65. * -- Added code in digi_set_termios() to
  66. * - add conditional in code handling transition from B0 to only
  67. * set RTS if RTS/CTS flow control is either not in use or if
  68. * the port is not currently throttled.
  69. * - handle turning off CRTSCTS.
  70. *
  71. * (7/30/2000) borchers
  72. * -- Added support for more than one Digi USB device by moving
  73. * globals to a private structure in the pointed to from the
  74. * usb_serial structure.
  75. * -- Moved the modem change and transmit idle wait queues into
  76. * the port private structure, so each port has its own queue
  77. * rather than sharing global queues.
  78. * -- Added support for break signals.
  79. *
  80. * (7/25/2000) pberger
  81. * -- Added USB-2 support. Note: the USB-2 supports 3 devices: two
  82. * serial and a parallel port. The parallel port is implemented
  83. * as a serial-to-parallel converter. That is, the driver actually
  84. * presents all three USB-2 interfaces as serial ports, but the third
  85. * one physically connects to a parallel device. Thus, for example,
  86. * one could plug a parallel printer into the USB-2's third port,
  87. * but from the kernel's (and userland's) point of view what's
  88. * actually out there is a serial device.
  89. *
  90. * (7/15/2000) borchers
  91. * -- Fixed race in open when a close is in progress.
  92. * -- Keep count of opens and dec the module use count for each
  93. * outstanding open when shutdown is called (on disconnect).
  94. * -- Fixed sanity checks in read_bulk_callback and write_bulk_callback
  95. * so pointers are checked before use.
  96. * -- Split read bulk callback into in band and out of band
  97. * callbacks, and no longer restart read chains if there is
  98. * a status error or a sanity error. This fixed the seg
  99. * faults and other errors we used to get on disconnect.
  100. * -- Port->active is once again a flag as usb-serial intended it
  101. * to be, not a count. Since it was only a char it would
  102. * have been limited to 256 simultaneous opens. Now the open
  103. * count is kept in the port private structure in dp_open_count.
  104. * -- Added code for modularization of the digi_acceleport driver.
  105. *
  106. * (6/27/2000) pberger and borchers
  107. * -- Zeroed out sync field in the wakeup_task before first use;
  108. * otherwise the uninitialized value might prevent the task from
  109. * being scheduled.
  110. * -- Initialized ret value to 0 in write_bulk_callback, otherwise
  111. * the uninitialized value could cause a spurious debugging message.
  112. *
  113. * (6/22/2000) pberger and borchers
  114. * -- Made cond_wait_... inline--apparently on SPARC the flags arg
  115. * to spin_lock_irqsave cannot be passed to another function
  116. * to call spin_unlock_irqrestore. Thanks to Pauline Middelink.
  117. * -- In digi_set_modem_signals the inner nested spin locks use just
  118. * spin_lock() rather than spin_lock_irqsave(). The old code
  119. * mistakenly left interrupts off. Thanks to Pauline Middelink.
  120. * -- copy_from_user (which can sleep) is no longer called while a
  121. * spinlock is held. We copy to a local buffer before getting
  122. * the spinlock--don't like the extra copy but the code is simpler.
  123. * -- Printk and dbg are no longer called while a spin lock is held.
  124. *
  125. * (6/4/2000) pberger and borchers
  126. * -- Replaced separate calls to spin_unlock_irqrestore and
  127. * interruptible_sleep_on_timeout with a new function
  128. * cond_wait_interruptible_timeout_irqrestore. This eliminates
  129. * the race condition where the wake up could happen after
  130. * the unlock and before the sleep.
  131. * -- Close now waits for output to drain.
  132. * -- Open waits until any close in progress is finished.
  133. * -- All out of band responses are now processed, not just the
  134. * first in a USB packet.
  135. * -- Fixed a bug that prevented the driver from working when the
  136. * first Digi port was not the first USB serial port--the driver
  137. * was mistakenly using the external USB serial port number to
  138. * try to index into its internal ports.
  139. * -- Fixed an SMP bug -- write_bulk_callback is called directly from
  140. * an interrupt, so spin_lock_irqsave/spin_unlock_irqrestore are
  141. * needed for locks outside write_bulk_callback that are also
  142. * acquired by write_bulk_callback to prevent deadlocks.
  143. * -- Fixed support for select() by making digi_chars_in_buffer()
  144. * return 256 when -EINPROGRESS is set, as the line discipline
  145. * code in n_tty.c expects.
  146. * -- Fixed an include file ordering problem that prevented debugging
  147. * messages from working.
  148. * -- Fixed an intermittent timeout problem that caused writes to
  149. * sometimes get stuck on some machines on some kernels. It turns
  150. * out in these circumstances write_chan() (in n_tty.c) was
  151. * asleep waiting for our wakeup call. Even though we call
  152. * wake_up_interruptible() in digi_write_bulk_callback(), there is
  153. * a race condition that could cause the wakeup to fail: if our
  154. * wake_up_interruptible() call occurs between the time that our
  155. * driver write routine finishes and write_chan() sets current->state
  156. * to TASK_INTERRUPTIBLE, the effect of our wakeup setting the state
  157. * to TASK_RUNNING will be lost and write_chan's subsequent call to
  158. * schedule() will never return (unless it catches a signal).
  159. * This race condition occurs because write_bulk_callback() (and thus
  160. * the wakeup) are called asynchronously from an interrupt, rather than
  161. * from the scheduler. We can avoid the race by calling the wakeup
  162. * from the scheduler queue and that's our fix: Now, at the end of
  163. * write_bulk_callback() we queue up a wakeup call on the scheduler
  164. * task queue. We still also invoke the wakeup directly since that
  165. * squeezes a bit more performance out of the driver, and any lost
  166. * race conditions will get cleaned up at the next scheduler run.
  167. *
  168. * NOTE: The problem also goes away if you comment out
  169. * the two code lines in write_chan() where current->state
  170. * is set to TASK_RUNNING just before calling driver.write() and to
  171. * TASK_INTERRUPTIBLE immediately afterwards. This is why the
  172. * problem did not show up with the 2.2 kernels -- they do not
  173. * include that code.
  174. *
  175. * (5/16/2000) pberger and borchers
  176. * -- Added timeouts to sleeps, to defend against lost wake ups.
  177. * -- Handle transition to/from B0 baud rate in digi_set_termios.
  178. *
  179. * (5/13/2000) pberger and borchers
  180. * -- All commands now sent on out of band port, using
  181. * digi_write_oob_command.
  182. * -- Get modem control signals whenever they change, support TIOCMGET/
  183. * SET/BIS/BIC ioctls.
  184. * -- digi_set_termios now supports parity, word size, stop bits, and
  185. * receive enable.
  186. * -- Cleaned up open and close, use digi_set_termios and
  187. * digi_write_oob_command to set port parameters.
  188. * -- Added digi_startup_device to start read chains on all ports.
  189. * -- Write buffer is only used when count==1, to be sure put_char can
  190. * write a char (unless the buffer is full).
  191. *
  192. * (5/10/2000) pberger and borchers
  193. * -- Added MOD_INC_USE_COUNT/MOD_DEC_USE_COUNT calls on open/close.
  194. * -- Fixed problem where the first incoming character is lost on
  195. * port opens after the first close on that port. Now we keep
  196. * the read_urb chain open until shutdown.
  197. * -- Added more port conditioning calls in digi_open and digi_close.
  198. * -- Convert port->active to a use count so that we can deal with multiple
  199. * opens and closes properly.
  200. * -- Fixed some problems with the locking code.
  201. *
  202. * (5/3/2000) pberger and borchers
  203. * -- First alpha version of the driver--many known limitations and bugs.
  204. *
  205. *
  206. * Locking and SMP
  207. *
  208. * - Each port, including the out-of-band port, has a lock used to
  209. * serialize all access to the port's private structure.
  210. * - The port lock is also used to serialize all writes and access to
  211. * the port's URB.
  212. * - The port lock is also used for the port write_wait condition
  213. * variable. Holding the port lock will prevent a wake up on the
  214. * port's write_wait; this can be used with cond_wait_... to be sure
  215. * the wake up is not lost in a race when dropping the lock and
  216. * sleeping waiting for the wakeup.
  217. * - digi_write() does not sleep, since it is sometimes called on
  218. * interrupt time.
  219. * - digi_write_bulk_callback() and digi_read_bulk_callback() are
  220. * called directly from interrupts. Hence spin_lock_irqsave()
  221. * and spin_unlock_irqrestore() are used in the rest of the code
  222. * for any locks they acquire.
  223. * - digi_write_bulk_callback() gets the port lock before waking up
  224. * processes sleeping on the port write_wait. It also schedules
  225. * wake ups so they happen from the scheduler, because the tty
  226. * system can miss wake ups from interrupts.
  227. * - All sleeps use a timeout of DIGI_RETRY_TIMEOUT before looping to
  228. * recheck the condition they are sleeping on. This is defensive,
  229. * in case a wake up is lost.
  230. * - Following Documentation/DocBook/kernel-locking.pdf no spin locks
  231. * are held when calling copy_to/from_user or printk.
  232. */
  233. #include <linux/kernel.h>
  234. #include <linux/errno.h>
  235. #include <linux/init.h>
  236. #include <linux/slab.h>
  237. #include <linux/tty.h>
  238. #include <linux/tty_driver.h>
  239. #include <linux/tty_flip.h>
  240. #include <linux/module.h>
  241. #include <linux/spinlock.h>
  242. #include <linux/workqueue.h>
  243. #include <linux/uaccess.h>
  244. #include <linux/usb.h>
  245. #include <linux/wait.h>
  246. #include <linux/usb/serial.h>
  247. /* Defines */
  248. /*
  249. * Version Information
  250. */
  251. #define DRIVER_VERSION "v1.80.1.2"
  252. #define DRIVER_AUTHOR "Peter Berger <pberger@brimson.com>, Al Borchers <borchers@steinerpoint.com>"
  253. #define DRIVER_DESC "Digi AccelePort USB-2/USB-4 Serial Converter driver"
  254. /* port output buffer length -- must be <= transfer buffer length - 2 */
  255. /* so we can be sure to send the full buffer in one urb */
  256. #define DIGI_OUT_BUF_SIZE 8
  257. /* port input buffer length -- must be >= transfer buffer length - 3 */
  258. /* so we can be sure to hold at least one full buffer from one urb */
  259. #define DIGI_IN_BUF_SIZE 64
  260. /* retry timeout while sleeping */
  261. #define DIGI_RETRY_TIMEOUT (HZ/10)
  262. /* timeout while waiting for tty output to drain in close */
  263. /* this delay is used twice in close, so the total delay could */
  264. /* be twice this value */
  265. #define DIGI_CLOSE_TIMEOUT (5*HZ)
  266. /* AccelePort USB Defines */
  267. /* ids */
  268. #define DIGI_VENDOR_ID 0x05c5
  269. #define DIGI_2_ID 0x0002 /* USB-2 */
  270. #define DIGI_4_ID 0x0004 /* USB-4 */
  271. /* commands
  272. * "INB": can be used on the in-band endpoint
  273. * "OOB": can be used on the out-of-band endpoint
  274. */
  275. #define DIGI_CMD_SET_BAUD_RATE 0 /* INB, OOB */
  276. #define DIGI_CMD_SET_WORD_SIZE 1 /* INB, OOB */
  277. #define DIGI_CMD_SET_PARITY 2 /* INB, OOB */
  278. #define DIGI_CMD_SET_STOP_BITS 3 /* INB, OOB */
  279. #define DIGI_CMD_SET_INPUT_FLOW_CONTROL 4 /* INB, OOB */
  280. #define DIGI_CMD_SET_OUTPUT_FLOW_CONTROL 5 /* INB, OOB */
  281. #define DIGI_CMD_SET_DTR_SIGNAL 6 /* INB, OOB */
  282. #define DIGI_CMD_SET_RTS_SIGNAL 7 /* INB, OOB */
  283. #define DIGI_CMD_READ_INPUT_SIGNALS 8 /* OOB */
  284. #define DIGI_CMD_IFLUSH_FIFO 9 /* OOB */
  285. #define DIGI_CMD_RECEIVE_ENABLE 10 /* INB, OOB */
  286. #define DIGI_CMD_BREAK_CONTROL 11 /* INB, OOB */
  287. #define DIGI_CMD_LOCAL_LOOPBACK 12 /* INB, OOB */
  288. #define DIGI_CMD_TRANSMIT_IDLE 13 /* INB, OOB */
  289. #define DIGI_CMD_READ_UART_REGISTER 14 /* OOB */
  290. #define DIGI_CMD_WRITE_UART_REGISTER 15 /* INB, OOB */
  291. #define DIGI_CMD_AND_UART_REGISTER 16 /* INB, OOB */
  292. #define DIGI_CMD_OR_UART_REGISTER 17 /* INB, OOB */
  293. #define DIGI_CMD_SEND_DATA 18 /* INB */
  294. #define DIGI_CMD_RECEIVE_DATA 19 /* INB */
  295. #define DIGI_CMD_RECEIVE_DISABLE 20 /* INB */
  296. #define DIGI_CMD_GET_PORT_TYPE 21 /* OOB */
  297. /* baud rates */
  298. #define DIGI_BAUD_50 0
  299. #define DIGI_BAUD_75 1
  300. #define DIGI_BAUD_110 2
  301. #define DIGI_BAUD_150 3
  302. #define DIGI_BAUD_200 4
  303. #define DIGI_BAUD_300 5
  304. #define DIGI_BAUD_600 6
  305. #define DIGI_BAUD_1200 7
  306. #define DIGI_BAUD_1800 8
  307. #define DIGI_BAUD_2400 9
  308. #define DIGI_BAUD_4800 10
  309. #define DIGI_BAUD_7200 11
  310. #define DIGI_BAUD_9600 12
  311. #define DIGI_BAUD_14400 13
  312. #define DIGI_BAUD_19200 14
  313. #define DIGI_BAUD_28800 15
  314. #define DIGI_BAUD_38400 16
  315. #define DIGI_BAUD_57600 17
  316. #define DIGI_BAUD_76800 18
  317. #define DIGI_BAUD_115200 19
  318. #define DIGI_BAUD_153600 20
  319. #define DIGI_BAUD_230400 21
  320. #define DIGI_BAUD_460800 22
  321. /* arguments */
  322. #define DIGI_WORD_SIZE_5 0
  323. #define DIGI_WORD_SIZE_6 1
  324. #define DIGI_WORD_SIZE_7 2
  325. #define DIGI_WORD_SIZE_8 3
  326. #define DIGI_PARITY_NONE 0
  327. #define DIGI_PARITY_ODD 1
  328. #define DIGI_PARITY_EVEN 2
  329. #define DIGI_PARITY_MARK 3
  330. #define DIGI_PARITY_SPACE 4
  331. #define DIGI_STOP_BITS_1 0
  332. #define DIGI_STOP_BITS_2 1
  333. #define DIGI_INPUT_FLOW_CONTROL_XON_XOFF 1
  334. #define DIGI_INPUT_FLOW_CONTROL_RTS 2
  335. #define DIGI_INPUT_FLOW_CONTROL_DTR 4
  336. #define DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF 1
  337. #define DIGI_OUTPUT_FLOW_CONTROL_CTS 2
  338. #define DIGI_OUTPUT_FLOW_CONTROL_DSR 4
  339. #define DIGI_DTR_INACTIVE 0
  340. #define DIGI_DTR_ACTIVE 1
  341. #define DIGI_DTR_INPUT_FLOW_CONTROL 2
  342. #define DIGI_RTS_INACTIVE 0
  343. #define DIGI_RTS_ACTIVE 1
  344. #define DIGI_RTS_INPUT_FLOW_CONTROL 2
  345. #define DIGI_RTS_TOGGLE 3
  346. #define DIGI_FLUSH_TX 1
  347. #define DIGI_FLUSH_RX 2
  348. #define DIGI_RESUME_TX 4 /* clears xoff condition */
  349. #define DIGI_TRANSMIT_NOT_IDLE 0
  350. #define DIGI_TRANSMIT_IDLE 1
  351. #define DIGI_DISABLE 0
  352. #define DIGI_ENABLE 1
  353. #define DIGI_DEASSERT 0
  354. #define DIGI_ASSERT 1
  355. /* in band status codes */
  356. #define DIGI_OVERRUN_ERROR 4
  357. #define DIGI_PARITY_ERROR 8
  358. #define DIGI_FRAMING_ERROR 16
  359. #define DIGI_BREAK_ERROR 32
  360. /* out of band status */
  361. #define DIGI_NO_ERROR 0
  362. #define DIGI_BAD_FIRST_PARAMETER 1
  363. #define DIGI_BAD_SECOND_PARAMETER 2
  364. #define DIGI_INVALID_LINE 3
  365. #define DIGI_INVALID_OPCODE 4
  366. /* input signals */
  367. #define DIGI_READ_INPUT_SIGNALS_SLOT 1
  368. #define DIGI_READ_INPUT_SIGNALS_ERR 2
  369. #define DIGI_READ_INPUT_SIGNALS_BUSY 4
  370. #define DIGI_READ_INPUT_SIGNALS_PE 8
  371. #define DIGI_READ_INPUT_SIGNALS_CTS 16
  372. #define DIGI_READ_INPUT_SIGNALS_DSR 32
  373. #define DIGI_READ_INPUT_SIGNALS_RI 64
  374. #define DIGI_READ_INPUT_SIGNALS_DCD 128
  375. /* Structures */
  376. struct digi_serial {
  377. spinlock_t ds_serial_lock;
  378. struct usb_serial_port *ds_oob_port; /* out-of-band port */
  379. int ds_oob_port_num; /* index of out-of-band port */
  380. int ds_device_started;
  381. };
  382. struct digi_port {
  383. spinlock_t dp_port_lock;
  384. int dp_port_num;
  385. int dp_out_buf_len;
  386. unsigned char dp_out_buf[DIGI_OUT_BUF_SIZE];
  387. int dp_write_urb_in_use;
  388. unsigned int dp_modem_signals;
  389. wait_queue_head_t dp_modem_change_wait;
  390. int dp_transmit_idle;
  391. wait_queue_head_t dp_transmit_idle_wait;
  392. int dp_throttled;
  393. int dp_throttle_restart;
  394. wait_queue_head_t dp_flush_wait;
  395. wait_queue_head_t dp_close_wait; /* wait queue for close */
  396. struct work_struct dp_wakeup_work;
  397. struct usb_serial_port *dp_port;
  398. };
  399. /* Local Function Declarations */
  400. static void digi_wakeup_write(struct usb_serial_port *port);
  401. static void digi_wakeup_write_lock(struct work_struct *work);
  402. static int digi_write_oob_command(struct usb_serial_port *port,
  403. unsigned char *buf, int count, int interruptible);
  404. static int digi_write_inb_command(struct usb_serial_port *port,
  405. unsigned char *buf, int count, unsigned long timeout);
  406. static int digi_set_modem_signals(struct usb_serial_port *port,
  407. unsigned int modem_signals, int interruptible);
  408. static int digi_transmit_idle(struct usb_serial_port *port,
  409. unsigned long timeout);
  410. static void digi_rx_throttle(struct tty_struct *tty);
  411. static void digi_rx_unthrottle(struct tty_struct *tty);
  412. static void digi_set_termios(struct tty_struct *tty,
  413. struct usb_serial_port *port, struct ktermios *old_termios);
  414. static void digi_break_ctl(struct tty_struct *tty, int break_state);
  415. static int digi_tiocmget(struct tty_struct *tty, struct file *file);
  416. static int digi_tiocmset(struct tty_struct *tty, struct file *file,
  417. unsigned int set, unsigned int clear);
  418. static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
  419. const unsigned char *buf, int count);
  420. static void digi_write_bulk_callback(struct urb *urb);
  421. static int digi_write_room(struct tty_struct *tty);
  422. static int digi_chars_in_buffer(struct tty_struct *tty);
  423. static int digi_open(struct tty_struct *tty, struct usb_serial_port *port);
  424. static void digi_close(struct usb_serial_port *port);
  425. static int digi_carrier_raised(struct usb_serial_port *port);
  426. static void digi_dtr_rts(struct usb_serial_port *port, int on);
  427. static int digi_startup_device(struct usb_serial *serial);
  428. static int digi_startup(struct usb_serial *serial);
  429. static void digi_disconnect(struct usb_serial *serial);
  430. static void digi_release(struct usb_serial *serial);
  431. static void digi_read_bulk_callback(struct urb *urb);
  432. static int digi_read_inb_callback(struct urb *urb);
  433. static int digi_read_oob_callback(struct urb *urb);
  434. /* Statics */
  435. static int debug;
  436. static struct usb_device_id id_table_combined [] = {
  437. { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) },
  438. { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) },
  439. { } /* Terminating entry */
  440. };
  441. static struct usb_device_id id_table_2 [] = {
  442. { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) },
  443. { } /* Terminating entry */
  444. };
  445. static struct usb_device_id id_table_4 [] = {
  446. { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) },
  447. { } /* Terminating entry */
  448. };
  449. MODULE_DEVICE_TABLE(usb, id_table_combined);
  450. static struct usb_driver digi_driver = {
  451. .name = "digi_acceleport",
  452. .probe = usb_serial_probe,
  453. .disconnect = usb_serial_disconnect,
  454. .id_table = id_table_combined,
  455. .no_dynamic_id = 1,
  456. };
  457. /* device info needed for the Digi serial converter */
  458. static struct usb_serial_driver digi_acceleport_2_device = {
  459. .driver = {
  460. .owner = THIS_MODULE,
  461. .name = "digi_2",
  462. },
  463. .description = "Digi 2 port USB adapter",
  464. .usb_driver = &digi_driver,
  465. .id_table = id_table_2,
  466. .num_ports = 3,
  467. .open = digi_open,
  468. .close = digi_close,
  469. .dtr_rts = digi_dtr_rts,
  470. .carrier_raised = digi_carrier_raised,
  471. .write = digi_write,
  472. .write_room = digi_write_room,
  473. .write_bulk_callback = digi_write_bulk_callback,
  474. .read_bulk_callback = digi_read_bulk_callback,
  475. .chars_in_buffer = digi_chars_in_buffer,
  476. .throttle = digi_rx_throttle,
  477. .unthrottle = digi_rx_unthrottle,
  478. .set_termios = digi_set_termios,
  479. .break_ctl = digi_break_ctl,
  480. .tiocmget = digi_tiocmget,
  481. .tiocmset = digi_tiocmset,
  482. .attach = digi_startup,
  483. .disconnect = digi_disconnect,
  484. .release = digi_release,
  485. };
  486. static struct usb_serial_driver digi_acceleport_4_device = {
  487. .driver = {
  488. .owner = THIS_MODULE,
  489. .name = "digi_4",
  490. },
  491. .description = "Digi 4 port USB adapter",
  492. .usb_driver = &digi_driver,
  493. .id_table = id_table_4,
  494. .num_ports = 4,
  495. .open = digi_open,
  496. .close = digi_close,
  497. .write = digi_write,
  498. .write_room = digi_write_room,
  499. .write_bulk_callback = digi_write_bulk_callback,
  500. .read_bulk_callback = digi_read_bulk_callback,
  501. .chars_in_buffer = digi_chars_in_buffer,
  502. .throttle = digi_rx_throttle,
  503. .unthrottle = digi_rx_unthrottle,
  504. .set_termios = digi_set_termios,
  505. .break_ctl = digi_break_ctl,
  506. .tiocmget = digi_tiocmget,
  507. .tiocmset = digi_tiocmset,
  508. .attach = digi_startup,
  509. .disconnect = digi_disconnect,
  510. .release = digi_release,
  511. };
  512. /* Functions */
  513. /*
  514. * Cond Wait Interruptible Timeout Irqrestore
  515. *
  516. * Do spin_unlock_irqrestore and interruptible_sleep_on_timeout
  517. * so that wake ups are not lost if they occur between the unlock
  518. * and the sleep. In other words, spin_unlock_irqrestore and
  519. * interruptible_sleep_on_timeout are "atomic" with respect to
  520. * wake ups. This is used to implement condition variables.
  521. *
  522. * interruptible_sleep_on_timeout is deprecated and has been replaced
  523. * with the equivalent code.
  524. */
  525. static long cond_wait_interruptible_timeout_irqrestore(
  526. wait_queue_head_t *q, long timeout,
  527. spinlock_t *lock, unsigned long flags)
  528. __releases(lock)
  529. {
  530. DEFINE_WAIT(wait);
  531. prepare_to_wait(q, &wait, TASK_INTERRUPTIBLE);
  532. spin_unlock_irqrestore(lock, flags);
  533. timeout = schedule_timeout(timeout);
  534. finish_wait(q, &wait);
  535. return timeout;
  536. }
  537. /*
  538. * Digi Wakeup Write
  539. *
  540. * Wake up port, line discipline, and tty processes sleeping
  541. * on writes.
  542. */
  543. static void digi_wakeup_write_lock(struct work_struct *work)
  544. {
  545. struct digi_port *priv =
  546. container_of(work, struct digi_port, dp_wakeup_work);
  547. struct usb_serial_port *port = priv->dp_port;
  548. unsigned long flags;
  549. spin_lock_irqsave(&priv->dp_port_lock, flags);
  550. digi_wakeup_write(port);
  551. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  552. }
  553. static void digi_wakeup_write(struct usb_serial_port *port)
  554. {
  555. struct tty_struct *tty = tty_port_tty_get(&port->port);
  556. tty_wakeup(tty);
  557. tty_kref_put(tty);
  558. }
  559. /*
  560. * Digi Write OOB Command
  561. *
  562. * Write commands on the out of band port. Commands are 4
  563. * bytes each, multiple commands can be sent at once, and
  564. * no command will be split across USB packets. Returns 0
  565. * if successful, -EINTR if interrupted while sleeping and
  566. * the interruptible flag is true, or a negative error
  567. * returned by usb_submit_urb.
  568. */
  569. static int digi_write_oob_command(struct usb_serial_port *port,
  570. unsigned char *buf, int count, int interruptible)
  571. {
  572. int ret = 0;
  573. int len;
  574. struct usb_serial_port *oob_port = (struct usb_serial_port *)((struct digi_serial *)(usb_get_serial_data(port->serial)))->ds_oob_port;
  575. struct digi_port *oob_priv = usb_get_serial_port_data(oob_port);
  576. unsigned long flags = 0;
  577. dbg("digi_write_oob_command: TOP: port=%d, count=%d", oob_priv->dp_port_num, count);
  578. spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
  579. while (count > 0) {
  580. while (oob_priv->dp_write_urb_in_use) {
  581. cond_wait_interruptible_timeout_irqrestore(
  582. &oob_port->write_wait, DIGI_RETRY_TIMEOUT,
  583. &oob_priv->dp_port_lock, flags);
  584. if (interruptible && signal_pending(current))
  585. return -EINTR;
  586. spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
  587. }
  588. /* len must be a multiple of 4, so commands are not split */
  589. len = min(count, oob_port->bulk_out_size);
  590. if (len > 4)
  591. len &= ~3;
  592. memcpy(oob_port->write_urb->transfer_buffer, buf, len);
  593. oob_port->write_urb->transfer_buffer_length = len;
  594. oob_port->write_urb->dev = port->serial->dev;
  595. ret = usb_submit_urb(oob_port->write_urb, GFP_ATOMIC);
  596. if (ret == 0) {
  597. oob_priv->dp_write_urb_in_use = 1;
  598. count -= len;
  599. buf += len;
  600. }
  601. }
  602. spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags);
  603. if (ret)
  604. dev_err(&port->dev, "%s: usb_submit_urb failed, ret=%d\n",
  605. __func__, ret);
  606. return ret;
  607. }
  608. /*
  609. * Digi Write In Band Command
  610. *
  611. * Write commands on the given port. Commands are 4
  612. * bytes each, multiple commands can be sent at once, and
  613. * no command will be split across USB packets. If timeout
  614. * is non-zero, write in band command will return after
  615. * waiting unsuccessfully for the URB status to clear for
  616. * timeout ticks. Returns 0 if successful, or a negative
  617. * error returned by digi_write.
  618. */
  619. static int digi_write_inb_command(struct usb_serial_port *port,
  620. unsigned char *buf, int count, unsigned long timeout)
  621. {
  622. int ret = 0;
  623. int len;
  624. struct digi_port *priv = usb_get_serial_port_data(port);
  625. unsigned char *data = port->write_urb->transfer_buffer;
  626. unsigned long flags = 0;
  627. dbg("digi_write_inb_command: TOP: port=%d, count=%d",
  628. priv->dp_port_num, count);
  629. if (timeout)
  630. timeout += jiffies;
  631. else
  632. timeout = ULONG_MAX;
  633. spin_lock_irqsave(&priv->dp_port_lock, flags);
  634. while (count > 0 && ret == 0) {
  635. while (priv->dp_write_urb_in_use &&
  636. time_before(jiffies, timeout)) {
  637. cond_wait_interruptible_timeout_irqrestore(
  638. &port->write_wait, DIGI_RETRY_TIMEOUT,
  639. &priv->dp_port_lock, flags);
  640. if (signal_pending(current))
  641. return -EINTR;
  642. spin_lock_irqsave(&priv->dp_port_lock, flags);
  643. }
  644. /* len must be a multiple of 4 and small enough to */
  645. /* guarantee the write will send buffered data first, */
  646. /* so commands are in order with data and not split */
  647. len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len);
  648. if (len > 4)
  649. len &= ~3;
  650. /* write any buffered data first */
  651. if (priv->dp_out_buf_len > 0) {
  652. data[0] = DIGI_CMD_SEND_DATA;
  653. data[1] = priv->dp_out_buf_len;
  654. memcpy(data + 2, priv->dp_out_buf,
  655. priv->dp_out_buf_len);
  656. memcpy(data + 2 + priv->dp_out_buf_len, buf, len);
  657. port->write_urb->transfer_buffer_length
  658. = priv->dp_out_buf_len + 2 + len;
  659. } else {
  660. memcpy(data, buf, len);
  661. port->write_urb->transfer_buffer_length = len;
  662. }
  663. port->write_urb->dev = port->serial->dev;
  664. ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
  665. if (ret == 0) {
  666. priv->dp_write_urb_in_use = 1;
  667. priv->dp_out_buf_len = 0;
  668. count -= len;
  669. buf += len;
  670. }
  671. }
  672. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  673. if (ret)
  674. dev_err(&port->dev,
  675. "%s: usb_submit_urb failed, ret=%d, port=%d\n",
  676. __func__, ret, priv->dp_port_num);
  677. return ret;
  678. }
  679. /*
  680. * Digi Set Modem Signals
  681. *
  682. * Sets or clears DTR and RTS on the port, according to the
  683. * modem_signals argument. Use TIOCM_DTR and TIOCM_RTS flags
  684. * for the modem_signals argument. Returns 0 if successful,
  685. * -EINTR if interrupted while sleeping, or a non-zero error
  686. * returned by usb_submit_urb.
  687. */
  688. static int digi_set_modem_signals(struct usb_serial_port *port,
  689. unsigned int modem_signals, int interruptible)
  690. {
  691. int ret;
  692. struct digi_port *port_priv = usb_get_serial_port_data(port);
  693. struct usb_serial_port *oob_port = (struct usb_serial_port *) ((struct digi_serial *)(usb_get_serial_data(port->serial)))->ds_oob_port;
  694. struct digi_port *oob_priv = usb_get_serial_port_data(oob_port);
  695. unsigned char *data = oob_port->write_urb->transfer_buffer;
  696. unsigned long flags = 0;
  697. dbg("digi_set_modem_signals: TOP: port=%d, modem_signals=0x%x",
  698. port_priv->dp_port_num, modem_signals);
  699. spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
  700. spin_lock(&port_priv->dp_port_lock);
  701. while (oob_priv->dp_write_urb_in_use) {
  702. spin_unlock(&port_priv->dp_port_lock);
  703. cond_wait_interruptible_timeout_irqrestore(
  704. &oob_port->write_wait, DIGI_RETRY_TIMEOUT,
  705. &oob_priv->dp_port_lock, flags);
  706. if (interruptible && signal_pending(current))
  707. return -EINTR;
  708. spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
  709. spin_lock(&port_priv->dp_port_lock);
  710. }
  711. data[0] = DIGI_CMD_SET_DTR_SIGNAL;
  712. data[1] = port_priv->dp_port_num;
  713. data[2] = (modem_signals & TIOCM_DTR) ?
  714. DIGI_DTR_ACTIVE : DIGI_DTR_INACTIVE;
  715. data[3] = 0;
  716. data[4] = DIGI_CMD_SET_RTS_SIGNAL;
  717. data[5] = port_priv->dp_port_num;
  718. data[6] = (modem_signals & TIOCM_RTS) ?
  719. DIGI_RTS_ACTIVE : DIGI_RTS_INACTIVE;
  720. data[7] = 0;
  721. oob_port->write_urb->transfer_buffer_length = 8;
  722. oob_port->write_urb->dev = port->serial->dev;
  723. ret = usb_submit_urb(oob_port->write_urb, GFP_ATOMIC);
  724. if (ret == 0) {
  725. oob_priv->dp_write_urb_in_use = 1;
  726. port_priv->dp_modem_signals =
  727. (port_priv->dp_modem_signals&~(TIOCM_DTR|TIOCM_RTS))
  728. | (modem_signals&(TIOCM_DTR|TIOCM_RTS));
  729. }
  730. spin_unlock(&port_priv->dp_port_lock);
  731. spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags);
  732. if (ret)
  733. dev_err(&port->dev, "%s: usb_submit_urb failed, ret=%d\n",
  734. __func__, ret);
  735. return ret;
  736. }
  737. /*
  738. * Digi Transmit Idle
  739. *
  740. * Digi transmit idle waits, up to timeout ticks, for the transmitter
  741. * to go idle. It returns 0 if successful or a negative error.
  742. *
  743. * There are race conditions here if more than one process is calling
  744. * digi_transmit_idle on the same port at the same time. However, this
  745. * is only called from close, and only one process can be in close on a
  746. * port at a time, so its ok.
  747. */
  748. static int digi_transmit_idle(struct usb_serial_port *port,
  749. unsigned long timeout)
  750. {
  751. int ret;
  752. unsigned char buf[2];
  753. struct digi_port *priv = usb_get_serial_port_data(port);
  754. unsigned long flags = 0;
  755. spin_lock_irqsave(&priv->dp_port_lock, flags);
  756. priv->dp_transmit_idle = 0;
  757. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  758. buf[0] = DIGI_CMD_TRANSMIT_IDLE;
  759. buf[1] = 0;
  760. timeout += jiffies;
  761. ret = digi_write_inb_command(port, buf, 2, timeout - jiffies);
  762. if (ret != 0)
  763. return ret;
  764. spin_lock_irqsave(&priv->dp_port_lock, flags);
  765. while (time_before(jiffies, timeout) && !priv->dp_transmit_idle) {
  766. cond_wait_interruptible_timeout_irqrestore(
  767. &priv->dp_transmit_idle_wait, DIGI_RETRY_TIMEOUT,
  768. &priv->dp_port_lock, flags);
  769. if (signal_pending(current))
  770. return -EINTR;
  771. spin_lock_irqsave(&priv->dp_port_lock, flags);
  772. }
  773. priv->dp_transmit_idle = 0;
  774. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  775. return 0;
  776. }
  777. static void digi_rx_throttle(struct tty_struct *tty)
  778. {
  779. unsigned long flags;
  780. struct usb_serial_port *port = tty->driver_data;
  781. struct digi_port *priv = usb_get_serial_port_data(port);
  782. dbg("digi_rx_throttle: TOP: port=%d", priv->dp_port_num);
  783. /* stop receiving characters by not resubmitting the read urb */
  784. spin_lock_irqsave(&priv->dp_port_lock, flags);
  785. priv->dp_throttled = 1;
  786. priv->dp_throttle_restart = 0;
  787. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  788. }
  789. static void digi_rx_unthrottle(struct tty_struct *tty)
  790. {
  791. int ret = 0;
  792. unsigned long flags;
  793. struct usb_serial_port *port = tty->driver_data;
  794. struct digi_port *priv = usb_get_serial_port_data(port);
  795. dbg("digi_rx_unthrottle: TOP: port=%d", priv->dp_port_num);
  796. spin_lock_irqsave(&priv->dp_port_lock, flags);
  797. /* restart read chain */
  798. if (priv->dp_throttle_restart) {
  799. port->read_urb->dev = port->serial->dev;
  800. ret = usb_submit_urb(port->read_urb, GFP_ATOMIC);
  801. }
  802. /* turn throttle off */
  803. priv->dp_throttled = 0;
  804. priv->dp_throttle_restart = 0;
  805. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  806. if (ret)
  807. dev_err(&port->dev,
  808. "%s: usb_submit_urb failed, ret=%d, port=%d\n",
  809. __func__, ret, priv->dp_port_num);
  810. }
  811. static void digi_set_termios(struct tty_struct *tty,
  812. struct usb_serial_port *port, struct ktermios *old_termios)
  813. {
  814. struct digi_port *priv = usb_get_serial_port_data(port);
  815. unsigned int iflag = tty->termios->c_iflag;
  816. unsigned int cflag = tty->termios->c_cflag;
  817. unsigned int old_iflag = old_termios->c_iflag;
  818. unsigned int old_cflag = old_termios->c_cflag;
  819. unsigned char buf[32];
  820. unsigned int modem_signals;
  821. int arg, ret;
  822. int i = 0;
  823. speed_t baud;
  824. dbg("digi_set_termios: TOP: port=%d, iflag=0x%x, old_iflag=0x%x, cflag=0x%x, old_cflag=0x%x", priv->dp_port_num, iflag, old_iflag, cflag, old_cflag);
  825. /* set baud rate */
  826. baud = tty_get_baud_rate(tty);
  827. if (baud != tty_termios_baud_rate(old_termios)) {
  828. arg = -1;
  829. /* reassert DTR and (maybe) RTS on transition from B0 */
  830. if ((old_cflag&CBAUD) == B0) {
  831. /* don't set RTS if using hardware flow control */
  832. /* and throttling input */
  833. modem_signals = TIOCM_DTR;
  834. if (!(tty->termios->c_cflag & CRTSCTS) ||
  835. !test_bit(TTY_THROTTLED, &tty->flags))
  836. modem_signals |= TIOCM_RTS;
  837. digi_set_modem_signals(port, modem_signals, 1);
  838. }
  839. switch (baud) {
  840. /* drop DTR and RTS on transition to B0 */
  841. case 0: digi_set_modem_signals(port, 0, 1); break;
  842. case 50: arg = DIGI_BAUD_50; break;
  843. case 75: arg = DIGI_BAUD_75; break;
  844. case 110: arg = DIGI_BAUD_110; break;
  845. case 150: arg = DIGI_BAUD_150; break;
  846. case 200: arg = DIGI_BAUD_200; break;
  847. case 300: arg = DIGI_BAUD_300; break;
  848. case 600: arg = DIGI_BAUD_600; break;
  849. case 1200: arg = DIGI_BAUD_1200; break;
  850. case 1800: arg = DIGI_BAUD_1800; break;
  851. case 2400: arg = DIGI_BAUD_2400; break;
  852. case 4800: arg = DIGI_BAUD_4800; break;
  853. case 9600: arg = DIGI_BAUD_9600; break;
  854. case 19200: arg = DIGI_BAUD_19200; break;
  855. case 38400: arg = DIGI_BAUD_38400; break;
  856. case 57600: arg = DIGI_BAUD_57600; break;
  857. case 115200: arg = DIGI_BAUD_115200; break;
  858. case 230400: arg = DIGI_BAUD_230400; break;
  859. case 460800: arg = DIGI_BAUD_460800; break;
  860. default:
  861. arg = DIGI_BAUD_9600;
  862. baud = 9600;
  863. break;
  864. }
  865. if (arg != -1) {
  866. buf[i++] = DIGI_CMD_SET_BAUD_RATE;
  867. buf[i++] = priv->dp_port_num;
  868. buf[i++] = arg;
  869. buf[i++] = 0;
  870. }
  871. }
  872. /* set parity */
  873. tty->termios->c_cflag &= ~CMSPAR;
  874. if ((cflag&(PARENB|PARODD)) != (old_cflag&(PARENB|PARODD))) {
  875. if (cflag&PARENB) {
  876. if (cflag&PARODD)
  877. arg = DIGI_PARITY_ODD;
  878. else
  879. arg = DIGI_PARITY_EVEN;
  880. } else {
  881. arg = DIGI_PARITY_NONE;
  882. }
  883. buf[i++] = DIGI_CMD_SET_PARITY;
  884. buf[i++] = priv->dp_port_num;
  885. buf[i++] = arg;
  886. buf[i++] = 0;
  887. }
  888. /* set word size */
  889. if ((cflag&CSIZE) != (old_cflag&CSIZE)) {
  890. arg = -1;
  891. switch (cflag&CSIZE) {
  892. case CS5: arg = DIGI_WORD_SIZE_5; break;
  893. case CS6: arg = DIGI_WORD_SIZE_6; break;
  894. case CS7: arg = DIGI_WORD_SIZE_7; break;
  895. case CS8: arg = DIGI_WORD_SIZE_8; break;
  896. default:
  897. dbg("digi_set_termios: can't handle word size %d",
  898. (cflag&CSIZE));
  899. break;
  900. }
  901. if (arg != -1) {
  902. buf[i++] = DIGI_CMD_SET_WORD_SIZE;
  903. buf[i++] = priv->dp_port_num;
  904. buf[i++] = arg;
  905. buf[i++] = 0;
  906. }
  907. }
  908. /* set stop bits */
  909. if ((cflag&CSTOPB) != (old_cflag&CSTOPB)) {
  910. if ((cflag&CSTOPB))
  911. arg = DIGI_STOP_BITS_2;
  912. else
  913. arg = DIGI_STOP_BITS_1;
  914. buf[i++] = DIGI_CMD_SET_STOP_BITS;
  915. buf[i++] = priv->dp_port_num;
  916. buf[i++] = arg;
  917. buf[i++] = 0;
  918. }
  919. /* set input flow control */
  920. if ((iflag&IXOFF) != (old_iflag&IXOFF)
  921. || (cflag&CRTSCTS) != (old_cflag&CRTSCTS)) {
  922. arg = 0;
  923. if (iflag&IXOFF)
  924. arg |= DIGI_INPUT_FLOW_CONTROL_XON_XOFF;
  925. else
  926. arg &= ~DIGI_INPUT_FLOW_CONTROL_XON_XOFF;
  927. if (cflag&CRTSCTS) {
  928. arg |= DIGI_INPUT_FLOW_CONTROL_RTS;
  929. /* On USB-4 it is necessary to assert RTS prior */
  930. /* to selecting RTS input flow control. */
  931. buf[i++] = DIGI_CMD_SET_RTS_SIGNAL;
  932. buf[i++] = priv->dp_port_num;
  933. buf[i++] = DIGI_RTS_ACTIVE;
  934. buf[i++] = 0;
  935. } else {
  936. arg &= ~DIGI_INPUT_FLOW_CONTROL_RTS;
  937. }
  938. buf[i++] = DIGI_CMD_SET_INPUT_FLOW_CONTROL;
  939. buf[i++] = priv->dp_port_num;
  940. buf[i++] = arg;
  941. buf[i++] = 0;
  942. }
  943. /* set output flow control */
  944. if ((iflag & IXON) != (old_iflag & IXON)
  945. || (cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
  946. arg = 0;
  947. if (iflag & IXON)
  948. arg |= DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF;
  949. else
  950. arg &= ~DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF;
  951. if (cflag & CRTSCTS) {
  952. arg |= DIGI_OUTPUT_FLOW_CONTROL_CTS;
  953. } else {
  954. arg &= ~DIGI_OUTPUT_FLOW_CONTROL_CTS;
  955. tty->hw_stopped = 0;
  956. }
  957. buf[i++] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL;
  958. buf[i++] = priv->dp_port_num;
  959. buf[i++] = arg;
  960. buf[i++] = 0;
  961. }
  962. /* set receive enable/disable */
  963. if ((cflag & CREAD) != (old_cflag & CREAD)) {
  964. if (cflag & CREAD)
  965. arg = DIGI_ENABLE;
  966. else
  967. arg = DIGI_DISABLE;
  968. buf[i++] = DIGI_CMD_RECEIVE_ENABLE;
  969. buf[i++] = priv->dp_port_num;
  970. buf[i++] = arg;
  971. buf[i++] = 0;
  972. }
  973. ret = digi_write_oob_command(port, buf, i, 1);
  974. if (ret != 0)
  975. dbg("digi_set_termios: write oob failed, ret=%d", ret);
  976. tty_encode_baud_rate(tty, baud, baud);
  977. }
  978. static void digi_break_ctl(struct tty_struct *tty, int break_state)
  979. {
  980. struct usb_serial_port *port = tty->driver_data;
  981. unsigned char buf[4];
  982. buf[0] = DIGI_CMD_BREAK_CONTROL;
  983. buf[1] = 2; /* length */
  984. buf[2] = break_state ? 1 : 0;
  985. buf[3] = 0; /* pad */
  986. digi_write_inb_command(port, buf, 4, 0);
  987. }
  988. static int digi_tiocmget(struct tty_struct *tty, struct file *file)
  989. {
  990. struct usb_serial_port *port = tty->driver_data;
  991. struct digi_port *priv = usb_get_serial_port_data(port);
  992. unsigned int val;
  993. unsigned long flags;
  994. dbg("%s: TOP: port=%d", __func__, priv->dp_port_num);
  995. spin_lock_irqsave(&priv->dp_port_lock, flags);
  996. val = priv->dp_modem_signals;
  997. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  998. return val;
  999. }
  1000. static int digi_tiocmset(struct tty_struct *tty, struct file *file,
  1001. unsigned int set, unsigned int clear)
  1002. {
  1003. struct usb_serial_port *port = tty->driver_data;
  1004. struct digi_port *priv = usb_get_serial_port_data(port);
  1005. unsigned int val;
  1006. unsigned long flags;
  1007. dbg("%s: TOP: port=%d", __func__, priv->dp_port_num);
  1008. spin_lock_irqsave(&priv->dp_port_lock, flags);
  1009. val = (priv->dp_modem_signals & ~clear) | set;
  1010. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  1011. return digi_set_modem_signals(port, val, 1);
  1012. }
  1013. static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
  1014. const unsigned char *buf, int count)
  1015. {
  1016. int ret, data_len, new_len;
  1017. struct digi_port *priv = usb_get_serial_port_data(port);
  1018. unsigned char *data = port->write_urb->transfer_buffer;
  1019. unsigned long flags = 0;
  1020. dbg("digi_write: TOP: port=%d, count=%d, in_interrupt=%ld",
  1021. priv->dp_port_num, count, in_interrupt());
  1022. /* copy user data (which can sleep) before getting spin lock */
  1023. count = min(count, port->bulk_out_size-2);
  1024. count = min(64, count);
  1025. /* be sure only one write proceeds at a time */
  1026. /* there are races on the port private buffer */
  1027. spin_lock_irqsave(&priv->dp_port_lock, flags);
  1028. /* wait for urb status clear to submit another urb */
  1029. if (priv->dp_write_urb_in_use) {
  1030. /* buffer data if count is 1 (probably put_char) if possible */
  1031. if (count == 1 && priv->dp_out_buf_len < DIGI_OUT_BUF_SIZE) {
  1032. priv->dp_out_buf[priv->dp_out_buf_len++] = *buf;
  1033. new_len = 1;
  1034. } else {
  1035. new_len = 0;
  1036. }
  1037. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  1038. return new_len;
  1039. }
  1040. /* allow space for any buffered data and for new data, up to */
  1041. /* transfer buffer size - 2 (for command and length bytes) */
  1042. new_len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len);
  1043. data_len = new_len + priv->dp_out_buf_len;
  1044. if (data_len == 0) {
  1045. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  1046. return 0;
  1047. }
  1048. port->write_urb->transfer_buffer_length = data_len+2;
  1049. port->write_urb->dev = port->serial->dev;
  1050. *data++ = DIGI_CMD_SEND_DATA;
  1051. *data++ = data_len;
  1052. /* copy in buffered data first */
  1053. memcpy(data, priv->dp_out_buf, priv->dp_out_buf_len);
  1054. data += priv->dp_out_buf_len;
  1055. /* copy in new data */
  1056. memcpy(data, buf, new_len);
  1057. ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
  1058. if (ret == 0) {
  1059. priv->dp_write_urb_in_use = 1;
  1060. ret = new_len;
  1061. priv->dp_out_buf_len = 0;
  1062. }
  1063. /* return length of new data written, or error */
  1064. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  1065. if (ret < 0)
  1066. dev_err(&port->dev,
  1067. "%s: usb_submit_urb failed, ret=%d, port=%d\n",
  1068. __func__, ret, priv->dp_port_num);
  1069. dbg("digi_write: returning %d", ret);
  1070. return ret;
  1071. }
  1072. static void digi_write_bulk_callback(struct urb *urb)
  1073. {
  1074. struct usb_serial_port *port = urb->context;
  1075. struct usb_serial *serial;
  1076. struct digi_port *priv;
  1077. struct digi_serial *serial_priv;
  1078. int ret = 0;
  1079. int status = urb->status;
  1080. dbg("digi_write_bulk_callback: TOP, status=%d", status);
  1081. /* port and serial sanity check */
  1082. if (port == NULL || (priv = usb_get_serial_port_data(port)) == NULL) {
  1083. dev_err(&port->dev,
  1084. "%s: port or port->private is NULL, status=%d\n",
  1085. __func__, status);
  1086. return;
  1087. }
  1088. serial = port->serial;
  1089. if (serial == NULL || (serial_priv = usb_get_serial_data(serial)) == NULL) {
  1090. dev_err(&port->dev,
  1091. "%s: serial or serial->private is NULL, status=%d\n",
  1092. __func__, status);
  1093. return;
  1094. }
  1095. /* handle oob callback */
  1096. if (priv->dp_port_num == serial_priv->ds_oob_port_num) {
  1097. dbg("digi_write_bulk_callback: oob callback");
  1098. spin_lock(&priv->dp_port_lock);
  1099. priv->dp_write_urb_in_use = 0;
  1100. wake_up_interruptible(&port->write_wait);
  1101. spin_unlock(&priv->dp_port_lock);
  1102. return;
  1103. }
  1104. /* try to send any buffered data on this port, if it is open */
  1105. spin_lock(&priv->dp_port_lock);
  1106. priv->dp_write_urb_in_use = 0;
  1107. if (port->port.count && priv->dp_out_buf_len > 0) {
  1108. *((unsigned char *)(port->write_urb->transfer_buffer))
  1109. = (unsigned char)DIGI_CMD_SEND_DATA;
  1110. *((unsigned char *)(port->write_urb->transfer_buffer) + 1)
  1111. = (unsigned char)priv->dp_out_buf_len;
  1112. port->write_urb->transfer_buffer_length =
  1113. priv->dp_out_buf_len + 2;
  1114. port->write_urb->dev = serial->dev;
  1115. memcpy(port->write_urb->transfer_buffer + 2, priv->dp_out_buf,
  1116. priv->dp_out_buf_len);
  1117. ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
  1118. if (ret == 0) {
  1119. priv->dp_write_urb_in_use = 1;
  1120. priv->dp_out_buf_len = 0;
  1121. }
  1122. }
  1123. /* wake up processes sleeping on writes immediately */
  1124. digi_wakeup_write(port);
  1125. /* also queue up a wakeup at scheduler time, in case we */
  1126. /* lost the race in write_chan(). */
  1127. schedule_work(&priv->dp_wakeup_work);
  1128. spin_unlock(&priv->dp_port_lock);
  1129. if (ret)
  1130. dev_err(&port->dev,
  1131. "%s: usb_submit_urb failed, ret=%d, port=%d\n",
  1132. __func__, ret, priv->dp_port_num);
  1133. }
  1134. static int digi_write_room(struct tty_struct *tty)
  1135. {
  1136. struct usb_serial_port *port = tty->driver_data;
  1137. struct digi_port *priv = usb_get_serial_port_data(port);
  1138. int room;
  1139. unsigned long flags = 0;
  1140. spin_lock_irqsave(&priv->dp_port_lock, flags);
  1141. if (priv->dp_write_urb_in_use)
  1142. room = 0;
  1143. else
  1144. room = port->bulk_out_size - 2 - priv->dp_out_buf_len;
  1145. spin_unlock_irqrestore(&priv->dp_port_lock, flags);
  1146. dbg("digi_write_room: port=%d, room=%d", priv->dp_port_num, room);
  1147. return room;
  1148. }
  1149. static int digi_chars_in_buffer(struct tty_struct *tty)
  1150. {
  1151. struct usb_serial_port *port = tty->driver_data;
  1152. struct digi_port *priv = usb_get_serial_port_data(port);
  1153. if (priv->dp_write_urb_in_use) {
  1154. dbg("digi_chars_in_buffer: port=%d, chars=%d",
  1155. priv->dp_port_num, port->bulk_out_size - 2);
  1156. /* return(port->bulk_out_size - 2); */
  1157. return 256;
  1158. } else {
  1159. dbg("digi_chars_in_buffer: port=%d, chars=%d",
  1160. priv->dp_port_num, priv->dp_out_buf_len);
  1161. return priv->dp_out_buf_len;
  1162. }
  1163. }
  1164. static void digi_dtr_rts(struct usb_serial_port *port, int on)
  1165. {
  1166. /* Adjust DTR and RTS */
  1167. digi_set_modem_signals(port, on * (TIOCM_DTR|TIOCM_RTS), 1);
  1168. }
  1169. static int digi_carrier_raised(struct usb_serial_port *port)
  1170. {
  1171. struct digi_port *priv = usb_get_serial_port_data(port);
  1172. if (priv->dp_modem_signals & TIOCM_CD)
  1173. return 1;
  1174. return 0;
  1175. }
  1176. static int digi_open(struct tty_struct *tty, struct usb_serial_port *port)
  1177. {
  1178. int ret;
  1179. unsigned char buf[32];
  1180. struct digi_port *priv = usb_get_serial_port_data(port);
  1181. struct ktermios not_termios;
  1182. dbg("digi_open: TOP: port=%d, open_count=%d",
  1183. priv->dp_port_num, port->port.count);
  1184. /* be sure the device is started up */
  1185. if (digi_startup_device(port->serial) != 0)
  1186. return -ENXIO;
  1187. /* read modem signals automatically whenever they change */
  1188. buf[0] = DIGI_CMD_READ_INPUT_SIGNALS;
  1189. buf[1] = priv->dp_port_num;
  1190. buf[2] = DIGI_ENABLE;
  1191. buf[3] = 0;
  1192. /* flush fifos */
  1193. buf[4] = DIGI_CMD_IFLUSH_FIFO;
  1194. buf[5] = priv->dp_port_num;
  1195. buf[6] = DIGI_FLUSH_TX | DIGI_FLUSH_RX;
  1196. buf[7] = 0;
  1197. ret = digi_write_oob_command(port, buf, 8, 1);
  1198. if (ret != 0)
  1199. dbg("digi_open: write oob failed, ret=%d", ret);
  1200. /* set termios settings */
  1201. if (tty) {
  1202. not_termios.c_cflag = ~tty->termios->c_cflag;
  1203. not_termios.c_iflag = ~tty->termios->c_iflag;
  1204. digi_set_termios(tty, port, &not_termios);
  1205. }
  1206. return 0;
  1207. }
  1208. static void digi_close(struct usb_serial_port *port)
  1209. {
  1210. DEFINE_WAIT(wait);
  1211. int ret;
  1212. unsigned char buf[32];
  1213. struct digi_port *priv = usb_get_serial_port_data(port);
  1214. dbg("digi_close: TOP: port=%d, open_count=%d",
  1215. priv->dp_port_num, port->port.count);
  1216. mutex_lock(&port->serial->disc_mutex);
  1217. /* if disconnected, just clear flags */
  1218. if (port->serial->disconnected)
  1219. goto exit;
  1220. if (port->serial->dev) {
  1221. /* FIXME: Transmit idle belongs in the wait_unti_sent path */
  1222. digi_transmit_idle(port, DIGI_CLOSE_TIMEOUT);
  1223. /* disable input flow control */
  1224. buf[0] = DIGI_CMD_SET_INPUT_FLOW_CONTROL;
  1225. buf[1] = priv->dp_port_num;
  1226. buf[2] = DIGI_DISABLE;
  1227. buf[3] = 0;
  1228. /* disable output flow control */
  1229. buf[4] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL;
  1230. buf[5] = priv->dp_port_num;
  1231. buf[6] = DIGI_DISABLE;
  1232. buf[7] = 0;
  1233. /* disable reading modem signals automatically */
  1234. buf[8] = DIGI_CMD_READ_INPUT_SIGNALS;
  1235. buf[9] = priv->dp_port_num;
  1236. buf[10] = DIGI_DISABLE;
  1237. buf[11] = 0;
  1238. /* disable receive */
  1239. buf[12] = DIGI_CMD_RECEIVE_ENABLE;
  1240. buf[13] = priv->dp_port_num;
  1241. buf[14] = DIGI_DISABLE;
  1242. buf[15] = 0;
  1243. /* flush fifos */
  1244. buf[16] = DIGI_CMD_IFLUSH_FIFO;
  1245. buf[17] = priv->dp_port_num;
  1246. buf[18] = DIGI_FLUSH_TX | DIGI_FLUSH_RX;
  1247. buf[19] = 0;
  1248. ret = digi_write_oob_command(port, buf, 20, 0);
  1249. if (ret != 0)
  1250. dbg("digi_close: write oob failed, ret=%d", ret);
  1251. /* wait for final commands on oob port to complete */
  1252. prepare_to_wait(&priv->dp_flush_wait, &wait,
  1253. TASK_INTERRUPTIBLE);
  1254. schedule_timeout(DIGI_CLOSE_TIMEOUT);
  1255. finish_wait(&priv->dp_flush_wait, &wait);
  1256. /* shutdown any outstanding bulk writes */
  1257. usb_kill_urb(port->write_urb);
  1258. }
  1259. exit:
  1260. spin_lock_irq(&priv->dp_port_lock);
  1261. priv->dp_write_urb_in_use = 0;
  1262. wake_up_interruptible(&priv->dp_close_wait);
  1263. spin_unlock_irq(&priv->dp_port_lock);
  1264. mutex_unlock(&port->serial->disc_mutex);
  1265. dbg("digi_close: done");
  1266. }
  1267. /*
  1268. * Digi Startup Device
  1269. *
  1270. * Starts reads on all ports. Must be called AFTER startup, with
  1271. * urbs initialized. Returns 0 if successful, non-zero error otherwise.
  1272. */
  1273. static int digi_startup_device(struct usb_serial *serial)
  1274. {
  1275. int i, ret = 0;
  1276. struct digi_serial *serial_priv = usb_get_serial_data(serial);
  1277. struct usb_serial_port *port;
  1278. /* be sure this happens exactly once */
  1279. spin_lock(&serial_priv->ds_serial_lock);
  1280. if (serial_priv->ds_device_started) {
  1281. spin_unlock(&serial_priv->ds_serial_lock);
  1282. return 0;
  1283. }
  1284. serial_priv->ds_device_started = 1;
  1285. spin_unlock(&serial_priv->ds_serial_lock);
  1286. /* start reading from each bulk in endpoint for the device */
  1287. /* set USB_DISABLE_SPD flag for write bulk urbs */
  1288. for (i = 0; i < serial->type->num_ports + 1; i++) {
  1289. port = serial->port[i];
  1290. port->write_urb->dev = port->serial->dev;
  1291. ret = usb_submit_urb(port->read_urb, GFP_KERNEL);
  1292. if (ret != 0) {
  1293. dev_err(&port->dev,
  1294. "%s: usb_submit_urb failed, ret=%d, port=%d\n",
  1295. __func__, ret, i);
  1296. break;
  1297. }
  1298. }
  1299. return ret;
  1300. }
  1301. static int digi_startup(struct usb_serial *serial)
  1302. {
  1303. int i;
  1304. struct digi_port *priv;
  1305. struct digi_serial *serial_priv;
  1306. dbg("digi_startup: TOP");
  1307. /* allocate the private data structures for all ports */
  1308. /* number of regular ports + 1 for the out-of-band port */
  1309. for (i = 0; i < serial->type->num_ports + 1; i++) {
  1310. /* allocate port private structure */
  1311. priv = kmalloc(sizeof(struct digi_port), GFP_KERNEL);
  1312. if (priv == NULL) {
  1313. while (--i >= 0)
  1314. kfree(usb_get_serial_port_data(serial->port[i]));
  1315. return 1; /* error */
  1316. }
  1317. /* initialize port private structure */
  1318. spin_lock_init(&priv->dp_port_lock);
  1319. priv->dp_port_num = i;
  1320. priv->dp_out_buf_len = 0;
  1321. priv->dp_write_urb_in_use = 0;
  1322. priv->dp_modem_signals = 0;
  1323. init_waitqueue_head(&priv->dp_modem_change_wait);
  1324. priv->dp_transmit_idle = 0;
  1325. init_waitqueue_head(&priv->dp_transmit_idle_wait);
  1326. priv->dp_throttled = 0;
  1327. priv->dp_throttle_restart = 0;
  1328. init_waitqueue_head(&priv->dp_flush_wait);
  1329. init_waitqueue_head(&priv->dp_close_wait);
  1330. INIT_WORK(&priv->dp_wakeup_work, digi_wakeup_write_lock);
  1331. priv->dp_port = serial->port[i];
  1332. /* initialize write wait queue for this port */
  1333. init_waitqueue_head(&serial->port[i]->write_wait);
  1334. usb_set_serial_port_data(serial->port[i], priv);
  1335. }
  1336. /* allocate serial private structure */
  1337. serial_priv = kmalloc(sizeof(struct digi_serial), GFP_KERNEL);
  1338. if (serial_priv == NULL) {
  1339. for (i = 0; i < serial->type->num_ports + 1; i++)
  1340. kfree(usb_get_serial_port_data(serial->port[i]));
  1341. return 1; /* error */
  1342. }
  1343. /* initialize serial private structure */
  1344. spin_lock_init(&serial_priv->ds_serial_lock);
  1345. serial_priv->ds_oob_port_num = serial->type->num_ports;
  1346. serial_priv->ds_oob_port = serial->port[serial_priv->ds_oob_port_num];
  1347. serial_priv->ds_device_started = 0;
  1348. usb_set_serial_data(serial, serial_priv);
  1349. return 0;
  1350. }
  1351. static void digi_disconnect(struct usb_serial *serial)
  1352. {
  1353. int i;
  1354. dbg("digi_disconnect: TOP, in_interrupt()=%ld", in_interrupt());
  1355. /* stop reads and writes on all ports */
  1356. for (i = 0; i < serial->type->num_ports + 1; i++) {
  1357. usb_kill_urb(serial->port[i]->read_urb);
  1358. usb_kill_urb(serial->port[i]->write_urb);
  1359. }
  1360. }
  1361. static void digi_release(struct usb_serial *serial)
  1362. {
  1363. int i;
  1364. dbg("digi_release: TOP, in_interrupt()=%ld", in_interrupt());
  1365. /* free the private data structures for all ports */
  1366. /* number of regular ports + 1 for the out-of-band port */
  1367. for (i = 0; i < serial->type->num_ports + 1; i++)
  1368. kfree(usb_get_serial_port_data(serial->port[i]));
  1369. kfree(usb_get_serial_data(serial));
  1370. }
  1371. static void digi_read_bulk_callback(struct urb *urb)
  1372. {
  1373. struct usb_serial_port *port = urb->context;
  1374. struct digi_port *priv;
  1375. struct digi_serial *serial_priv;
  1376. int ret;
  1377. int status = urb->status;
  1378. dbg("digi_read_bulk_callback: TOP");
  1379. /* port sanity check, do not resubmit if port is not valid */
  1380. if (port == NULL)
  1381. return;
  1382. priv = usb_get_serial_port_data(port);
  1383. if (priv == NULL) {
  1384. dev_err(&port->dev, "%s: port->private is NULL, status=%d\n",
  1385. __func__, status);
  1386. return;
  1387. }
  1388. if (port->serial == NULL ||
  1389. (serial_priv = usb_get_serial_data(port->serial)) == NULL) {
  1390. dev_err(&port->dev, "%s: serial is bad or serial->private "
  1391. "is NULL, status=%d\n", __func__, status);
  1392. return;
  1393. }
  1394. /* do not resubmit urb if it has any status error */
  1395. if (status) {
  1396. dev_err(&port->dev,
  1397. "%s: nonzero read bulk status: status=%d, port=%d\n",
  1398. __func__, status, priv->dp_port_num);
  1399. return;
  1400. }
  1401. /* handle oob or inb callback, do not resubmit if error */
  1402. if (priv->dp_port_num == serial_priv->ds_oob_port_num) {
  1403. if (digi_read_oob_callback(urb) != 0)
  1404. return;
  1405. } else {
  1406. if (digi_read_inb_callback(urb) != 0)
  1407. return;
  1408. }
  1409. /* continue read */
  1410. urb->dev = port->serial->dev;
  1411. ret = usb_submit_urb(urb, GFP_ATOMIC);
  1412. if (ret != 0) {
  1413. dev_err(&port->dev,
  1414. "%s: failed resubmitting urb, ret=%d, port=%d\n",
  1415. __func__, ret, priv->dp_port_num);
  1416. }
  1417. }
  1418. /*
  1419. * Digi Read INB Callback
  1420. *
  1421. * Digi Read INB Callback handles reads on the in band ports, sending
  1422. * the data on to the tty subsystem. When called we know port and
  1423. * port->private are not NULL and port->serial has been validated.
  1424. * It returns 0 if successful, 1 if successful but the port is
  1425. * throttled, and -1 if the sanity checks failed.
  1426. */
  1427. static int digi_read_inb_callback(struct urb *urb)
  1428. {
  1429. struct usb_serial_port *port = urb->context;
  1430. struct tty_struct *tty;
  1431. struct digi_port *priv = usb_get_serial_port_data(port);
  1432. int opcode = ((unsigned char *)urb->transfer_buffer)[0];
  1433. int len = ((unsigned char *)urb->transfer_buffer)[1];
  1434. int port_status = ((unsigned char *)urb->transfer_buffer)[2];
  1435. unsigned char *data = ((unsigned char *)urb->transfer_buffer) + 3;
  1436. int flag, throttled;
  1437. int i;
  1438. int status = urb->status;
  1439. /* do not process callbacks on closed ports */
  1440. /* but do continue the read chain */
  1441. if (port->port.count == 0)
  1442. return 0;
  1443. /* short/multiple packet check */
  1444. if (urb->actual_length != len + 2) {
  1445. dev_err(&port->dev, "%s: INCOMPLETE OR MULTIPLE PACKET, "
  1446. "status=%d, port=%d, opcode=%d, len=%d, "
  1447. "actual_length=%d, status=%d\n", __func__, status,
  1448. priv->dp_port_num, opcode, len, urb->actual_length,
  1449. port_status);
  1450. return -1;
  1451. }
  1452. tty = tty_port_tty_get(&port->port);
  1453. spin_lock(&priv->dp_port_lock);
  1454. /* check for throttle; if set, do not resubmit read urb */
  1455. /* indicate the read chain needs to be restarted on unthrottle */
  1456. throttled = priv->dp_throttled;
  1457. if (throttled)
  1458. priv->dp_throttle_restart = 1;
  1459. /* receive data */
  1460. if (opcode == DIGI_CMD_RECEIVE_DATA) {
  1461. /* get flag from port_status */
  1462. flag = 0;
  1463. /* overrun is special, not associated with a char */
  1464. if (port_status & DIGI_OVERRUN_ERROR)
  1465. tty_insert_flip_char(tty, 0, TTY_OVERRUN);
  1466. /* break takes precedence over parity, */
  1467. /* which takes precedence over framing errors */
  1468. if (port_status & DIGI_BREAK_ERROR)
  1469. flag = TTY_BREAK;
  1470. else if (port_status & DIGI_PARITY_ERROR)
  1471. flag = TTY_PARITY;
  1472. else if (port_status & DIGI_FRAMING_ERROR)
  1473. flag = TTY_FRAME;
  1474. /* data length is len-1 (one byte of len is port_status) */
  1475. --len;
  1476. len = tty_buffer_request_room(tty, len);
  1477. if (len > 0) {
  1478. /* Hot path */
  1479. if (flag == TTY_NORMAL)
  1480. tty_insert_flip_string(tty, data, len);
  1481. else {
  1482. for (i = 0; i < len; i++)
  1483. tty_insert_flip_char(tty,
  1484. data[i], flag);
  1485. }
  1486. tty_flip_buffer_push(tty);
  1487. }
  1488. }
  1489. spin_unlock(&priv->dp_port_lock);
  1490. tty_kref_put(tty);
  1491. if (opcode == DIGI_CMD_RECEIVE_DISABLE)
  1492. dbg("%s: got RECEIVE_DISABLE", __func__);
  1493. else if (opcode != DIGI_CMD_RECEIVE_DATA)
  1494. dbg("%s: unknown opcode: %d", __func__, opcode);
  1495. return throttled ? 1 : 0;
  1496. }
  1497. /*
  1498. * Digi Read OOB Callback
  1499. *
  1500. * Digi Read OOB Callback handles reads on the out of band port.
  1501. * When called we know port and port->private are not NULL and
  1502. * the port->serial is valid. It returns 0 if successful, and
  1503. * -1 if the sanity checks failed.
  1504. */
  1505. static int digi_read_oob_callback(struct urb *urb)
  1506. {
  1507. struct usb_serial_port *port = urb->context;
  1508. struct usb_serial *serial = port->serial;
  1509. struct tty_struct *tty;
  1510. struct digi_port *priv = usb_get_serial_port_data(port);
  1511. int opcode, line, status, val;
  1512. int i;
  1513. unsigned int rts;
  1514. dbg("digi_read_oob_callback: port=%d, len=%d",
  1515. priv->dp_port_num, urb->actual_length);
  1516. /* handle each oob command */
  1517. for (i = 0; i < urb->actual_length - 3;) {
  1518. opcode = ((unsigned char *)urb->transfer_buffer)[i++];
  1519. line = ((unsigned char *)urb->transfer_buffer)[i++];
  1520. status = ((unsigned char *)urb->transfer_buffer)[i++];
  1521. val = ((unsigned char *)urb->transfer_buffer)[i++];
  1522. dbg("digi_read_oob_callback: opcode=%d, line=%d, status=%d, val=%d",
  1523. opcode, line, status, val);
  1524. if (status != 0 || line >= serial->type->num_ports)
  1525. continue;
  1526. port = serial->port[line];
  1527. priv = usb_get_serial_port_data(port);
  1528. if (priv == NULL)
  1529. return -1;
  1530. tty = tty_port_tty_get(&port->port);
  1531. rts = 0;
  1532. if (port->port.count)
  1533. rts = tty->termios->c_cflag & CRTSCTS;
  1534. if (opcode == DIGI_CMD_READ_INPUT_SIGNALS) {
  1535. spin_lock(&priv->dp_port_lock);
  1536. /* convert from digi flags to termiox flags */
  1537. if (val & DIGI_READ_INPUT_SIGNALS_CTS) {
  1538. priv->dp_modem_signals |= TIOCM_CTS;
  1539. /* port must be open to use tty struct */
  1540. if (rts) {
  1541. tty->hw_stopped = 0;
  1542. digi_wakeup_write(port);
  1543. }
  1544. } else {
  1545. priv->dp_modem_signals &= ~TIOCM_CTS;
  1546. /* port must be open to use tty struct */
  1547. if (rts)
  1548. tty->hw_stopped = 1;
  1549. }
  1550. if (val & DIGI_READ_INPUT_SIGNALS_DSR)
  1551. priv->dp_modem_signals |= TIOCM_DSR;
  1552. else
  1553. priv->dp_modem_signals &= ~TIOCM_DSR;
  1554. if (val & DIGI_READ_INPUT_SIGNALS_RI)
  1555. priv->dp_modem_signals |= TIOCM_RI;
  1556. else
  1557. priv->dp_modem_signals &= ~TIOCM_RI;
  1558. if (val & DIGI_READ_INPUT_SIGNALS_DCD)
  1559. priv->dp_modem_signals |= TIOCM_CD;
  1560. else
  1561. priv->dp_modem_signals &= ~TIOCM_CD;
  1562. wake_up_interruptible(&priv->dp_modem_change_wait);
  1563. spin_unlock(&priv->dp_port_lock);
  1564. } else if (opcode == DIGI_CMD_TRANSMIT_IDLE) {
  1565. spin_lock(&priv->dp_port_lock);
  1566. priv->dp_transmit_idle = 1;
  1567. wake_up_interruptible(&priv->dp_transmit_idle_wait);
  1568. spin_unlock(&priv->dp_port_lock);
  1569. } else if (opcode == DIGI_CMD_IFLUSH_FIFO) {
  1570. wake_up_interruptible(&priv->dp_flush_wait);
  1571. }
  1572. tty_kref_put(tty);
  1573. }
  1574. return 0;
  1575. }
  1576. static int __init digi_init(void)
  1577. {
  1578. int retval;
  1579. retval = usb_serial_register(&digi_acceleport_2_device);
  1580. if (retval)
  1581. goto failed_acceleport_2_device;
  1582. retval = usb_serial_register(&digi_acceleport_4_device);
  1583. if (retval)
  1584. goto failed_acceleport_4_device;
  1585. retval = usb_register(&digi_driver);
  1586. if (retval)
  1587. goto failed_usb_register;
  1588. printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
  1589. DRIVER_DESC "\n");
  1590. return 0;
  1591. failed_usb_register:
  1592. usb_serial_deregister(&digi_acceleport_4_device);
  1593. failed_acceleport_4_device:
  1594. usb_serial_deregister(&digi_acceleport_2_device);
  1595. failed_acceleport_2_device:
  1596. return retval;
  1597. }
  1598. static void __exit digi_exit (void)
  1599. {
  1600. usb_deregister(&digi_driver);
  1601. usb_serial_deregister(&digi_acceleport_2_device);
  1602. usb_serial_deregister(&digi_acceleport_4_device);
  1603. }
  1604. module_init(digi_init);
  1605. module_exit(digi_exit);
  1606. MODULE_AUTHOR(DRIVER_AUTHOR);
  1607. MODULE_DESCRIPTION(DRIVER_DESC);
  1608. MODULE_LICENSE("GPL");
  1609. module_param(debug, bool, S_IRUGO | S_IWUSR);
  1610. MODULE_PARM_DESC(debug, "Debug enabled or not");