ftdi_sio.c 81 KB

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