ftdi_sio.c 75 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304
  1. /*
  2. * USB FTDI SIO driver
  3. *
  4. * Copyright (C) 1999 - 2001
  5. * Greg Kroah-Hartman (greg@kroah.com)
  6. * Bill Ryder (bryder@sgi.com)
  7. * Copyright (C) 2002
  8. * Kuba Ober (kuba@mareimbrium.org)
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License as published by
  12. * the Free Software Foundation; either version 2 of the License, or
  13. * (at your option) any later version.
  14. *
  15. * See Documentation/usb/usb-serial.txt for more information on using this driver
  16. *
  17. * See http://ftdi-usb-sio.sourceforge.net for upto date testing info
  18. * and extra documentation
  19. *
  20. * (21/Jul/2004) Ian Abbott
  21. * Incorporated Steven Turner's code to add support for the FT2232C chip.
  22. * The prelimilary port to the 2.6 kernel was by Rus V. Brushkoff. I have
  23. * fixed a couple of things.
  24. *
  25. * (27/May/2004) Ian Abbott
  26. * Improved throttling code, mostly stolen from the WhiteHEAT driver.
  27. *
  28. * (26/Mar/2004) Jan Capek
  29. * Added PID's for ICD-U20/ICD-U40 - incircuit PIC debuggers from CCS Inc.
  30. *
  31. * (09/Feb/2004) Ian Abbott
  32. * Changed full name of USB-UIRT device to avoid "/" character.
  33. * Added FTDI's alternate PID (0x6006) for FT232/245 devices.
  34. * Added PID for "ELV USB Module UO100" from Stefan Frings.
  35. *
  36. * (21/Oct/2003) Ian Abbott
  37. * Renamed some VID/PID macros for Matrix Orbital and Perle Systems
  38. * devices. Removed Matrix Orbital and Perle Systems devices from the
  39. * 8U232AM device table, but left them in the FT232BM table, as they are
  40. * known to use only FT232BM.
  41. *
  42. * (17/Oct/2003) Scott Allen
  43. * Added vid/pid for Perle Systems UltraPort USB serial converters
  44. *
  45. * (21/Sep/2003) Ian Abbott
  46. * Added VID/PID for Omnidirectional Control Technology US101 USB to
  47. * RS-232 adapter (also rebadged as Dick Smith Electronics XH6381).
  48. * VID/PID supplied by Donald Gordon.
  49. *
  50. * (19/Aug/2003) Ian Abbott
  51. * Freed urb's transfer buffer in write bulk callback.
  52. * Omitted some paranoid checks in write bulk callback that don't matter.
  53. * Scheduled work in write bulk callback regardless of port's open count.
  54. *
  55. * (05/Aug/2003) Ian Abbott
  56. * Added VID/PID for ID TECH IDT1221U USB to RS-232 adapter.
  57. * VID/PID provided by Steve Briggs.
  58. *
  59. * (23/Jul/2003) Ian Abbott
  60. * Added PIDs for CrystalFontz 547, 633, 631, 635, 640 and 640 from
  61. * Wayne Wylupski.
  62. *
  63. * (10/Jul/2003) David Glance
  64. * Added PID for DSS-20 SyncStation cradle for Sony-Ericsson P800.
  65. *
  66. * (27/Jun/2003) Ian Abbott
  67. * Reworked the urb handling logic. We have no more pool, but dynamically
  68. * allocate the urb and the transfer buffer on the fly. In testing this
  69. * does not incure any measurable overhead. This also relies on the fact
  70. * that we have proper reference counting logic for urbs. I nicked this
  71. * from Greg KH's Visor driver.
  72. *
  73. * (23/Jun/2003) Ian Abbott
  74. * Reduced flip buffer pushes and corrected a data length test in
  75. * ftdi_read_bulk_callback.
  76. * Defererence pointers after any paranoid checks, not before.
  77. *
  78. * (21/Jun/2003) Erik Nygren
  79. * Added support for Home Electronics Tira-1 IR transceiver using FT232BM chip.
  80. * See <http://www.home-electro.com/tira1.htm>. Only operates properly
  81. * at 100000 and RTS-CTS, so set custom divisor mode on startup.
  82. * Also force the Tira-1 and USB-UIRT to only use their custom baud rates.
  83. *
  84. * (18/Jun/2003) Ian Abbott
  85. * Added Device ID of the USB relais from Rudolf Gugler (backported from
  86. * Philipp Gühring's patch for 2.5.x kernel).
  87. * Moved read transfer buffer reallocation into startup function.
  88. * Free existing write urb and transfer buffer in startup function.
  89. * Only use urbs in write urb pool that were successfully allocated.
  90. * Moved some constant macros out of functions.
  91. * Minor whitespace and comment changes.
  92. *
  93. * (12/Jun/2003) David Norwood
  94. * Added support for USB-UIRT IR transceiver using 8U232AM chip.
  95. * See <http://home.earthlink.net/~jrhees/USBUIRT/index.htm>. Only
  96. * operates properly at 312500, so set custom divisor mode on startup.
  97. *
  98. * (12/Jun/2003) Ian Abbott
  99. * Added Sealevel SeaLINK+ 210x, 220x, 240x, 280x vid/pids from Tuan Hoang
  100. * - I've eliminated some that don't seem to exist!
  101. * Added Home Electronics Tira-1 IR transceiver pid from Chris Horn
  102. * Some whitespace/coding-style cleanups
  103. *
  104. * (11/Jun/2003) Ian Abbott
  105. * Fixed unsafe spinlock usage in ftdi_write
  106. *
  107. * (24/Feb/2003) Richard Shooter
  108. * Increase read buffer size to improve read speeds at higher baud rates
  109. * (specifically tested with up to 1Mb/sec at 1.5M baud)
  110. *
  111. * (23/Feb/2003) John Wilkins
  112. * Added Xon/xoff flow control (activating support in the ftdi device)
  113. * Added vid/pid for Videonetworks/Homechoice (UK ISP)
  114. *
  115. * (23/Feb/2003) Bill Ryder
  116. * Added matrix orb device vid/pids from Wayne Wylupski
  117. *
  118. * (19/Feb/2003) Ian Abbott
  119. * For TIOCSSERIAL, set alt_speed to 0 when ASYNC_SPD_MASK value has
  120. * changed to something other than ASYNC_SPD_HI, ASYNC_SPD_VHI,
  121. * ASYNC_SPD_SHI or ASYNC_SPD_WARP. Also, unless ASYNC_SPD_CUST is in
  122. * force, don't bother changing baud rate when custom_divisor has changed.
  123. *
  124. * (18/Feb/2003) Ian Abbott
  125. * Fixed TIOCMGET handling to include state of DTR and RTS, the state
  126. * of which are now saved by set_dtr() and set_rts().
  127. * Fixed improper storage class for buf in set_dtr() and set_rts().
  128. * Added FT232BM chip type and support for its extra baud rates (compared
  129. * to FT8U232AM).
  130. * Took account of special case divisor values for highest baud rates of
  131. * FT8U232AM and FT232BM.
  132. * For TIOCSSERIAL, forced alt_speed to 0 when ASYNC_SPD_CUST kludge used,
  133. * as previous alt_speed setting is now stale.
  134. * Moved startup code common between the startup routines for the
  135. * different chip types into a common subroutine.
  136. *
  137. * (17/Feb/2003) Bill Ryder
  138. * Added write urb buffer pool on a per device basis
  139. * Added more checking for open file on callbacks (fixed OOPS)
  140. * Added CrystalFontz 632 and 634 PIDs
  141. * (thanx to CrystalFontz for the sample devices - they flushed out
  142. * some driver bugs)
  143. * Minor debugging message changes
  144. * Added throttle, unthrottle and chars_in_buffer functions
  145. * Fixed FTDI_SIO (the original device) bug
  146. * Fixed some shutdown handling
  147. *
  148. *
  149. *
  150. *
  151. * (07/Jun/2002) Kuba Ober
  152. * Changed FTDI_SIO_BASE_BAUD_TO_DIVISOR macro into ftdi_baud_to_divisor
  153. * function. It was getting too complex.
  154. * Fix the divisor calculation logic which was setting divisor of 0.125
  155. * instead of 0.5 for fractional parts of divisor equal to 5/8, 6/8, 7/8.
  156. * Also make it bump up the divisor to next integer in case of 7/8 - it's
  157. * a better approximation.
  158. *
  159. * (25/Jul/2002) Bill Ryder inserted Dmitri's TIOCMIWAIT patch
  160. * Not tested by me but it doesn't break anything I use.
  161. *
  162. * (04/Jan/2002) Kuba Ober
  163. * Implemented 38400 baudrate kludge, where it can be substituted with other
  164. * values. That's the only way to set custom baudrates.
  165. * Implemented TIOCSSERIAL, TIOCGSERIAL ioctl's so that setserial is happy.
  166. * FIXME: both baudrate things should eventually go to usbserial.c as other
  167. * devices may need that functionality too. Actually, it can probably be
  168. * merged in serial.c somehow - too many drivers repeat this code over
  169. * and over.
  170. * Fixed baudrate forgetfulness - open() used to reset baudrate to 9600 every time.
  171. * Divisors for baudrates are calculated by a macro.
  172. * Small code cleanups. Ugly whitespace changes for Plato's sake only ;-].
  173. *
  174. * (04/Nov/2001) Bill Ryder
  175. * Fixed bug in read_bulk_callback where incorrect urb buffer was used.
  176. * Cleaned up write offset calculation
  177. * Added write_room since default values can be incorrect for sio
  178. * Changed write_bulk_callback to use same queue_task as other drivers
  179. * (the previous version caused panics)
  180. * Removed port iteration code since the device only has one I/O port and it
  181. * was wrong anyway.
  182. *
  183. * (31/May/2001) gkh
  184. * Switched from using spinlock to a semaphore, which fixes lots of problems.
  185. *
  186. * (23/May/2001) Bill Ryder
  187. * Added runtime debug patch (thanx Tyson D Sawyer).
  188. * Cleaned up comments for 8U232
  189. * Added parity, framing and overrun error handling
  190. * Added receive break handling.
  191. *
  192. * (04/08/2001) gb
  193. * Identify version on module load.
  194. *
  195. * (18/March/2001) Bill Ryder
  196. * (Not released)
  197. * Added send break handling. (requires kernel patch too)
  198. * Fixed 8U232AM hardware RTS/CTS etc status reporting.
  199. * Added flipbuf fix copied from generic device
  200. *
  201. * (12/3/2000) Bill Ryder
  202. * Added support for 8U232AM device.
  203. * Moved PID and VIDs into header file only.
  204. * Turned on low-latency for the tty (device will do high baudrates)
  205. * Added shutdown routine to close files when device removed.
  206. * More debug and error message cleanups.
  207. *
  208. * (11/13/2000) Bill Ryder
  209. * Added spinlock protected open code and close code.
  210. * Multiple opens work (sort of - see webpage mentioned above).
  211. * Cleaned up comments. Removed multiple PID/VID definitions.
  212. * Factorised cts/dtr code
  213. * Made use of __FUNCTION__ in dbg's
  214. *
  215. * (11/01/2000) Adam J. Richter
  216. * usb_device_id table support
  217. *
  218. * (10/05/2000) gkh
  219. * Fixed bug with urb->dev not being set properly, now that the usb
  220. * core needs it.
  221. *
  222. * (09/11/2000) gkh
  223. * Removed DEBUG #ifdefs with call to usb_serial_debug_data
  224. *
  225. * (07/19/2000) gkh
  226. * Added module_init and module_exit functions to handle the fact that this
  227. * driver is a loadable module now.
  228. *
  229. * (04/04/2000) Bill Ryder
  230. * Fixed bugs in TCGET/TCSET ioctls (by removing them - they are
  231. * handled elsewhere in the tty io driver chain).
  232. *
  233. * (03/30/2000) Bill Ryder
  234. * Implemented lots of ioctls
  235. * Fixed a race condition in write
  236. * Changed some dbg's to errs
  237. *
  238. * (03/26/2000) gkh
  239. * Split driver up into device specific pieces.
  240. *
  241. */
  242. /* Bill Ryder - bryder@sgi.com - wrote the FTDI_SIO implementation */
  243. /* Thanx to FTDI for so kindly providing details of the protocol required */
  244. /* to talk to the device */
  245. /* Thanx to gkh and the rest of the usb dev group for all code I have assimilated :-) */
  246. #include <linux/kernel.h>
  247. #include <linux/errno.h>
  248. #include <linux/init.h>
  249. #include <linux/slab.h>
  250. #include <linux/tty.h>
  251. #include <linux/tty_driver.h>
  252. #include <linux/tty_flip.h>
  253. #include <linux/module.h>
  254. #include <linux/spinlock.h>
  255. #include <asm/uaccess.h>
  256. #include <linux/usb.h>
  257. #include <linux/serial.h>
  258. #include <linux/usb/serial.h>
  259. #include "ftdi_sio.h"
  260. /*
  261. * Version Information
  262. */
  263. #define DRIVER_VERSION "v1.4.3"
  264. #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>"
  265. #define DRIVER_DESC "USB FTDI Serial Converters Driver"
  266. static int debug;
  267. static __u16 vendor = FTDI_VID;
  268. static __u16 product;
  269. /* struct ftdi_sio_quirk is used by devices requiring special attention. */
  270. struct ftdi_sio_quirk {
  271. int (*probe)(struct usb_serial *);
  272. void (*setup)(struct usb_serial *); /* Special settings during startup. */
  273. };
  274. static int ftdi_olimex_probe (struct usb_serial *serial);
  275. static void ftdi_USB_UIRT_setup (struct usb_serial *serial);
  276. static void ftdi_HE_TIRA1_setup (struct usb_serial *serial);
  277. static struct ftdi_sio_quirk ftdi_olimex_quirk = {
  278. .probe = ftdi_olimex_probe,
  279. };
  280. static struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
  281. .setup = ftdi_USB_UIRT_setup,
  282. };
  283. static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
  284. .setup = ftdi_HE_TIRA1_setup,
  285. };
  286. /*
  287. * The 8U232AM has the same API as the sio except for:
  288. * - it can support MUCH higher baudrates; up to:
  289. * o 921600 for RS232 and 2000000 for RS422/485 at 48MHz
  290. * o 230400 at 12MHz
  291. * so .. 8U232AM's baudrate setting codes are different
  292. * - it has a two byte status code.
  293. * - it returns characters every 16ms (the FTDI does it every 40ms)
  294. *
  295. * the bcdDevice value is used to differentiate FT232BM and FT245BM from
  296. * the earlier FT8U232AM and FT8U232BM. For now, include all known VID/PID
  297. * combinations in both tables.
  298. * FIXME: perhaps bcdDevice can also identify 12MHz FT8U232AM devices,
  299. * but I don't know if those ever went into mass production. [Ian Abbott]
  300. */
  301. static struct usb_device_id id_table_combined [] = {
  302. { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
  303. { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
  304. { USB_DEVICE(FTDI_VID, FTDI_ACTZWAVE_PID) },
  305. { USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
  306. { USB_DEVICE(FTDI_VID, FTDI_IPLUS_PID) },
  307. { USB_DEVICE(FTDI_VID, FTDI_IPLUS2_PID) },
  308. { USB_DEVICE(FTDI_VID, FTDI_DMX4ALL) },
  309. { USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
  310. { USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
  311. { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
  312. { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
  313. { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) },
  314. { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
  315. { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
  316. { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
  317. { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
  318. { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
  319. { USB_DEVICE(FTDI_VID, FTDI_XF_632_PID) },
  320. { USB_DEVICE(FTDI_VID, FTDI_XF_634_PID) },
  321. { USB_DEVICE(FTDI_VID, FTDI_XF_547_PID) },
  322. { USB_DEVICE(FTDI_VID, FTDI_XF_633_PID) },
  323. { USB_DEVICE(FTDI_VID, FTDI_XF_631_PID) },
  324. { USB_DEVICE(FTDI_VID, FTDI_XF_635_PID) },
  325. { USB_DEVICE(FTDI_VID, FTDI_XF_640_PID) },
  326. { USB_DEVICE(FTDI_VID, FTDI_XF_642_PID) },
  327. { USB_DEVICE(FTDI_VID, FTDI_DSS20_PID) },
  328. { USB_DEVICE(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID) },
  329. { USB_DEVICE(FTDI_VID, FTDI_VNHCPCUSB_D_PID) },
  330. { USB_DEVICE(FTDI_VID, FTDI_MTXORB_0_PID) },
  331. { USB_DEVICE(FTDI_VID, FTDI_MTXORB_1_PID) },
  332. { USB_DEVICE(FTDI_VID, FTDI_MTXORB_2_PID) },
  333. { USB_DEVICE(FTDI_VID, FTDI_MTXORB_3_PID) },
  334. { USB_DEVICE(FTDI_VID, FTDI_MTXORB_4_PID) },
  335. { USB_DEVICE(FTDI_VID, FTDI_MTXORB_5_PID) },
  336. { USB_DEVICE(FTDI_VID, FTDI_MTXORB_6_PID) },
  337. { USB_DEVICE(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID) },
  338. { USB_DEVICE(FTDI_VID, FTDI_PIEGROUP_PID) },
  339. { USB_DEVICE(FTDI_VID, FTDI_TNC_X_PID) },
  340. { USB_DEVICE(FTDI_VID, FTDI_USBX_707_PID) },
  341. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2101_PID) },
  342. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2102_PID) },
  343. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2103_PID) },
  344. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2104_PID) },
  345. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2106_PID) },
  346. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_1_PID) },
  347. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_2_PID) },
  348. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_1_PID) },
  349. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_2_PID) },
  350. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_1_PID) },
  351. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_2_PID) },
  352. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_1_PID) },
  353. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_2_PID) },
  354. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_3_PID) },
  355. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_4_PID) },
  356. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_1_PID) },
  357. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_2_PID) },
  358. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_3_PID) },
  359. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_4_PID) },
  360. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_1_PID) },
  361. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_2_PID) },
  362. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_3_PID) },
  363. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_4_PID) },
  364. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_1_PID) },
  365. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_2_PID) },
  366. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_3_PID) },
  367. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_4_PID) },
  368. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_5_PID) },
  369. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_6_PID) },
  370. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_7_PID) },
  371. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_8_PID) },
  372. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_1_PID) },
  373. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_2_PID) },
  374. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_3_PID) },
  375. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_4_PID) },
  376. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_5_PID) },
  377. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_6_PID) },
  378. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_7_PID) },
  379. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_8_PID) },
  380. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_1_PID) },
  381. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_2_PID) },
  382. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_3_PID) },
  383. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_4_PID) },
  384. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_5_PID) },
  385. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_6_PID) },
  386. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_7_PID) },
  387. { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
  388. { USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
  389. { USB_DEVICE(OCT_VID, OCT_US101_PID) },
  390. { USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
  391. .driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
  392. { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
  393. .driver_info = (kernel_ulong_t)&ftdi_USB_UIRT_quirk },
  394. { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
  395. { USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
  396. { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
  397. { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_4) },
  398. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E808_PID) },
  399. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E809_PID) },
  400. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80A_PID) },
  401. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80B_PID) },
  402. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80C_PID) },
  403. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80D_PID) },
  404. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80E_PID) },
  405. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80F_PID) },
  406. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E888_PID) },
  407. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E889_PID) },
  408. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88A_PID) },
  409. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88B_PID) },
  410. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88C_PID) },
  411. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88D_PID) },
  412. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88E_PID) },
  413. { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88F_PID) },
  414. { USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
  415. { USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
  416. { USB_DEVICE(FTDI_VID, FTDI_ELV_UR100_PID) },
  417. { USB_DEVICE(FTDI_VID, FTDI_ELV_ALC8500_PID) },
  418. { USB_DEVICE(FTDI_VID, FTDI_PYRAMID_PID) },
  419. { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) },
  420. { USB_DEVICE(FTDI_VID, FTDI_IBS_US485_PID) },
  421. { USB_DEVICE(FTDI_VID, FTDI_IBS_PICPRO_PID) },
  422. { USB_DEVICE(FTDI_VID, FTDI_IBS_PCMCIA_PID) },
  423. { USB_DEVICE(FTDI_VID, FTDI_IBS_PK1_PID) },
  424. { USB_DEVICE(FTDI_VID, FTDI_IBS_RS232MON_PID) },
  425. { USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
  426. { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
  427. { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
  428. /*
  429. * These will probably use user-space drivers. Uncomment them if
  430. * you need them or use the user-specified vendor/product module
  431. * parameters (see ftdi_sio.h for the numbers). Make a fuss if
  432. * you think the driver should recognize any of them by default.
  433. */
  434. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) }, */
  435. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) }, */
  436. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) }, */
  437. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_UDF77_PID) }, */
  438. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_UIO88_PID) }, */
  439. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_UAD8_PID) }, */
  440. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_UDA7_PID) }, */
  441. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_USI2_PID) }, */
  442. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_T1100_PID) }, */
  443. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_PCD200_PID) }, */
  444. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_ULA200_PID) }, */
  445. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_CSI8_PID) }, */
  446. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1000DL_PID) }, */
  447. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) }, */
  448. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) }, */
  449. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) }, */
  450. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) }, */
  451. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) }, */
  452. /* { USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) }, */
  453. { USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
  454. { USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
  455. { USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
  456. { USB_DEVICE(FTDI_VID, LINX_FUTURE_1_PID) },
  457. { USB_DEVICE(FTDI_VID, LINX_FUTURE_2_PID) },
  458. { USB_DEVICE(FTDI_VID, FTDI_CCSICDU20_0_PID) },
  459. { USB_DEVICE(FTDI_VID, FTDI_CCSICDU40_1_PID) },
  460. { USB_DEVICE(FTDI_VID, FTDI_CCSMACHX_2_PID) },
  461. { USB_DEVICE(FTDI_VID, INSIDE_ACCESSO) },
  462. { USB_DEVICE(INTREPID_VID, INTREPID_VALUECAN_PID) },
  463. { USB_DEVICE(INTREPID_VID, INTREPID_NEOVI_PID) },
  464. { USB_DEVICE(FALCOM_VID, FALCOM_TWIST_PID) },
  465. { USB_DEVICE(FALCOM_VID, FALCOM_SAMBA_PID) },
  466. { USB_DEVICE(FTDI_VID, FTDI_SUUNTO_SPORTS_PID) },
  467. { USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
  468. { USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
  469. { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
  470. { USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
  471. { USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) },
  472. { USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
  473. { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
  474. { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
  475. { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
  476. { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
  477. { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
  478. { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_3_PID) },
  479. { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_4_PID) },
  480. { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_5_PID) },
  481. { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_6_PID) },
  482. { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_7_PID) },
  483. { USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
  484. { USB_DEVICE(FTDI_VID, FTDI_ACTIVE_ROBOTS_PID) },
  485. { USB_DEVICE(FTDI_VID, FTDI_MHAM_KW_PID) },
  486. { USB_DEVICE(FTDI_VID, FTDI_MHAM_YS_PID) },
  487. { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) },
  488. { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) },
  489. { USB_DEVICE(FTDI_VID, FTDI_MHAM_IC_PID) },
  490. { USB_DEVICE(FTDI_VID, FTDI_MHAM_DB9_PID) },
  491. { USB_DEVICE(FTDI_VID, FTDI_MHAM_RS232_PID) },
  492. { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y9_PID) },
  493. { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_VCP_PID) },
  494. { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_D2XX_PID) },
  495. { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
  496. { USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
  497. { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
  498. { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16C_PID) },
  499. { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HR_PID) },
  500. { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HRC_PID) },
  501. { USB_DEVICE(KOBIL_VID, KOBIL_CONV_B1_PID) },
  502. { USB_DEVICE(KOBIL_VID, KOBIL_CONV_KAAN_PID) },
  503. { USB_DEVICE(POSIFLEX_VID, POSIFLEX_PP7000_PID) },
  504. { USB_DEVICE(FTDI_VID, FTDI_TTUSB_PID) },
  505. { USB_DEVICE(FTDI_VID, FTDI_ECLO_COM_1WIRE_PID) },
  506. { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_777_PID) },
  507. { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_8900F_PID) },
  508. { USB_DEVICE(FTDI_VID, FTDI_PCDJ_DAC2_PID) },
  509. { USB_DEVICE(FTDI_VID, FTDI_RRCIRKITS_LOCOBUFFER_PID) },
  510. { USB_DEVICE(FTDI_VID, FTDI_ASK_RDR400_PID) },
  511. { USB_DEVICE(ICOM_ID1_VID, ICOM_ID1_PID) },
  512. { USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
  513. { USB_DEVICE(FTDI_VID, FTDI_ACG_HFDUAL_PID) },
  514. { USB_DEVICE(FTDI_VID, FTDI_YEI_SERVOCENTER31_PID) },
  515. { USB_DEVICE(FTDI_VID, FTDI_THORLABS_PID) },
  516. { USB_DEVICE(TESTO_VID, TESTO_USB_INTERFACE_PID) },
  517. { USB_DEVICE(FTDI_VID, FTDI_GAMMA_SCOUT_PID) },
  518. { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13M_PID) },
  519. { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13S_PID) },
  520. { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13U_PID) },
  521. { USB_DEVICE(ELEKTOR_VID, ELEKTOR_FT323R_PID) },
  522. { USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
  523. { USB_DEVICE(FTDI_VID, FTDI_MAXSTREAM_PID) },
  524. { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_PID),
  525. .driver_info = (kernel_ulong_t)&ftdi_olimex_quirk },
  526. { }, /* Optional parameter entry */
  527. { } /* Terminating entry */
  528. };
  529. MODULE_DEVICE_TABLE (usb, id_table_combined);
  530. static struct usb_driver ftdi_driver = {
  531. .name = "ftdi_sio",
  532. .probe = usb_serial_probe,
  533. .disconnect = usb_serial_disconnect,
  534. .id_table = id_table_combined,
  535. .no_dynamic_id = 1,
  536. };
  537. static const char *ftdi_chip_name[] = {
  538. [SIO] = "SIO", /* the serial part of FT8U100AX */
  539. [FT8U232AM] = "FT8U232AM",
  540. [FT232BM] = "FT232BM",
  541. [FT2232C] = "FT2232C",
  542. [FT232RL] = "FT232RL",
  543. };
  544. /* Constants for read urb and write urb */
  545. #define BUFSZ 512
  546. #define PKTSZ 64
  547. /* rx_flags */
  548. #define THROTTLED 0x01
  549. #define ACTUALLY_THROTTLED 0x02
  550. struct ftdi_private {
  551. ftdi_chip_type_t chip_type;
  552. /* type of the device, either SIO or FT8U232AM */
  553. int baud_base; /* baud base clock for divisor setting */
  554. int custom_divisor; /* custom_divisor kludge, this is for baud_base (different from what goes to the chip!) */
  555. __u16 last_set_data_urb_value ;
  556. /* the last data state set - needed for doing a break */
  557. int write_offset; /* This is the offset in the usb data block to write the serial data -
  558. * it is different between devices
  559. */
  560. int flags; /* some ASYNC_xxxx flags are supported */
  561. unsigned long last_dtr_rts; /* saved modem control outputs */
  562. wait_queue_head_t delta_msr_wait; /* Used for TIOCMIWAIT */
  563. char prev_status, diff_status; /* Used for TIOCMIWAIT */
  564. __u8 rx_flags; /* receive state flags (throttling) */
  565. spinlock_t rx_lock; /* spinlock for receive state */
  566. struct delayed_work rx_work;
  567. struct usb_serial_port *port;
  568. int rx_processed;
  569. unsigned long rx_bytes;
  570. __u16 interface; /* FT2232C port interface (0 for FT232/245) */
  571. int force_baud; /* if non-zero, force the baud rate to this value */
  572. int force_rtscts; /* if non-zero, force RTS-CTS to always be enabled */
  573. spinlock_t tx_lock; /* spinlock for transmit state */
  574. unsigned long tx_bytes;
  575. unsigned long tx_outstanding_bytes;
  576. unsigned long tx_outstanding_urbs;
  577. };
  578. /* Used for TIOCMIWAIT */
  579. #define FTDI_STATUS_B0_MASK (FTDI_RS0_CTS | FTDI_RS0_DSR | FTDI_RS0_RI | FTDI_RS0_RLSD)
  580. #define FTDI_STATUS_B1_MASK (FTDI_RS_BI)
  581. /* End TIOCMIWAIT */
  582. #define FTDI_IMPL_ASYNC_FLAGS = ( ASYNC_SPD_HI | ASYNC_SPD_VHI \
  583. ASYNC_SPD_CUST | ASYNC_SPD_SHI | ASYNC_SPD_WARP )
  584. /* function prototypes for a FTDI serial converter */
  585. static int ftdi_sio_probe (struct usb_serial *serial, const struct usb_device_id *id);
  586. static int ftdi_sio_attach (struct usb_serial *serial);
  587. static void ftdi_shutdown (struct usb_serial *serial);
  588. static int ftdi_sio_port_probe (struct usb_serial_port *port);
  589. static int ftdi_sio_port_remove (struct usb_serial_port *port);
  590. static int ftdi_open (struct usb_serial_port *port, struct file *filp);
  591. static void ftdi_close (struct usb_serial_port *port, struct file *filp);
  592. static int ftdi_write (struct usb_serial_port *port, const unsigned char *buf, int count);
  593. static int ftdi_write_room (struct usb_serial_port *port);
  594. static int ftdi_chars_in_buffer (struct usb_serial_port *port);
  595. static void ftdi_write_bulk_callback (struct urb *urb);
  596. static void ftdi_read_bulk_callback (struct urb *urb);
  597. static void ftdi_process_read (struct work_struct *work);
  598. static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios * old);
  599. static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file);
  600. static int ftdi_tiocmset (struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear);
  601. static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
  602. static void ftdi_break_ctl (struct usb_serial_port *port, int break_state );
  603. static void ftdi_throttle (struct usb_serial_port *port);
  604. static void ftdi_unthrottle (struct usb_serial_port *port);
  605. static unsigned short int ftdi_232am_baud_base_to_divisor (int baud, int base);
  606. static unsigned short int ftdi_232am_baud_to_divisor (int baud);
  607. static __u32 ftdi_232bm_baud_base_to_divisor (int baud, int base);
  608. static __u32 ftdi_232bm_baud_to_divisor (int baud);
  609. static struct usb_serial_driver ftdi_sio_device = {
  610. .driver = {
  611. .owner = THIS_MODULE,
  612. .name = "ftdi_sio",
  613. },
  614. .description = "FTDI USB Serial Device",
  615. .usb_driver = &ftdi_driver ,
  616. .id_table = id_table_combined,
  617. .num_interrupt_in = 0,
  618. .num_bulk_in = 1,
  619. .num_bulk_out = 1,
  620. .num_ports = 1,
  621. .probe = ftdi_sio_probe,
  622. .port_probe = ftdi_sio_port_probe,
  623. .port_remove = ftdi_sio_port_remove,
  624. .open = ftdi_open,
  625. .close = ftdi_close,
  626. .throttle = ftdi_throttle,
  627. .unthrottle = ftdi_unthrottle,
  628. .write = ftdi_write,
  629. .write_room = ftdi_write_room,
  630. .chars_in_buffer = ftdi_chars_in_buffer,
  631. .read_bulk_callback = ftdi_read_bulk_callback,
  632. .write_bulk_callback = ftdi_write_bulk_callback,
  633. .tiocmget = ftdi_tiocmget,
  634. .tiocmset = ftdi_tiocmset,
  635. .ioctl = ftdi_ioctl,
  636. .set_termios = ftdi_set_termios,
  637. .break_ctl = ftdi_break_ctl,
  638. .attach = ftdi_sio_attach,
  639. .shutdown = ftdi_shutdown,
  640. };
  641. #define WDR_TIMEOUT 5000 /* default urb timeout */
  642. #define WDR_SHORT_TIMEOUT 1000 /* shorter urb timeout */
  643. /* High and low are for DTR, RTS etc etc */
  644. #define HIGH 1
  645. #define LOW 0
  646. /* number of outstanding urbs to prevent userspace DoS from happening */
  647. #define URB_UPPER_LIMIT 42
  648. /*
  649. * ***************************************************************************
  650. * Utility functions
  651. * ***************************************************************************
  652. */
  653. static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base)
  654. {
  655. unsigned short int divisor;
  656. int divisor3 = base / 2 / baud; // divisor shifted 3 bits to the left
  657. if ((divisor3 & 0x7) == 7) divisor3 ++; // round x.7/8 up to x+1
  658. divisor = divisor3 >> 3;
  659. divisor3 &= 0x7;
  660. if (divisor3 == 1) divisor |= 0xc000; else // 0.125
  661. if (divisor3 >= 4) divisor |= 0x4000; else // 0.5
  662. if (divisor3 != 0) divisor |= 0x8000; // 0.25
  663. if (divisor == 1) divisor = 0; /* special case for maximum baud rate */
  664. return divisor;
  665. }
  666. static unsigned short int ftdi_232am_baud_to_divisor(int baud)
  667. {
  668. return(ftdi_232am_baud_base_to_divisor(baud, 48000000));
  669. }
  670. static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base)
  671. {
  672. static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
  673. __u32 divisor;
  674. int divisor3 = base / 2 / baud; // divisor shifted 3 bits to the left
  675. divisor = divisor3 >> 3;
  676. divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
  677. /* Deal with special cases for highest baud rates. */
  678. if (divisor == 1) divisor = 0; else // 1.0
  679. if (divisor == 0x4001) divisor = 1; // 1.5
  680. return divisor;
  681. }
  682. static __u32 ftdi_232bm_baud_to_divisor(int baud)
  683. {
  684. return(ftdi_232bm_baud_base_to_divisor(baud, 48000000));
  685. }
  686. #define set_mctrl(port, set) update_mctrl((port), (set), 0)
  687. #define clear_mctrl(port, clear) update_mctrl((port), 0, (clear))
  688. static int update_mctrl(struct usb_serial_port *port, unsigned int set, unsigned int clear)
  689. {
  690. struct ftdi_private *priv = usb_get_serial_port_data(port);
  691. char *buf;
  692. unsigned urb_value;
  693. int rv;
  694. if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
  695. dbg("%s - DTR|RTS not being set|cleared", __FUNCTION__);
  696. return 0; /* no change */
  697. }
  698. buf = kmalloc(1, GFP_NOIO);
  699. if (!buf) {
  700. return -ENOMEM;
  701. }
  702. clear &= ~set; /* 'set' takes precedence over 'clear' */
  703. urb_value = 0;
  704. if (clear & TIOCM_DTR)
  705. urb_value |= FTDI_SIO_SET_DTR_LOW;
  706. if (clear & TIOCM_RTS)
  707. urb_value |= FTDI_SIO_SET_RTS_LOW;
  708. if (set & TIOCM_DTR)
  709. urb_value |= FTDI_SIO_SET_DTR_HIGH;
  710. if (set & TIOCM_RTS)
  711. urb_value |= FTDI_SIO_SET_RTS_HIGH;
  712. rv = usb_control_msg(port->serial->dev,
  713. usb_sndctrlpipe(port->serial->dev, 0),
  714. FTDI_SIO_SET_MODEM_CTRL_REQUEST,
  715. FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
  716. urb_value, priv->interface,
  717. buf, 0, WDR_TIMEOUT);
  718. kfree(buf);
  719. if (rv < 0) {
  720. err("%s Error from MODEM_CTRL urb: DTR %s, RTS %s",
  721. __FUNCTION__,
  722. (set & TIOCM_DTR) ? "HIGH" :
  723. (clear & TIOCM_DTR) ? "LOW" : "unchanged",
  724. (set & TIOCM_RTS) ? "HIGH" :
  725. (clear & TIOCM_RTS) ? "LOW" : "unchanged");
  726. } else {
  727. dbg("%s - DTR %s, RTS %s", __FUNCTION__,
  728. (set & TIOCM_DTR) ? "HIGH" :
  729. (clear & TIOCM_DTR) ? "LOW" : "unchanged",
  730. (set & TIOCM_RTS) ? "HIGH" :
  731. (clear & TIOCM_RTS) ? "LOW" : "unchanged");
  732. priv->last_dtr_rts = (priv->last_dtr_rts & ~clear) | set;
  733. }
  734. return rv;
  735. }
  736. static __u32 get_ftdi_divisor(struct usb_serial_port * port);
  737. static int change_speed(struct usb_serial_port *port)
  738. {
  739. struct ftdi_private *priv = usb_get_serial_port_data(port);
  740. char *buf;
  741. __u16 urb_value;
  742. __u16 urb_index;
  743. __u32 urb_index_value;
  744. int rv;
  745. buf = kmalloc(1, GFP_NOIO);
  746. if (!buf)
  747. return -ENOMEM;
  748. urb_index_value = get_ftdi_divisor(port);
  749. urb_value = (__u16)urb_index_value;
  750. urb_index = (__u16)(urb_index_value >> 16);
  751. if (priv->interface) { /* FT2232C */
  752. urb_index = (__u16)((urb_index << 8) | priv->interface);
  753. }
  754. rv = usb_control_msg(port->serial->dev,
  755. usb_sndctrlpipe(port->serial->dev, 0),
  756. FTDI_SIO_SET_BAUDRATE_REQUEST,
  757. FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
  758. urb_value, urb_index,
  759. buf, 0, WDR_SHORT_TIMEOUT);
  760. kfree(buf);
  761. return rv;
  762. }
  763. static __u32 get_ftdi_divisor(struct usb_serial_port * port)
  764. { /* get_ftdi_divisor */
  765. struct ftdi_private *priv = usb_get_serial_port_data(port);
  766. __u32 div_value = 0;
  767. int div_okay = 1;
  768. int baud;
  769. /*
  770. * The logic involved in setting the baudrate can be cleanly split in 3 steps.
  771. * Obtaining the actual baud rate is a little tricky since unix traditionally
  772. * somehow ignored the possibility to set non-standard baud rates.
  773. * 1. Standard baud rates are set in tty->termios->c_cflag
  774. * 2. If these are not enough, you can set any speed using alt_speed as follows:
  775. * - set tty->termios->c_cflag speed to B38400
  776. * - set your real speed in tty->alt_speed; it gets ignored when
  777. * alt_speed==0, (or)
  778. * - call TIOCSSERIAL ioctl with (struct serial_struct) set as follows:
  779. * flags & ASYNC_SPD_MASK == ASYNC_SPD_[HI, VHI, SHI, WARP], this just
  780. * sets alt_speed to (HI: 57600, VHI: 115200, SHI: 230400, WARP: 460800)
  781. * ** Steps 1, 2 are done courtesy of tty_get_baud_rate
  782. * 3. You can also set baud rate by setting custom divisor as follows
  783. * - set tty->termios->c_cflag speed to B38400
  784. * - call TIOCSSERIAL ioctl with (struct serial_struct) set as follows:
  785. * o flags & ASYNC_SPD_MASK == ASYNC_SPD_CUST
  786. * o custom_divisor set to baud_base / your_new_baudrate
  787. * ** Step 3 is done courtesy of code borrowed from serial.c - I should really
  788. * spend some time and separate+move this common code to serial.c, it is
  789. * replicated in nearly every serial driver you see.
  790. */
  791. /* 1. Get the baud rate from the tty settings, this observes alt_speed hack */
  792. baud = tty_get_baud_rate(port->tty);
  793. dbg("%s - tty_get_baud_rate reports speed %d", __FUNCTION__, baud);
  794. /* 2. Observe async-compatible custom_divisor hack, update baudrate if needed */
  795. if (baud == 38400 &&
  796. ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
  797. (priv->custom_divisor)) {
  798. baud = priv->baud_base / priv->custom_divisor;
  799. dbg("%s - custom divisor %d sets baud rate to %d", __FUNCTION__, priv->custom_divisor, baud);
  800. }
  801. /* 3. Convert baudrate to device-specific divisor */
  802. if (!baud) baud = 9600;
  803. switch(priv->chip_type) {
  804. case SIO: /* SIO chip */
  805. switch(baud) {
  806. case 300: div_value = ftdi_sio_b300; break;
  807. case 600: div_value = ftdi_sio_b600; break;
  808. case 1200: div_value = ftdi_sio_b1200; break;
  809. case 2400: div_value = ftdi_sio_b2400; break;
  810. case 4800: div_value = ftdi_sio_b4800; break;
  811. case 9600: div_value = ftdi_sio_b9600; break;
  812. case 19200: div_value = ftdi_sio_b19200; break;
  813. case 38400: div_value = ftdi_sio_b38400; break;
  814. case 57600: div_value = ftdi_sio_b57600; break;
  815. case 115200: div_value = ftdi_sio_b115200; break;
  816. } /* baud */
  817. if (div_value == 0) {
  818. dbg("%s - Baudrate (%d) requested is not supported", __FUNCTION__, baud);
  819. div_value = ftdi_sio_b9600;
  820. div_okay = 0;
  821. }
  822. break;
  823. case FT8U232AM: /* 8U232AM chip */
  824. if (baud <= 3000000) {
  825. div_value = ftdi_232am_baud_to_divisor(baud);
  826. } else {
  827. dbg("%s - Baud rate too high!", __FUNCTION__);
  828. div_value = ftdi_232am_baud_to_divisor(9600);
  829. div_okay = 0;
  830. }
  831. break;
  832. case FT232BM: /* FT232BM chip */
  833. case FT2232C: /* FT2232C chip */
  834. case FT232RL:
  835. if (baud <= 3000000) {
  836. div_value = ftdi_232bm_baud_to_divisor(baud);
  837. } else {
  838. dbg("%s - Baud rate too high!", __FUNCTION__);
  839. div_value = ftdi_232bm_baud_to_divisor(9600);
  840. div_okay = 0;
  841. }
  842. break;
  843. } /* priv->chip_type */
  844. if (div_okay) {
  845. dbg("%s - Baud rate set to %d (divisor 0x%lX) on chip %s",
  846. __FUNCTION__, baud, (unsigned long)div_value,
  847. ftdi_chip_name[priv->chip_type]);
  848. }
  849. return(div_value);
  850. }
  851. static int get_serial_info(struct usb_serial_port * port, struct serial_struct __user * retinfo)
  852. {
  853. struct ftdi_private *priv = usb_get_serial_port_data(port);
  854. struct serial_struct tmp;
  855. if (!retinfo)
  856. return -EFAULT;
  857. memset(&tmp, 0, sizeof(tmp));
  858. tmp.flags = priv->flags;
  859. tmp.baud_base = priv->baud_base;
  860. tmp.custom_divisor = priv->custom_divisor;
  861. if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
  862. return -EFAULT;
  863. return 0;
  864. } /* get_serial_info */
  865. static int set_serial_info(struct usb_serial_port * port, struct serial_struct __user * newinfo)
  866. { /* set_serial_info */
  867. struct ftdi_private *priv = usb_get_serial_port_data(port);
  868. struct serial_struct new_serial;
  869. struct ftdi_private old_priv;
  870. if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
  871. return -EFAULT;
  872. old_priv = * priv;
  873. /* Do error checking and permission checking */
  874. if (!capable(CAP_SYS_ADMIN)) {
  875. if (((new_serial.flags & ~ASYNC_USR_MASK) !=
  876. (priv->flags & ~ASYNC_USR_MASK)))
  877. return -EPERM;
  878. priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |
  879. (new_serial.flags & ASYNC_USR_MASK));
  880. priv->custom_divisor = new_serial.custom_divisor;
  881. goto check_and_exit;
  882. }
  883. if ((new_serial.baud_base != priv->baud_base) &&
  884. (new_serial.baud_base < 9600))
  885. return -EINVAL;
  886. /* Make the changes - these are privileged changes! */
  887. priv->flags = ((priv->flags & ~ASYNC_FLAGS) |
  888. (new_serial.flags & ASYNC_FLAGS));
  889. priv->custom_divisor = new_serial.custom_divisor;
  890. port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
  891. check_and_exit:
  892. if ((old_priv.flags & ASYNC_SPD_MASK) !=
  893. (priv->flags & ASYNC_SPD_MASK)) {
  894. if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
  895. port->tty->alt_speed = 57600;
  896. else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
  897. port->tty->alt_speed = 115200;
  898. else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
  899. port->tty->alt_speed = 230400;
  900. else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
  901. port->tty->alt_speed = 460800;
  902. else
  903. port->tty->alt_speed = 0;
  904. }
  905. if (((old_priv.flags & ASYNC_SPD_MASK) !=
  906. (priv->flags & ASYNC_SPD_MASK)) ||
  907. (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
  908. (old_priv.custom_divisor != priv->custom_divisor))) {
  909. change_speed(port);
  910. }
  911. return (0);
  912. } /* set_serial_info */
  913. /* Determine type of FTDI chip based on USB config and descriptor. */
  914. static void ftdi_determine_type(struct usb_serial_port *port)
  915. {
  916. struct ftdi_private *priv = usb_get_serial_port_data(port);
  917. struct usb_serial *serial = port->serial;
  918. struct usb_device *udev = serial->dev;
  919. unsigned version;
  920. unsigned interfaces;
  921. /* Assume it is not the original SIO device for now. */
  922. priv->baud_base = 48000000 / 2;
  923. priv->write_offset = 0;
  924. version = le16_to_cpu(udev->descriptor.bcdDevice);
  925. interfaces = udev->actconfig->desc.bNumInterfaces;
  926. dbg("%s: bcdDevice = 0x%x, bNumInterfaces = %u", __FUNCTION__,
  927. version, interfaces);
  928. if (interfaces > 1) {
  929. int inter;
  930. /* Multiple interfaces. Assume FT2232C. */
  931. priv->chip_type = FT2232C;
  932. /* Determine interface code. */
  933. inter = serial->interface->altsetting->desc.bInterfaceNumber;
  934. if (inter == 0) {
  935. priv->interface = PIT_SIOA;
  936. } else {
  937. priv->interface = PIT_SIOB;
  938. }
  939. /* BM-type devices have a bug where bcdDevice gets set
  940. * to 0x200 when iSerialNumber is 0. */
  941. if (version < 0x500) {
  942. dbg("%s: something fishy - bcdDevice too low for multi-interface device",
  943. __FUNCTION__);
  944. }
  945. } else if (version < 0x200) {
  946. /* Old device. Assume its the original SIO. */
  947. priv->chip_type = SIO;
  948. priv->baud_base = 12000000 / 16;
  949. priv->write_offset = 1;
  950. } else if (version < 0x400) {
  951. /* Assume its an FT8U232AM (or FT8U245AM) */
  952. /* (It might be a BM because of the iSerialNumber bug,
  953. * but it will still work as an AM device.) */
  954. priv->chip_type = FT8U232AM;
  955. } else if (version < 0x600) {
  956. /* Assume its an FT232BM (or FT245BM) */
  957. priv->chip_type = FT232BM;
  958. } else {
  959. /* Assume its an FT232R */
  960. priv->chip_type = FT232RL;
  961. }
  962. info("Detected %s", ftdi_chip_name[priv->chip_type]);
  963. }
  964. /*
  965. * ***************************************************************************
  966. * Sysfs Attribute
  967. * ***************************************************************************
  968. */
  969. static ssize_t show_latency_timer(struct device *dev, struct device_attribute *attr, char *buf)
  970. {
  971. struct usb_serial_port *port = to_usb_serial_port(dev);
  972. struct ftdi_private *priv = usb_get_serial_port_data(port);
  973. struct usb_device *udev = port->serial->dev;
  974. unsigned short latency = 0;
  975. int rv = 0;
  976. dbg("%s",__FUNCTION__);
  977. rv = usb_control_msg(udev,
  978. usb_rcvctrlpipe(udev, 0),
  979. FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
  980. FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
  981. 0, priv->interface,
  982. (char*) &latency, 1, WDR_TIMEOUT);
  983. if (rv < 0) {
  984. dev_err(dev, "Unable to read latency timer: %i", rv);
  985. return -EIO;
  986. }
  987. return sprintf(buf, "%i\n", latency);
  988. }
  989. /* Write a new value of the latency timer, in units of milliseconds. */
  990. static ssize_t store_latency_timer(struct device *dev, struct device_attribute *attr, const char *valbuf,
  991. size_t count)
  992. {
  993. struct usb_serial_port *port = to_usb_serial_port(dev);
  994. struct ftdi_private *priv = usb_get_serial_port_data(port);
  995. struct usb_device *udev = port->serial->dev;
  996. char buf[1];
  997. int v = simple_strtoul(valbuf, NULL, 10);
  998. int rv = 0;
  999. dbg("%s: setting latency timer = %i", __FUNCTION__, v);
  1000. rv = usb_control_msg(udev,
  1001. usb_sndctrlpipe(udev, 0),
  1002. FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
  1003. FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
  1004. v, priv->interface,
  1005. buf, 0, WDR_TIMEOUT);
  1006. if (rv < 0) {
  1007. dev_err(dev, "Unable to write latency timer: %i", rv);
  1008. return -EIO;
  1009. }
  1010. return count;
  1011. }
  1012. /* Write an event character directly to the FTDI register. The ASCII
  1013. value is in the low 8 bits, with the enable bit in the 9th bit. */
  1014. static ssize_t store_event_char(struct device *dev, struct device_attribute *attr, const char *valbuf,
  1015. size_t count)
  1016. {
  1017. struct usb_serial_port *port = to_usb_serial_port(dev);
  1018. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1019. struct usb_device *udev = port->serial->dev;
  1020. char buf[1];
  1021. int v = simple_strtoul(valbuf, NULL, 10);
  1022. int rv = 0;
  1023. dbg("%s: setting event char = %i", __FUNCTION__, v);
  1024. rv = usb_control_msg(udev,
  1025. usb_sndctrlpipe(udev, 0),
  1026. FTDI_SIO_SET_EVENT_CHAR_REQUEST,
  1027. FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE,
  1028. v, priv->interface,
  1029. buf, 0, WDR_TIMEOUT);
  1030. if (rv < 0) {
  1031. dbg("Unable to write event character: %i", rv);
  1032. return -EIO;
  1033. }
  1034. return count;
  1035. }
  1036. static DEVICE_ATTR(latency_timer, S_IWUSR | S_IRUGO, show_latency_timer, store_latency_timer);
  1037. static DEVICE_ATTR(event_char, S_IWUSR, NULL, store_event_char);
  1038. static int create_sysfs_attrs(struct usb_serial_port *port)
  1039. {
  1040. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1041. int retval = 0;
  1042. dbg("%s",__FUNCTION__);
  1043. /* XXX I've no idea if the original SIO supports the event_char
  1044. * sysfs parameter, so I'm playing it safe. */
  1045. if (priv->chip_type != SIO) {
  1046. dbg("sysfs attributes for %s", ftdi_chip_name[priv->chip_type]);
  1047. retval = device_create_file(&port->dev, &dev_attr_event_char);
  1048. if ((!retval) &&
  1049. (priv->chip_type == FT232BM ||
  1050. priv->chip_type == FT2232C ||
  1051. priv->chip_type == FT232RL)) {
  1052. retval = device_create_file(&port->dev,
  1053. &dev_attr_latency_timer);
  1054. }
  1055. }
  1056. return retval;
  1057. }
  1058. static void remove_sysfs_attrs(struct usb_serial_port *port)
  1059. {
  1060. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1061. dbg("%s",__FUNCTION__);
  1062. /* XXX see create_sysfs_attrs */
  1063. if (priv->chip_type != SIO) {
  1064. device_remove_file(&port->dev, &dev_attr_event_char);
  1065. if (priv->chip_type == FT232BM || priv->chip_type == FT2232C) {
  1066. device_remove_file(&port->dev, &dev_attr_latency_timer);
  1067. }
  1068. }
  1069. }
  1070. /*
  1071. * ***************************************************************************
  1072. * FTDI driver specific functions
  1073. * ***************************************************************************
  1074. */
  1075. /* Probe function to check for special devices */
  1076. static int ftdi_sio_probe (struct usb_serial *serial, const struct usb_device_id *id)
  1077. {
  1078. struct ftdi_sio_quirk *quirk = (struct ftdi_sio_quirk *)id->driver_info;
  1079. if (quirk && quirk->probe) {
  1080. int ret = quirk->probe(serial);
  1081. if (ret != 0)
  1082. return ret;
  1083. }
  1084. usb_set_serial_data(serial, (void *)id->driver_info);
  1085. return 0;
  1086. }
  1087. static int ftdi_sio_port_probe(struct usb_serial_port *port)
  1088. {
  1089. struct ftdi_private *priv;
  1090. dbg("%s",__FUNCTION__);
  1091. priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
  1092. if (!priv){
  1093. err("%s- kmalloc(%Zd) failed.", __FUNCTION__, sizeof(struct ftdi_private));
  1094. return -ENOMEM;
  1095. }
  1096. spin_lock_init(&priv->rx_lock);
  1097. spin_lock_init(&priv->tx_lock);
  1098. init_waitqueue_head(&priv->delta_msr_wait);
  1099. /* This will push the characters through immediately rather
  1100. than queue a task to deliver them */
  1101. priv->flags = ASYNC_LOW_LATENCY;
  1102. /* Increase the size of read buffers */
  1103. kfree(port->bulk_in_buffer);
  1104. port->bulk_in_buffer = kmalloc (BUFSZ, GFP_KERNEL);
  1105. if (!port->bulk_in_buffer) {
  1106. kfree (priv);
  1107. return -ENOMEM;
  1108. }
  1109. if (port->read_urb) {
  1110. port->read_urb->transfer_buffer = port->bulk_in_buffer;
  1111. port->read_urb->transfer_buffer_length = BUFSZ;
  1112. }
  1113. INIT_DELAYED_WORK(&priv->rx_work, ftdi_process_read);
  1114. priv->port = port;
  1115. /* Free port's existing write urb and transfer buffer. */
  1116. if (port->write_urb) {
  1117. usb_free_urb (port->write_urb);
  1118. port->write_urb = NULL;
  1119. }
  1120. kfree(port->bulk_out_buffer);
  1121. port->bulk_out_buffer = NULL;
  1122. usb_set_serial_port_data(port, priv);
  1123. ftdi_determine_type (port);
  1124. create_sysfs_attrs(port);
  1125. return 0;
  1126. }
  1127. /* attach subroutine */
  1128. static int ftdi_sio_attach (struct usb_serial *serial)
  1129. {
  1130. /* Check for device requiring special set up. */
  1131. struct ftdi_sio_quirk *quirk = usb_get_serial_data(serial);
  1132. if (quirk && quirk->setup)
  1133. quirk->setup(serial);
  1134. return 0;
  1135. } /* ftdi_sio_attach */
  1136. /* Setup for the USB-UIRT device, which requires hardwired
  1137. * baudrate (38400 gets mapped to 312500) */
  1138. /* Called from usbserial:serial_probe */
  1139. static void ftdi_USB_UIRT_setup (struct usb_serial *serial)
  1140. {
  1141. struct ftdi_private *priv;
  1142. dbg("%s",__FUNCTION__);
  1143. priv = usb_get_serial_port_data(serial->port[0]);
  1144. priv->flags |= ASYNC_SPD_CUST;
  1145. priv->custom_divisor = 77;
  1146. priv->force_baud = B38400;
  1147. } /* ftdi_USB_UIRT_setup */
  1148. /* Setup for the HE-TIRA1 device, which requires hardwired
  1149. * baudrate (38400 gets mapped to 100000) and RTS-CTS enabled. */
  1150. static void ftdi_HE_TIRA1_setup (struct usb_serial *serial)
  1151. {
  1152. struct ftdi_private *priv;
  1153. dbg("%s",__FUNCTION__);
  1154. priv = usb_get_serial_port_data(serial->port[0]);
  1155. priv->flags |= ASYNC_SPD_CUST;
  1156. priv->custom_divisor = 240;
  1157. priv->force_baud = B38400;
  1158. priv->force_rtscts = 1;
  1159. } /* ftdi_HE_TIRA1_setup */
  1160. /*
  1161. * First port on Olimex arm-usb-ocd is reserved for JTAG interface
  1162. * and can be accessed from userspace using openocd.
  1163. */
  1164. static int ftdi_olimex_probe(struct usb_serial *serial)
  1165. {
  1166. struct usb_device *udev = serial->dev;
  1167. struct usb_interface *interface = serial->interface;
  1168. dbg("%s",__FUNCTION__);
  1169. if (interface == udev->actconfig->interface[0]) {
  1170. info("Ignoring reserved serial port on Olimex arm-usb-ocd\n");
  1171. return -ENODEV;
  1172. }
  1173. return 0;
  1174. }
  1175. /* ftdi_shutdown is called from usbserial:usb_serial_disconnect
  1176. * it is called when the usb device is disconnected
  1177. *
  1178. * usbserial:usb_serial_disconnect
  1179. * calls __serial_close for each open of the port
  1180. * shutdown is called then (ie ftdi_shutdown)
  1181. */
  1182. static void ftdi_shutdown (struct usb_serial *serial)
  1183. {
  1184. dbg("%s", __FUNCTION__);
  1185. }
  1186. static int ftdi_sio_port_remove(struct usb_serial_port *port)
  1187. {
  1188. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1189. dbg("%s", __FUNCTION__);
  1190. remove_sysfs_attrs(port);
  1191. /* all open ports are closed at this point
  1192. * (by usbserial.c:__serial_close, which calls ftdi_close)
  1193. */
  1194. if (priv) {
  1195. usb_set_serial_port_data(port, NULL);
  1196. kfree(priv);
  1197. }
  1198. return 0;
  1199. }
  1200. static int ftdi_open (struct usb_serial_port *port, struct file *filp)
  1201. { /* ftdi_open */
  1202. struct usb_device *dev = port->serial->dev;
  1203. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1204. unsigned long flags;
  1205. int result = 0;
  1206. char buf[1]; /* Needed for the usb_control_msg I think */
  1207. dbg("%s", __FUNCTION__);
  1208. spin_lock_irqsave(&priv->tx_lock, flags);
  1209. priv->tx_bytes = 0;
  1210. spin_unlock_irqrestore(&priv->tx_lock, flags);
  1211. spin_lock_irqsave(&priv->rx_lock, flags);
  1212. priv->rx_bytes = 0;
  1213. spin_unlock_irqrestore(&priv->rx_lock, flags);
  1214. if (port->tty)
  1215. port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
  1216. /* No error checking for this (will get errors later anyway) */
  1217. /* See ftdi_sio.h for description of what is reset */
  1218. usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  1219. FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
  1220. FTDI_SIO_RESET_SIO,
  1221. priv->interface, buf, 0, WDR_TIMEOUT);
  1222. /* Termios defaults are set by usb_serial_init. We don't change
  1223. port->tty->termios - this would loose speed settings, etc.
  1224. This is same behaviour as serial.c/rs_open() - Kuba */
  1225. /* ftdi_set_termios will send usb control messages */
  1226. if (port->tty)
  1227. ftdi_set_termios(port, NULL);
  1228. /* FIXME: Flow control might be enabled, so it should be checked -
  1229. we have no control of defaults! */
  1230. /* Turn on RTS and DTR since we are not flow controlling by default */
  1231. set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
  1232. /* Not throttled */
  1233. spin_lock_irqsave(&priv->rx_lock, flags);
  1234. priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
  1235. spin_unlock_irqrestore(&priv->rx_lock, flags);
  1236. /* Start reading from the device */
  1237. priv->rx_processed = 0;
  1238. usb_fill_bulk_urb(port->read_urb, dev,
  1239. usb_rcvbulkpipe(dev, port->bulk_in_endpointAddress),
  1240. port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
  1241. ftdi_read_bulk_callback, port);
  1242. result = usb_submit_urb(port->read_urb, GFP_KERNEL);
  1243. if (result)
  1244. err("%s - failed submitting read urb, error %d", __FUNCTION__, result);
  1245. return result;
  1246. } /* ftdi_open */
  1247. /*
  1248. * usbserial:__serial_close only calls ftdi_close if the point is open
  1249. *
  1250. * This only gets called when it is the last close
  1251. *
  1252. *
  1253. */
  1254. static void ftdi_close (struct usb_serial_port *port, struct file *filp)
  1255. { /* ftdi_close */
  1256. unsigned int c_cflag = port->tty->termios->c_cflag;
  1257. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1258. char buf[1];
  1259. dbg("%s", __FUNCTION__);
  1260. if (c_cflag & HUPCL){
  1261. /* Disable flow control */
  1262. if (usb_control_msg(port->serial->dev,
  1263. usb_sndctrlpipe(port->serial->dev, 0),
  1264. FTDI_SIO_SET_FLOW_CTRL_REQUEST,
  1265. FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
  1266. 0, priv->interface, buf, 0,
  1267. WDR_TIMEOUT) < 0) {
  1268. err("error from flowcontrol urb");
  1269. }
  1270. /* drop RTS and DTR */
  1271. clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
  1272. } /* Note change no line if hupcl is off */
  1273. /* cancel any scheduled reading */
  1274. cancel_delayed_work(&priv->rx_work);
  1275. flush_scheduled_work();
  1276. /* shutdown our bulk read */
  1277. usb_kill_urb(port->read_urb);
  1278. } /* ftdi_close */
  1279. /* The SIO requires the first byte to have:
  1280. * B0 1
  1281. * B1 0
  1282. * B2..7 length of message excluding byte 0
  1283. *
  1284. * The new devices do not require this byte
  1285. */
  1286. static int ftdi_write (struct usb_serial_port *port,
  1287. const unsigned char *buf, int count)
  1288. { /* ftdi_write */
  1289. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1290. struct urb *urb;
  1291. unsigned char *buffer;
  1292. int data_offset ; /* will be 1 for the SIO and 0 otherwise */
  1293. int status;
  1294. int transfer_size;
  1295. unsigned long flags;
  1296. dbg("%s port %d, %d bytes", __FUNCTION__, port->number, count);
  1297. if (count == 0) {
  1298. dbg("write request of 0 bytes");
  1299. return 0;
  1300. }
  1301. spin_lock_irqsave(&priv->tx_lock, flags);
  1302. if (priv->tx_outstanding_urbs > URB_UPPER_LIMIT) {
  1303. spin_unlock_irqrestore(&priv->tx_lock, flags);
  1304. dbg("%s - write limit hit\n", __FUNCTION__);
  1305. return 0;
  1306. }
  1307. priv->tx_outstanding_urbs++;
  1308. spin_unlock_irqrestore(&priv->tx_lock, flags);
  1309. data_offset = priv->write_offset;
  1310. dbg("data_offset set to %d",data_offset);
  1311. /* Determine total transfer size */
  1312. transfer_size = count;
  1313. if (data_offset > 0) {
  1314. /* Original sio needs control bytes too... */
  1315. transfer_size += (data_offset *
  1316. ((count + (PKTSZ - 1 - data_offset)) /
  1317. (PKTSZ - data_offset)));
  1318. }
  1319. buffer = kmalloc (transfer_size, GFP_ATOMIC);
  1320. if (!buffer) {
  1321. err("%s ran out of kernel memory for urb ...", __FUNCTION__);
  1322. count = -ENOMEM;
  1323. goto error_no_buffer;
  1324. }
  1325. urb = usb_alloc_urb(0, GFP_ATOMIC);
  1326. if (!urb) {
  1327. err("%s - no more free urbs", __FUNCTION__);
  1328. count = -ENOMEM;
  1329. goto error_no_urb;
  1330. }
  1331. /* Copy data */
  1332. if (data_offset > 0) {
  1333. /* Original sio requires control byte at start of each packet. */
  1334. int user_pktsz = PKTSZ - data_offset;
  1335. int todo = count;
  1336. unsigned char *first_byte = buffer;
  1337. const unsigned char *current_position = buf;
  1338. while (todo > 0) {
  1339. if (user_pktsz > todo) {
  1340. user_pktsz = todo;
  1341. }
  1342. /* Write the control byte at the front of the packet*/
  1343. *first_byte = 1 | ((user_pktsz) << 2);
  1344. /* Copy data for packet */
  1345. memcpy (first_byte + data_offset,
  1346. current_position, user_pktsz);
  1347. first_byte += user_pktsz + data_offset;
  1348. current_position += user_pktsz;
  1349. todo -= user_pktsz;
  1350. }
  1351. } else {
  1352. /* No control byte required. */
  1353. /* Copy in the data to send */
  1354. memcpy (buffer, buf, count);
  1355. }
  1356. usb_serial_debug_data(debug, &port->dev, __FUNCTION__, transfer_size, buffer);
  1357. /* fill the buffer and send it */
  1358. usb_fill_bulk_urb(urb, port->serial->dev,
  1359. usb_sndbulkpipe(port->serial->dev, port->bulk_out_endpointAddress),
  1360. buffer, transfer_size,
  1361. ftdi_write_bulk_callback, port);
  1362. status = usb_submit_urb(urb, GFP_ATOMIC);
  1363. if (status) {
  1364. err("%s - failed submitting write urb, error %d", __FUNCTION__, status);
  1365. count = status;
  1366. goto error;
  1367. } else {
  1368. spin_lock_irqsave(&priv->tx_lock, flags);
  1369. priv->tx_outstanding_bytes += count;
  1370. priv->tx_bytes += count;
  1371. spin_unlock_irqrestore(&priv->tx_lock, flags);
  1372. }
  1373. /* we are done with this urb, so let the host driver
  1374. * really free it when it is finished with it */
  1375. usb_free_urb(urb);
  1376. dbg("%s write returning: %d", __FUNCTION__, count);
  1377. return count;
  1378. error:
  1379. usb_free_urb(urb);
  1380. error_no_urb:
  1381. kfree (buffer);
  1382. error_no_buffer:
  1383. spin_lock_irqsave(&priv->tx_lock, flags);
  1384. priv->tx_outstanding_urbs--;
  1385. spin_unlock_irqrestore(&priv->tx_lock, flags);
  1386. return count;
  1387. } /* ftdi_write */
  1388. /* This function may get called when the device is closed */
  1389. static void ftdi_write_bulk_callback (struct urb *urb)
  1390. {
  1391. unsigned long flags;
  1392. struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
  1393. struct ftdi_private *priv;
  1394. int data_offset; /* will be 1 for the SIO and 0 otherwise */
  1395. unsigned long countback;
  1396. int status = urb->status;
  1397. /* free up the transfer buffer, as usb_free_urb() does not do this */
  1398. kfree (urb->transfer_buffer);
  1399. dbg("%s - port %d", __FUNCTION__, port->number);
  1400. if (status) {
  1401. dbg("nonzero write bulk status received: %d", status);
  1402. return;
  1403. }
  1404. priv = usb_get_serial_port_data(port);
  1405. if (!priv) {
  1406. dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
  1407. return;
  1408. }
  1409. /* account for transferred data */
  1410. countback = urb->actual_length;
  1411. data_offset = priv->write_offset;
  1412. if (data_offset > 0) {
  1413. /* Subtract the control bytes */
  1414. countback -= (data_offset * ((countback + (PKTSZ - 1)) / PKTSZ));
  1415. }
  1416. spin_lock_irqsave(&priv->tx_lock, flags);
  1417. --priv->tx_outstanding_urbs;
  1418. priv->tx_outstanding_bytes -= countback;
  1419. spin_unlock_irqrestore(&priv->tx_lock, flags);
  1420. usb_serial_port_softint(port);
  1421. } /* ftdi_write_bulk_callback */
  1422. static int ftdi_write_room( struct usb_serial_port *port )
  1423. {
  1424. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1425. int room;
  1426. unsigned long flags;
  1427. dbg("%s - port %d", __FUNCTION__, port->number);
  1428. spin_lock_irqsave(&priv->tx_lock, flags);
  1429. if (priv->tx_outstanding_urbs < URB_UPPER_LIMIT) {
  1430. /*
  1431. * We really can take anything the user throws at us
  1432. * but let's pick a nice big number to tell the tty
  1433. * layer that we have lots of free space
  1434. */
  1435. room = 2048;
  1436. } else {
  1437. room = 0;
  1438. }
  1439. spin_unlock_irqrestore(&priv->tx_lock, flags);
  1440. return room;
  1441. } /* ftdi_write_room */
  1442. static int ftdi_chars_in_buffer (struct usb_serial_port *port)
  1443. { /* ftdi_chars_in_buffer */
  1444. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1445. int buffered;
  1446. unsigned long flags;
  1447. dbg("%s - port %d", __FUNCTION__, port->number);
  1448. spin_lock_irqsave(&priv->tx_lock, flags);
  1449. buffered = (int)priv->tx_outstanding_bytes;
  1450. spin_unlock_irqrestore(&priv->tx_lock, flags);
  1451. if (buffered < 0) {
  1452. err("%s outstanding tx bytes is negative!", __FUNCTION__);
  1453. buffered = 0;
  1454. }
  1455. return buffered;
  1456. } /* ftdi_chars_in_buffer */
  1457. static void ftdi_read_bulk_callback (struct urb *urb)
  1458. { /* ftdi_read_bulk_callback */
  1459. struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
  1460. struct tty_struct *tty;
  1461. struct ftdi_private *priv;
  1462. unsigned long countread;
  1463. unsigned long flags;
  1464. int status = urb->status;
  1465. if (urb->number_of_packets > 0) {
  1466. err("%s transfer_buffer_length %d actual_length %d number of packets %d",__FUNCTION__,
  1467. urb->transfer_buffer_length, urb->actual_length, urb->number_of_packets );
  1468. err("%s transfer_flags %x ", __FUNCTION__,urb->transfer_flags );
  1469. }
  1470. dbg("%s - port %d", __FUNCTION__, port->number);
  1471. if (port->open_count <= 0)
  1472. return;
  1473. tty = port->tty;
  1474. if (!tty) {
  1475. dbg("%s - bad tty pointer - exiting",__FUNCTION__);
  1476. return;
  1477. }
  1478. priv = usb_get_serial_port_data(port);
  1479. if (!priv) {
  1480. dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
  1481. return;
  1482. }
  1483. if (urb != port->read_urb) {
  1484. err("%s - Not my urb!", __FUNCTION__);
  1485. }
  1486. if (status) {
  1487. /* This will happen at close every time so it is a dbg not an err */
  1488. dbg("(this is ok on close) nonzero read bulk status received: "
  1489. "%d", status);
  1490. return;
  1491. }
  1492. /* count data bytes, but not status bytes */
  1493. countread = urb->actual_length;
  1494. countread -= 2 * ((countread + (PKTSZ - 1)) / PKTSZ);
  1495. spin_lock_irqsave(&priv->rx_lock, flags);
  1496. priv->rx_bytes += countread;
  1497. spin_unlock_irqrestore(&priv->rx_lock, flags);
  1498. ftdi_process_read(&priv->rx_work.work);
  1499. } /* ftdi_read_bulk_callback */
  1500. static void ftdi_process_read (struct work_struct *work)
  1501. { /* ftdi_process_read */
  1502. struct ftdi_private *priv =
  1503. container_of(work, struct ftdi_private, rx_work.work);
  1504. struct usb_serial_port *port = priv->port;
  1505. struct urb *urb;
  1506. struct tty_struct *tty;
  1507. char error_flag;
  1508. unsigned char *data;
  1509. int i;
  1510. int result;
  1511. int need_flip;
  1512. int packet_offset;
  1513. unsigned long flags;
  1514. dbg("%s - port %d", __FUNCTION__, port->number);
  1515. if (port->open_count <= 0)
  1516. return;
  1517. tty = port->tty;
  1518. if (!tty) {
  1519. dbg("%s - bad tty pointer - exiting",__FUNCTION__);
  1520. return;
  1521. }
  1522. priv = usb_get_serial_port_data(port);
  1523. if (!priv) {
  1524. dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
  1525. return;
  1526. }
  1527. urb = port->read_urb;
  1528. if (!urb) {
  1529. dbg("%s - bad read_urb pointer - exiting", __FUNCTION__);
  1530. return;
  1531. }
  1532. data = urb->transfer_buffer;
  1533. if (priv->rx_processed) {
  1534. dbg("%s - already processed: %d bytes, %d remain", __FUNCTION__,
  1535. priv->rx_processed,
  1536. urb->actual_length - priv->rx_processed);
  1537. } else {
  1538. /* The first two bytes of every read packet are status */
  1539. if (urb->actual_length > 2) {
  1540. usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
  1541. } else {
  1542. dbg("Status only: %03oo %03oo",data[0],data[1]);
  1543. }
  1544. }
  1545. /* TO DO -- check for hung up line and handle appropriately: */
  1546. /* send hangup */
  1547. /* See acm.c - you do a tty_hangup - eg tty_hangup(tty) */
  1548. /* if CD is dropped and the line is not CLOCAL then we should hangup */
  1549. need_flip = 0;
  1550. for (packet_offset = priv->rx_processed; packet_offset < urb->actual_length; packet_offset += PKTSZ) {
  1551. int length;
  1552. /* Compare new line status to the old one, signal if different */
  1553. /* N.B. packet may be processed more than once, but differences
  1554. * are only processed once. */
  1555. if (priv != NULL) {
  1556. char new_status = data[packet_offset+0] & FTDI_STATUS_B0_MASK;
  1557. if (new_status != priv->prev_status) {
  1558. priv->diff_status |= new_status ^ priv->prev_status;
  1559. wake_up_interruptible(&priv->delta_msr_wait);
  1560. priv->prev_status = new_status;
  1561. }
  1562. }
  1563. length = min(PKTSZ, urb->actual_length-packet_offset)-2;
  1564. if (length < 0) {
  1565. err("%s - bad packet length: %d", __FUNCTION__, length+2);
  1566. length = 0;
  1567. }
  1568. if (priv->rx_flags & THROTTLED) {
  1569. dbg("%s - throttled", __FUNCTION__);
  1570. break;
  1571. }
  1572. if (tty_buffer_request_room(tty, length) < length) {
  1573. /* break out & wait for throttling/unthrottling to happen */
  1574. dbg("%s - receive room low", __FUNCTION__);
  1575. break;
  1576. }
  1577. /* Handle errors and break */
  1578. error_flag = TTY_NORMAL;
  1579. /* Although the device uses a bitmask and hence can have multiple */
  1580. /* errors on a packet - the order here sets the priority the */
  1581. /* error is returned to the tty layer */
  1582. if ( data[packet_offset+1] & FTDI_RS_OE ) {
  1583. error_flag = TTY_OVERRUN;
  1584. dbg("OVERRRUN error");
  1585. }
  1586. if ( data[packet_offset+1] & FTDI_RS_BI ) {
  1587. error_flag = TTY_BREAK;
  1588. dbg("BREAK received");
  1589. }
  1590. if ( data[packet_offset+1] & FTDI_RS_PE ) {
  1591. error_flag = TTY_PARITY;
  1592. dbg("PARITY error");
  1593. }
  1594. if ( data[packet_offset+1] & FTDI_RS_FE ) {
  1595. error_flag = TTY_FRAME;
  1596. dbg("FRAMING error");
  1597. }
  1598. if (length > 0) {
  1599. for (i = 2; i < length+2; i++) {
  1600. /* Note that the error flag is duplicated for
  1601. every character received since we don't know
  1602. which character it applied to */
  1603. tty_insert_flip_char(tty, data[packet_offset+i], error_flag);
  1604. }
  1605. need_flip = 1;
  1606. }
  1607. #ifdef NOT_CORRECT_BUT_KEEPING_IT_FOR_NOW
  1608. /* if a parity error is detected you get status packets forever
  1609. until a character is sent without a parity error.
  1610. This doesn't work well since the application receives a never
  1611. ending stream of bad data - even though new data hasn't been sent.
  1612. Therefore I (bill) have taken this out.
  1613. However - this might make sense for framing errors and so on
  1614. so I am leaving the code in for now.
  1615. */
  1616. else {
  1617. if (error_flag != TTY_NORMAL){
  1618. dbg("error_flag is not normal");
  1619. /* In this case it is just status - if that is an error send a bad character */
  1620. if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
  1621. tty_flip_buffer_push(tty);
  1622. }
  1623. tty_insert_flip_char(tty, 0xff, error_flag);
  1624. need_flip = 1;
  1625. }
  1626. }
  1627. #endif
  1628. } /* "for(packet_offset=0..." */
  1629. /* Low latency */
  1630. if (need_flip) {
  1631. tty_flip_buffer_push(tty);
  1632. }
  1633. if (packet_offset < urb->actual_length) {
  1634. /* not completely processed - record progress */
  1635. priv->rx_processed = packet_offset;
  1636. dbg("%s - incomplete, %d bytes processed, %d remain",
  1637. __FUNCTION__, packet_offset,
  1638. urb->actual_length - packet_offset);
  1639. /* check if we were throttled while processing */
  1640. spin_lock_irqsave(&priv->rx_lock, flags);
  1641. if (priv->rx_flags & THROTTLED) {
  1642. priv->rx_flags |= ACTUALLY_THROTTLED;
  1643. spin_unlock_irqrestore(&priv->rx_lock, flags);
  1644. dbg("%s - deferring remainder until unthrottled",
  1645. __FUNCTION__);
  1646. return;
  1647. }
  1648. spin_unlock_irqrestore(&priv->rx_lock, flags);
  1649. /* if the port is closed stop trying to read */
  1650. if (port->open_count > 0){
  1651. /* delay processing of remainder */
  1652. schedule_delayed_work(&priv->rx_work, 1);
  1653. } else {
  1654. dbg("%s - port is closed", __FUNCTION__);
  1655. }
  1656. return;
  1657. }
  1658. /* urb is completely processed */
  1659. priv->rx_processed = 0;
  1660. /* if the port is closed stop trying to read */
  1661. if (port->open_count > 0){
  1662. /* Continue trying to always read */
  1663. usb_fill_bulk_urb(port->read_urb, port->serial->dev,
  1664. usb_rcvbulkpipe(port->serial->dev, port->bulk_in_endpointAddress),
  1665. port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
  1666. ftdi_read_bulk_callback, port);
  1667. result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
  1668. if (result)
  1669. err("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
  1670. }
  1671. return;
  1672. } /* ftdi_process_read */
  1673. static void ftdi_break_ctl( struct usb_serial_port *port, int break_state )
  1674. {
  1675. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1676. __u16 urb_value = 0;
  1677. char buf[1];
  1678. /* break_state = -1 to turn on break, and 0 to turn off break */
  1679. /* see drivers/char/tty_io.c to see it used */
  1680. /* last_set_data_urb_value NEVER has the break bit set in it */
  1681. if (break_state) {
  1682. urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
  1683. } else {
  1684. urb_value = priv->last_set_data_urb_value;
  1685. }
  1686. if (usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
  1687. FTDI_SIO_SET_DATA_REQUEST,
  1688. FTDI_SIO_SET_DATA_REQUEST_TYPE,
  1689. urb_value , priv->interface,
  1690. buf, 0, WDR_TIMEOUT) < 0) {
  1691. err("%s FAILED to enable/disable break state (state was %d)", __FUNCTION__,break_state);
  1692. }
  1693. dbg("%s break state is %d - urb is %d", __FUNCTION__,break_state, urb_value);
  1694. }
  1695. /* old_termios contains the original termios settings and tty->termios contains
  1696. * the new setting to be used
  1697. * WARNING: set_termios calls this with old_termios in kernel space
  1698. */
  1699. static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
  1700. { /* ftdi_termios */
  1701. struct usb_device *dev = port->serial->dev;
  1702. unsigned int cflag = port->tty->termios->c_cflag;
  1703. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1704. __u16 urb_value; /* will hold the new flags */
  1705. char buf[1]; /* Perhaps I should dynamically alloc this? */
  1706. // Added for xon/xoff support
  1707. unsigned int iflag = port->tty->termios->c_iflag;
  1708. unsigned char vstop;
  1709. unsigned char vstart;
  1710. dbg("%s", __FUNCTION__);
  1711. /* Force baud rate if this device requires it, unless it is set to B0. */
  1712. if (priv->force_baud && ((port->tty->termios->c_cflag & CBAUD) != B0)) {
  1713. dbg("%s: forcing baud rate for this device", __FUNCTION__);
  1714. port->tty->termios->c_cflag &= ~CBAUD;
  1715. port->tty->termios->c_cflag |= priv->force_baud;
  1716. }
  1717. /* Force RTS-CTS if this device requires it. */
  1718. if (priv->force_rtscts) {
  1719. dbg("%s: forcing rtscts for this device", __FUNCTION__);
  1720. port->tty->termios->c_cflag |= CRTSCTS;
  1721. }
  1722. cflag = port->tty->termios->c_cflag;
  1723. /* FIXME -For this cut I don't care if the line is really changing or
  1724. not - so just do the change regardless - should be able to
  1725. compare old_termios and tty->termios */
  1726. /* NOTE These routines can get interrupted by
  1727. ftdi_sio_read_bulk_callback - need to examine what this
  1728. means - don't see any problems yet */
  1729. /* Set number of data bits, parity, stop bits */
  1730. urb_value = 0;
  1731. urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
  1732. FTDI_SIO_SET_DATA_STOP_BITS_1);
  1733. urb_value |= (cflag & PARENB ?
  1734. (cflag & PARODD ? FTDI_SIO_SET_DATA_PARITY_ODD :
  1735. FTDI_SIO_SET_DATA_PARITY_EVEN) :
  1736. FTDI_SIO_SET_DATA_PARITY_NONE);
  1737. if (cflag & CSIZE) {
  1738. switch (cflag & CSIZE) {
  1739. case CS5: urb_value |= 5; dbg("Setting CS5"); break;
  1740. case CS6: urb_value |= 6; dbg("Setting CS6"); break;
  1741. case CS7: urb_value |= 7; dbg("Setting CS7"); break;
  1742. case CS8: urb_value |= 8; dbg("Setting CS8"); break;
  1743. default:
  1744. err("CSIZE was set but not CS5-CS8");
  1745. }
  1746. }
  1747. /* This is needed by the break command since it uses the same command - but is
  1748. * or'ed with this value */
  1749. priv->last_set_data_urb_value = urb_value;
  1750. if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  1751. FTDI_SIO_SET_DATA_REQUEST,
  1752. FTDI_SIO_SET_DATA_REQUEST_TYPE,
  1753. urb_value , priv->interface,
  1754. buf, 0, WDR_SHORT_TIMEOUT) < 0) {
  1755. err("%s FAILED to set databits/stopbits/parity", __FUNCTION__);
  1756. }
  1757. /* Now do the baudrate */
  1758. if ((cflag & CBAUD) == B0 ) {
  1759. /* Disable flow control */
  1760. if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  1761. FTDI_SIO_SET_FLOW_CTRL_REQUEST,
  1762. FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
  1763. 0, priv->interface,
  1764. buf, 0, WDR_TIMEOUT) < 0) {
  1765. err("%s error from disable flowcontrol urb", __FUNCTION__);
  1766. }
  1767. /* Drop RTS and DTR */
  1768. clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
  1769. } else {
  1770. /* set the baudrate determined before */
  1771. if (change_speed(port)) {
  1772. err("%s urb failed to set baudrate", __FUNCTION__);
  1773. }
  1774. /* Ensure RTS and DTR are raised when baudrate changed from 0 */
  1775. if (!old_termios || (old_termios->c_cflag & CBAUD) == B0) {
  1776. set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
  1777. }
  1778. }
  1779. /* Set flow control */
  1780. /* Note device also supports DTR/CD (ugh) and Xon/Xoff in hardware */
  1781. if (cflag & CRTSCTS) {
  1782. dbg("%s Setting to CRTSCTS flow control", __FUNCTION__);
  1783. if (usb_control_msg(dev,
  1784. usb_sndctrlpipe(dev, 0),
  1785. FTDI_SIO_SET_FLOW_CTRL_REQUEST,
  1786. FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
  1787. 0 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
  1788. buf, 0, WDR_TIMEOUT) < 0) {
  1789. err("urb failed to set to rts/cts flow control");
  1790. }
  1791. } else {
  1792. /*
  1793. * Xon/Xoff code
  1794. *
  1795. * Check the IXOFF status in the iflag component of the termios structure
  1796. * if IXOFF is not set, the pre-xon/xoff code is executed.
  1797. */
  1798. if (iflag & IXOFF) {
  1799. dbg("%s request to enable xonxoff iflag=%04x",__FUNCTION__,iflag);
  1800. // Try to enable the XON/XOFF on the ftdi_sio
  1801. // Set the vstart and vstop -- could have been done up above where
  1802. // a lot of other dereferencing is done but that would be very
  1803. // inefficient as vstart and vstop are not always needed
  1804. vstart=port->tty->termios->c_cc[VSTART];
  1805. vstop=port->tty->termios->c_cc[VSTOP];
  1806. urb_value=(vstop << 8) | (vstart);
  1807. if (usb_control_msg(dev,
  1808. usb_sndctrlpipe(dev, 0),
  1809. FTDI_SIO_SET_FLOW_CTRL_REQUEST,
  1810. FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
  1811. urb_value , (FTDI_SIO_XON_XOFF_HS
  1812. | priv->interface),
  1813. buf, 0, WDR_TIMEOUT) < 0) {
  1814. err("urb failed to set to xon/xoff flow control");
  1815. }
  1816. } else {
  1817. /* else clause to only run if cfag ! CRTSCTS and iflag ! XOFF */
  1818. /* CHECKME Assuming XON/XOFF handled by tty stack - not by device */
  1819. dbg("%s Turning off hardware flow control", __FUNCTION__);
  1820. if (usb_control_msg(dev,
  1821. usb_sndctrlpipe(dev, 0),
  1822. FTDI_SIO_SET_FLOW_CTRL_REQUEST,
  1823. FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
  1824. 0, priv->interface,
  1825. buf, 0, WDR_TIMEOUT) < 0) {
  1826. err("urb failed to clear flow control");
  1827. }
  1828. }
  1829. }
  1830. return;
  1831. } /* ftdi_termios */
  1832. static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
  1833. {
  1834. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1835. unsigned char buf[2];
  1836. int ret;
  1837. dbg("%s TIOCMGET", __FUNCTION__);
  1838. switch (priv->chip_type) {
  1839. case SIO:
  1840. /* Request the status from the device */
  1841. if ((ret = usb_control_msg(port->serial->dev,
  1842. usb_rcvctrlpipe(port->serial->dev, 0),
  1843. FTDI_SIO_GET_MODEM_STATUS_REQUEST,
  1844. FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
  1845. 0, 0,
  1846. buf, 1, WDR_TIMEOUT)) < 0 ) {
  1847. err("%s Could not get modem status of device - err: %d", __FUNCTION__,
  1848. ret);
  1849. return(ret);
  1850. }
  1851. break;
  1852. case FT8U232AM:
  1853. case FT232BM:
  1854. case FT2232C:
  1855. /* the 8U232AM returns a two byte value (the sio is a 1 byte value) - in the same
  1856. format as the data returned from the in point */
  1857. if ((ret = usb_control_msg(port->serial->dev,
  1858. usb_rcvctrlpipe(port->serial->dev, 0),
  1859. FTDI_SIO_GET_MODEM_STATUS_REQUEST,
  1860. FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
  1861. 0, priv->interface,
  1862. buf, 2, WDR_TIMEOUT)) < 0 ) {
  1863. err("%s Could not get modem status of device - err: %d", __FUNCTION__,
  1864. ret);
  1865. return(ret);
  1866. }
  1867. break;
  1868. default:
  1869. return -EFAULT;
  1870. break;
  1871. }
  1872. return (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
  1873. (buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
  1874. (buf[0] & FTDI_SIO_RI_MASK ? TIOCM_RI : 0) |
  1875. (buf[0] & FTDI_SIO_RLSD_MASK ? TIOCM_CD : 0) |
  1876. priv->last_dtr_rts;
  1877. }
  1878. static int ftdi_tiocmset(struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear)
  1879. {
  1880. dbg("%s TIOCMSET", __FUNCTION__);
  1881. return update_mctrl(port, set, clear);
  1882. }
  1883. static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
  1884. {
  1885. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1886. dbg("%s cmd 0x%04x", __FUNCTION__, cmd);
  1887. /* Based on code from acm.c and others */
  1888. switch (cmd) {
  1889. case TIOCGSERIAL: /* gets serial port data */
  1890. return get_serial_info(port, (struct serial_struct __user *) arg);
  1891. case TIOCSSERIAL: /* sets serial port data */
  1892. return set_serial_info(port, (struct serial_struct __user *) arg);
  1893. /*
  1894. * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
  1895. * - mask passed in arg for lines of interest
  1896. * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
  1897. * Caller should use TIOCGICOUNT to see which one it was.
  1898. *
  1899. * This code is borrowed from linux/drivers/char/serial.c
  1900. */
  1901. case TIOCMIWAIT:
  1902. while (priv != NULL) {
  1903. interruptible_sleep_on(&priv->delta_msr_wait);
  1904. /* see if a signal did it */
  1905. if (signal_pending(current))
  1906. return -ERESTARTSYS;
  1907. else {
  1908. char diff = priv->diff_status;
  1909. if (diff == 0) {
  1910. return -EIO; /* no change => error */
  1911. }
  1912. /* Consume all events */
  1913. priv->diff_status = 0;
  1914. /* Return 0 if caller wanted to know about these bits */
  1915. if ( ((arg & TIOCM_RNG) && (diff & FTDI_RS0_RI)) ||
  1916. ((arg & TIOCM_DSR) && (diff & FTDI_RS0_DSR)) ||
  1917. ((arg & TIOCM_CD) && (diff & FTDI_RS0_RLSD)) ||
  1918. ((arg & TIOCM_CTS) && (diff & FTDI_RS0_CTS)) ) {
  1919. return 0;
  1920. }
  1921. /*
  1922. * Otherwise caller can't care less about what happened,
  1923. * and so we continue to wait for more events.
  1924. */
  1925. }
  1926. }
  1927. return(0);
  1928. break;
  1929. default:
  1930. break;
  1931. }
  1932. /* This is not necessarily an error - turns out the higher layers will do
  1933. * some ioctls itself (see comment above)
  1934. */
  1935. dbg("%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h", __FUNCTION__, cmd);
  1936. return(-ENOIOCTLCMD);
  1937. } /* ftdi_ioctl */
  1938. static void ftdi_throttle (struct usb_serial_port *port)
  1939. {
  1940. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1941. unsigned long flags;
  1942. dbg("%s - port %d", __FUNCTION__, port->number);
  1943. spin_lock_irqsave(&priv->rx_lock, flags);
  1944. priv->rx_flags |= THROTTLED;
  1945. spin_unlock_irqrestore(&priv->rx_lock, flags);
  1946. }
  1947. static void ftdi_unthrottle (struct usb_serial_port *port)
  1948. {
  1949. struct ftdi_private *priv = usb_get_serial_port_data(port);
  1950. int actually_throttled;
  1951. unsigned long flags;
  1952. dbg("%s - port %d", __FUNCTION__, port->number);
  1953. spin_lock_irqsave(&priv->rx_lock, flags);
  1954. actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED;
  1955. priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
  1956. spin_unlock_irqrestore(&priv->rx_lock, flags);
  1957. if (actually_throttled)
  1958. schedule_delayed_work(&priv->rx_work, 0);
  1959. }
  1960. static int __init ftdi_init (void)
  1961. {
  1962. int retval;
  1963. dbg("%s", __FUNCTION__);
  1964. if (vendor > 0 && product > 0) {
  1965. /* Add user specified VID/PID to reserved element of table. */
  1966. int i;
  1967. for (i = 0; id_table_combined[i].idVendor; i++)
  1968. ;
  1969. id_table_combined[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
  1970. id_table_combined[i].idVendor = vendor;
  1971. id_table_combined[i].idProduct = product;
  1972. }
  1973. retval = usb_serial_register(&ftdi_sio_device);
  1974. if (retval)
  1975. goto failed_sio_register;
  1976. retval = usb_register(&ftdi_driver);
  1977. if (retval)
  1978. goto failed_usb_register;
  1979. info(DRIVER_VERSION ":" DRIVER_DESC);
  1980. return 0;
  1981. failed_usb_register:
  1982. usb_serial_deregister(&ftdi_sio_device);
  1983. failed_sio_register:
  1984. return retval;
  1985. }
  1986. static void __exit ftdi_exit (void)
  1987. {
  1988. dbg("%s", __FUNCTION__);
  1989. usb_deregister (&ftdi_driver);
  1990. usb_serial_deregister (&ftdi_sio_device);
  1991. }
  1992. module_init(ftdi_init);
  1993. module_exit(ftdi_exit);
  1994. MODULE_AUTHOR( DRIVER_AUTHOR );
  1995. MODULE_DESCRIPTION( DRIVER_DESC );
  1996. MODULE_LICENSE("GPL");
  1997. module_param(debug, bool, S_IRUGO | S_IWUSR);
  1998. MODULE_PARM_DESC(debug, "Debug enabled or not");
  1999. module_param(vendor, ushort, 0);
  2000. MODULE_PARM_DESC(vendor, "User specified vendor ID (default="
  2001. __MODULE_STRING(FTDI_VID)")");
  2002. module_param(product, ushort, 0);
  2003. MODULE_PARM_DESC(vendor, "User specified product ID");