pl2303.c 28 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Prolific PL2303 USB to serial adaptor driver
  4. *
  5. * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
  6. * Copyright (C) 2003 IBM Corp.
  7. *
  8. * Original driver for 2.2.x by anonymous
  9. *
  10. * See Documentation/usb/usb-serial.txt for more information on using this
  11. * driver
  12. */
  13. #include <linux/kernel.h>
  14. #include <linux/errno.h>
  15. #include <linux/slab.h>
  16. #include <linux/tty.h>
  17. #include <linux/tty_driver.h>
  18. #include <linux/tty_flip.h>
  19. #include <linux/serial.h>
  20. #include <linux/module.h>
  21. #include <linux/moduleparam.h>
  22. #include <linux/spinlock.h>
  23. #include <linux/uaccess.h>
  24. #include <linux/usb.h>
  25. #include <linux/usb/serial.h>
  26. #include <asm/unaligned.h>
  27. #include "pl2303.h"
  28. #define PL2303_QUIRK_UART_STATE_IDX0 BIT(0)
  29. #define PL2303_QUIRK_LEGACY BIT(1)
  30. #define PL2303_QUIRK_ENDPOINT_HACK BIT(2)
  31. static const struct usb_device_id id_table[] = {
  32. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID),
  33. .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
  34. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
  35. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
  36. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
  37. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_CHILITAG) },
  38. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
  39. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
  40. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
  41. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
  42. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
  43. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
  44. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ZTEK) },
  45. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_TB) },
  46. { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
  47. { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
  48. { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID),
  49. .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
  50. { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC485),
  51. .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
  52. { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC232B),
  53. .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
  54. { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
  55. { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
  56. { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
  57. { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
  58. { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
  59. { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
  60. { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
  61. { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
  62. { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
  63. { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
  64. { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
  65. { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
  66. { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
  67. { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
  68. .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
  69. { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
  70. .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
  71. { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
  72. .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
  73. { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81),
  74. .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
  75. { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
  76. { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
  77. { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
  78. { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
  79. { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
  80. { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
  81. { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
  82. { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
  83. { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
  84. { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID),
  85. .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
  86. { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
  87. { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
  88. { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
  89. { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
  90. { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
  91. { USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
  92. { USB_DEVICE(HP_VENDOR_ID, HP_LD381_PRODUCT_ID) },
  93. { USB_DEVICE(HP_VENDOR_ID, HP_LD381GC_PRODUCT_ID) },
  94. { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
  95. { USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
  96. { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
  97. { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
  98. { USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
  99. { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
  100. { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
  101. { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
  102. { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
  103. { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
  104. { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
  105. { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
  106. { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
  107. { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) },
  108. { } /* Terminating entry */
  109. };
  110. MODULE_DEVICE_TABLE(usb, id_table);
  111. #define SET_LINE_REQUEST_TYPE 0x21
  112. #define SET_LINE_REQUEST 0x20
  113. #define SET_CONTROL_REQUEST_TYPE 0x21
  114. #define SET_CONTROL_REQUEST 0x22
  115. #define CONTROL_DTR 0x01
  116. #define CONTROL_RTS 0x02
  117. #define BREAK_REQUEST_TYPE 0x21
  118. #define BREAK_REQUEST 0x23
  119. #define BREAK_ON 0xffff
  120. #define BREAK_OFF 0x0000
  121. #define GET_LINE_REQUEST_TYPE 0xa1
  122. #define GET_LINE_REQUEST 0x21
  123. #define VENDOR_WRITE_REQUEST_TYPE 0x40
  124. #define VENDOR_WRITE_REQUEST 0x01
  125. #define VENDOR_READ_REQUEST_TYPE 0xc0
  126. #define VENDOR_READ_REQUEST 0x01
  127. #define UART_STATE_INDEX 8
  128. #define UART_STATE_MSR_MASK 0x8b
  129. #define UART_STATE_TRANSIENT_MASK 0x74
  130. #define UART_DCD 0x01
  131. #define UART_DSR 0x02
  132. #define UART_BREAK_ERROR 0x04
  133. #define UART_RING 0x08
  134. #define UART_FRAME_ERROR 0x10
  135. #define UART_PARITY_ERROR 0x20
  136. #define UART_OVERRUN_ERROR 0x40
  137. #define UART_CTS 0x80
  138. static void pl2303_set_break(struct usb_serial_port *port, bool enable);
  139. enum pl2303_type {
  140. TYPE_01, /* Type 0 and 1 (difference unknown) */
  141. TYPE_HX, /* HX version of the pl2303 chip */
  142. TYPE_COUNT
  143. };
  144. struct pl2303_type_data {
  145. speed_t max_baud_rate;
  146. unsigned long quirks;
  147. };
  148. struct pl2303_serial_private {
  149. const struct pl2303_type_data *type;
  150. unsigned long quirks;
  151. };
  152. struct pl2303_private {
  153. spinlock_t lock;
  154. u8 line_control;
  155. u8 line_status;
  156. u8 line_settings[7];
  157. };
  158. static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
  159. [TYPE_01] = {
  160. .max_baud_rate = 1228800,
  161. .quirks = PL2303_QUIRK_LEGACY,
  162. },
  163. [TYPE_HX] = {
  164. .max_baud_rate = 12000000,
  165. },
  166. };
  167. static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
  168. unsigned char buf[1])
  169. {
  170. struct device *dev = &serial->interface->dev;
  171. int res;
  172. res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
  173. VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
  174. value, 0, buf, 1, 100);
  175. if (res != 1) {
  176. dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
  177. value, res);
  178. if (res >= 0)
  179. res = -EIO;
  180. return res;
  181. }
  182. dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
  183. return 0;
  184. }
  185. static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
  186. {
  187. struct device *dev = &serial->interface->dev;
  188. int res;
  189. dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
  190. res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
  191. VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
  192. value, index, NULL, 0, 100);
  193. if (res) {
  194. dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
  195. value, res);
  196. return res;
  197. }
  198. return 0;
  199. }
  200. static int pl2303_probe(struct usb_serial *serial,
  201. const struct usb_device_id *id)
  202. {
  203. usb_set_serial_data(serial, (void *)id->driver_info);
  204. return 0;
  205. }
  206. /*
  207. * Use interrupt endpoint from first interface if available.
  208. *
  209. * This is needed due to the looney way its endpoints are set up.
  210. */
  211. static int pl2303_endpoint_hack(struct usb_serial *serial,
  212. struct usb_serial_endpoints *epds)
  213. {
  214. struct usb_interface *interface = serial->interface;
  215. struct usb_device *dev = serial->dev;
  216. struct device *ddev = &interface->dev;
  217. struct usb_host_interface *iface_desc;
  218. struct usb_endpoint_descriptor *endpoint;
  219. unsigned int i;
  220. if (interface == dev->actconfig->interface[0])
  221. return 0;
  222. /* check out the endpoints of the other interface */
  223. iface_desc = dev->actconfig->interface[0]->cur_altsetting;
  224. for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
  225. endpoint = &iface_desc->endpoint[i].desc;
  226. if (!usb_endpoint_is_int_in(endpoint))
  227. continue;
  228. dev_dbg(ddev, "found interrupt in on separate interface\n");
  229. if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
  230. epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
  231. }
  232. return 0;
  233. }
  234. static int pl2303_calc_num_ports(struct usb_serial *serial,
  235. struct usb_serial_endpoints *epds)
  236. {
  237. unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
  238. struct device *dev = &serial->interface->dev;
  239. int ret;
  240. if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
  241. ret = pl2303_endpoint_hack(serial, epds);
  242. if (ret)
  243. return ret;
  244. }
  245. if (epds->num_interrupt_in < 1) {
  246. dev_err(dev, "required interrupt-in endpoint missing\n");
  247. return -ENODEV;
  248. }
  249. return 1;
  250. }
  251. static int pl2303_startup(struct usb_serial *serial)
  252. {
  253. struct pl2303_serial_private *spriv;
  254. enum pl2303_type type = TYPE_01;
  255. unsigned char *buf;
  256. spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
  257. if (!spriv)
  258. return -ENOMEM;
  259. buf = kmalloc(1, GFP_KERNEL);
  260. if (!buf) {
  261. kfree(spriv);
  262. return -ENOMEM;
  263. }
  264. if (serial->dev->descriptor.bDeviceClass == 0x02)
  265. type = TYPE_01; /* type 0 */
  266. else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
  267. type = TYPE_HX;
  268. else if (serial->dev->descriptor.bDeviceClass == 0x00)
  269. type = TYPE_01; /* type 1 */
  270. else if (serial->dev->descriptor.bDeviceClass == 0xFF)
  271. type = TYPE_01; /* type 1 */
  272. dev_dbg(&serial->interface->dev, "device type: %d\n", type);
  273. spriv->type = &pl2303_type_data[type];
  274. spriv->quirks = (unsigned long)usb_get_serial_data(serial);
  275. spriv->quirks |= spriv->type->quirks;
  276. usb_set_serial_data(serial, spriv);
  277. pl2303_vendor_read(serial, 0x8484, buf);
  278. pl2303_vendor_write(serial, 0x0404, 0);
  279. pl2303_vendor_read(serial, 0x8484, buf);
  280. pl2303_vendor_read(serial, 0x8383, buf);
  281. pl2303_vendor_read(serial, 0x8484, buf);
  282. pl2303_vendor_write(serial, 0x0404, 1);
  283. pl2303_vendor_read(serial, 0x8484, buf);
  284. pl2303_vendor_read(serial, 0x8383, buf);
  285. pl2303_vendor_write(serial, 0, 1);
  286. pl2303_vendor_write(serial, 1, 0);
  287. if (spriv->quirks & PL2303_QUIRK_LEGACY)
  288. pl2303_vendor_write(serial, 2, 0x24);
  289. else
  290. pl2303_vendor_write(serial, 2, 0x44);
  291. kfree(buf);
  292. return 0;
  293. }
  294. static void pl2303_release(struct usb_serial *serial)
  295. {
  296. struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
  297. kfree(spriv);
  298. }
  299. static int pl2303_port_probe(struct usb_serial_port *port)
  300. {
  301. struct pl2303_private *priv;
  302. priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  303. if (!priv)
  304. return -ENOMEM;
  305. spin_lock_init(&priv->lock);
  306. usb_set_serial_port_data(port, priv);
  307. port->port.drain_delay = 256;
  308. return 0;
  309. }
  310. static int pl2303_port_remove(struct usb_serial_port *port)
  311. {
  312. struct pl2303_private *priv = usb_get_serial_port_data(port);
  313. kfree(priv);
  314. return 0;
  315. }
  316. static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
  317. {
  318. struct usb_device *dev = port->serial->dev;
  319. int retval;
  320. dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
  321. retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  322. SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
  323. value, 0, NULL, 0, 100);
  324. if (retval)
  325. dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
  326. return retval;
  327. }
  328. /*
  329. * Returns the nearest supported baud rate that can be set directly without
  330. * using divisors.
  331. */
  332. static speed_t pl2303_get_supported_baud_rate(speed_t baud)
  333. {
  334. static const speed_t baud_sup[] = {
  335. 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
  336. 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
  337. 614400, 921600, 1228800, 2457600, 3000000, 6000000
  338. };
  339. unsigned i;
  340. for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
  341. if (baud_sup[i] > baud)
  342. break;
  343. }
  344. if (i == ARRAY_SIZE(baud_sup))
  345. baud = baud_sup[i - 1];
  346. else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
  347. baud = baud_sup[i - 1];
  348. else
  349. baud = baud_sup[i];
  350. return baud;
  351. }
  352. /*
  353. * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
  354. * use 9600 baud.
  355. */
  356. static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
  357. speed_t baud)
  358. {
  359. put_unaligned_le32(baud, buf);
  360. return baud;
  361. }
  362. static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
  363. speed_t baud)
  364. {
  365. unsigned int baseline, mantissa, exponent;
  366. /*
  367. * Apparently the formula is:
  368. * baudrate = 12M * 32 / (mantissa * 4^exponent)
  369. * where
  370. * mantissa = buf[8:0]
  371. * exponent = buf[11:9]
  372. */
  373. baseline = 12000000 * 32;
  374. mantissa = baseline / baud;
  375. if (mantissa == 0)
  376. mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
  377. exponent = 0;
  378. while (mantissa >= 512) {
  379. if (exponent < 7) {
  380. mantissa >>= 2; /* divide by 4 */
  381. exponent++;
  382. } else {
  383. /* Exponent is maxed. Trim mantissa and leave. */
  384. mantissa = 511;
  385. break;
  386. }
  387. }
  388. buf[3] = 0x80;
  389. buf[2] = 0;
  390. buf[1] = exponent << 1 | mantissa >> 8;
  391. buf[0] = mantissa & 0xff;
  392. /* Calculate and return the exact baud rate. */
  393. baud = (baseline / mantissa) >> (exponent << 1);
  394. return baud;
  395. }
  396. static void pl2303_encode_baud_rate(struct tty_struct *tty,
  397. struct usb_serial_port *port,
  398. u8 buf[4])
  399. {
  400. struct usb_serial *serial = port->serial;
  401. struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
  402. speed_t baud_sup;
  403. speed_t baud;
  404. baud = tty_get_baud_rate(tty);
  405. dev_dbg(&port->dev, "baud requested = %u\n", baud);
  406. if (!baud)
  407. return;
  408. if (spriv->type->max_baud_rate)
  409. baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
  410. /*
  411. * Use direct method for supported baud rates, otherwise use divisors.
  412. */
  413. baud_sup = pl2303_get_supported_baud_rate(baud);
  414. if (baud == baud_sup)
  415. baud = pl2303_encode_baud_rate_direct(buf, baud);
  416. else
  417. baud = pl2303_encode_baud_rate_divisor(buf, baud);
  418. /* Save resulting baud rate */
  419. tty_encode_baud_rate(tty, baud, baud);
  420. dev_dbg(&port->dev, "baud set = %u\n", baud);
  421. }
  422. static int pl2303_get_line_request(struct usb_serial_port *port,
  423. unsigned char buf[7])
  424. {
  425. struct usb_device *udev = port->serial->dev;
  426. int ret;
  427. ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
  428. GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
  429. 0, 0, buf, 7, 100);
  430. if (ret != 7) {
  431. dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
  432. if (ret >= 0)
  433. ret = -EIO;
  434. return ret;
  435. }
  436. dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
  437. return 0;
  438. }
  439. static int pl2303_set_line_request(struct usb_serial_port *port,
  440. unsigned char buf[7])
  441. {
  442. struct usb_device *udev = port->serial->dev;
  443. int ret;
  444. ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
  445. SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
  446. 0, 0, buf, 7, 100);
  447. if (ret < 0) {
  448. dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
  449. return ret;
  450. }
  451. dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
  452. return 0;
  453. }
  454. static bool pl2303_termios_change(const struct ktermios *a, const struct ktermios *b)
  455. {
  456. bool ixon_change;
  457. ixon_change = ((a->c_iflag ^ b->c_iflag) & (IXON | IXANY)) ||
  458. a->c_cc[VSTART] != b->c_cc[VSTART] ||
  459. a->c_cc[VSTOP] != b->c_cc[VSTOP];
  460. return tty_termios_hw_change(a, b) || ixon_change;
  461. }
  462. static void pl2303_set_termios(struct tty_struct *tty,
  463. struct usb_serial_port *port, struct ktermios *old_termios)
  464. {
  465. struct usb_serial *serial = port->serial;
  466. struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
  467. struct pl2303_private *priv = usb_get_serial_port_data(port);
  468. unsigned long flags;
  469. unsigned char *buf;
  470. int ret;
  471. u8 control;
  472. if (old_termios && !pl2303_termios_change(&tty->termios, old_termios))
  473. return;
  474. buf = kzalloc(7, GFP_KERNEL);
  475. if (!buf) {
  476. /* Report back no change occurred */
  477. if (old_termios)
  478. tty->termios = *old_termios;
  479. return;
  480. }
  481. pl2303_get_line_request(port, buf);
  482. switch (C_CSIZE(tty)) {
  483. case CS5:
  484. buf[6] = 5;
  485. break;
  486. case CS6:
  487. buf[6] = 6;
  488. break;
  489. case CS7:
  490. buf[6] = 7;
  491. break;
  492. default:
  493. case CS8:
  494. buf[6] = 8;
  495. }
  496. dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
  497. /* For reference buf[0]:buf[3] baud rate value */
  498. pl2303_encode_baud_rate(tty, port, &buf[0]);
  499. /* For reference buf[4]=0 is 1 stop bits */
  500. /* For reference buf[4]=1 is 1.5 stop bits */
  501. /* For reference buf[4]=2 is 2 stop bits */
  502. if (C_CSTOPB(tty)) {
  503. /*
  504. * NOTE: Comply with "real" UARTs / RS232:
  505. * use 1.5 instead of 2 stop bits with 5 data bits
  506. */
  507. if (C_CSIZE(tty) == CS5) {
  508. buf[4] = 1;
  509. dev_dbg(&port->dev, "stop bits = 1.5\n");
  510. } else {
  511. buf[4] = 2;
  512. dev_dbg(&port->dev, "stop bits = 2\n");
  513. }
  514. } else {
  515. buf[4] = 0;
  516. dev_dbg(&port->dev, "stop bits = 1\n");
  517. }
  518. if (C_PARENB(tty)) {
  519. /* For reference buf[5]=0 is none parity */
  520. /* For reference buf[5]=1 is odd parity */
  521. /* For reference buf[5]=2 is even parity */
  522. /* For reference buf[5]=3 is mark parity */
  523. /* For reference buf[5]=4 is space parity */
  524. if (C_PARODD(tty)) {
  525. if (C_CMSPAR(tty)) {
  526. buf[5] = 3;
  527. dev_dbg(&port->dev, "parity = mark\n");
  528. } else {
  529. buf[5] = 1;
  530. dev_dbg(&port->dev, "parity = odd\n");
  531. }
  532. } else {
  533. if (C_CMSPAR(tty)) {
  534. buf[5] = 4;
  535. dev_dbg(&port->dev, "parity = space\n");
  536. } else {
  537. buf[5] = 2;
  538. dev_dbg(&port->dev, "parity = even\n");
  539. }
  540. }
  541. } else {
  542. buf[5] = 0;
  543. dev_dbg(&port->dev, "parity = none\n");
  544. }
  545. /*
  546. * Some PL2303 are known to lose bytes if you change serial settings
  547. * even to the same values as before. Thus we actually need to filter
  548. * in this specific case.
  549. *
  550. * Note that the tty_termios_hw_change check above is not sufficient
  551. * as a previously requested baud rate may differ from the one
  552. * actually used (and stored in old_termios).
  553. *
  554. * NOTE: No additional locking needed for line_settings as it is
  555. * only used in set_termios, which is serialised against itself.
  556. */
  557. if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
  558. ret = pl2303_set_line_request(port, buf);
  559. if (!ret)
  560. memcpy(priv->line_settings, buf, 7);
  561. }
  562. /* change control lines if we are switching to or from B0 */
  563. spin_lock_irqsave(&priv->lock, flags);
  564. control = priv->line_control;
  565. if (C_BAUD(tty) == B0)
  566. priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
  567. else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
  568. priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
  569. if (control != priv->line_control) {
  570. control = priv->line_control;
  571. spin_unlock_irqrestore(&priv->lock, flags);
  572. pl2303_set_control_lines(port, control);
  573. } else {
  574. spin_unlock_irqrestore(&priv->lock, flags);
  575. }
  576. if (C_CRTSCTS(tty)) {
  577. if (spriv->quirks & PL2303_QUIRK_LEGACY)
  578. pl2303_vendor_write(serial, 0x0, 0x41);
  579. else
  580. pl2303_vendor_write(serial, 0x0, 0x61);
  581. } else if (I_IXON(tty) && !I_IXANY(tty) && START_CHAR(tty) == 0x11 &&
  582. STOP_CHAR(tty) == 0x13) {
  583. pl2303_vendor_write(serial, 0x0, 0xc0);
  584. } else {
  585. pl2303_vendor_write(serial, 0x0, 0x0);
  586. }
  587. kfree(buf);
  588. }
  589. static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
  590. {
  591. struct pl2303_private *priv = usb_get_serial_port_data(port);
  592. unsigned long flags;
  593. u8 control;
  594. spin_lock_irqsave(&priv->lock, flags);
  595. if (on)
  596. priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
  597. else
  598. priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
  599. control = priv->line_control;
  600. spin_unlock_irqrestore(&priv->lock, flags);
  601. pl2303_set_control_lines(port, control);
  602. }
  603. static void pl2303_close(struct usb_serial_port *port)
  604. {
  605. usb_serial_generic_close(port);
  606. usb_kill_urb(port->interrupt_in_urb);
  607. pl2303_set_break(port, false);
  608. }
  609. static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
  610. {
  611. struct usb_serial *serial = port->serial;
  612. struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
  613. int result;
  614. if (spriv->quirks & PL2303_QUIRK_LEGACY) {
  615. usb_clear_halt(serial->dev, port->write_urb->pipe);
  616. usb_clear_halt(serial->dev, port->read_urb->pipe);
  617. } else {
  618. /* reset upstream data pipes */
  619. pl2303_vendor_write(serial, 8, 0);
  620. pl2303_vendor_write(serial, 9, 0);
  621. }
  622. /* Setup termios */
  623. if (tty)
  624. pl2303_set_termios(tty, port, NULL);
  625. result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
  626. if (result) {
  627. dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
  628. result);
  629. return result;
  630. }
  631. result = usb_serial_generic_open(tty, port);
  632. if (result) {
  633. usb_kill_urb(port->interrupt_in_urb);
  634. return result;
  635. }
  636. return 0;
  637. }
  638. static int pl2303_tiocmset(struct tty_struct *tty,
  639. unsigned int set, unsigned int clear)
  640. {
  641. struct usb_serial_port *port = tty->driver_data;
  642. struct pl2303_private *priv = usb_get_serial_port_data(port);
  643. unsigned long flags;
  644. u8 control;
  645. int ret;
  646. spin_lock_irqsave(&priv->lock, flags);
  647. if (set & TIOCM_RTS)
  648. priv->line_control |= CONTROL_RTS;
  649. if (set & TIOCM_DTR)
  650. priv->line_control |= CONTROL_DTR;
  651. if (clear & TIOCM_RTS)
  652. priv->line_control &= ~CONTROL_RTS;
  653. if (clear & TIOCM_DTR)
  654. priv->line_control &= ~CONTROL_DTR;
  655. control = priv->line_control;
  656. spin_unlock_irqrestore(&priv->lock, flags);
  657. ret = pl2303_set_control_lines(port, control);
  658. if (ret)
  659. return usb_translate_errors(ret);
  660. return 0;
  661. }
  662. static int pl2303_tiocmget(struct tty_struct *tty)
  663. {
  664. struct usb_serial_port *port = tty->driver_data;
  665. struct pl2303_private *priv = usb_get_serial_port_data(port);
  666. unsigned long flags;
  667. unsigned int mcr;
  668. unsigned int status;
  669. unsigned int result;
  670. spin_lock_irqsave(&priv->lock, flags);
  671. mcr = priv->line_control;
  672. status = priv->line_status;
  673. spin_unlock_irqrestore(&priv->lock, flags);
  674. result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
  675. | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
  676. | ((status & UART_CTS) ? TIOCM_CTS : 0)
  677. | ((status & UART_DSR) ? TIOCM_DSR : 0)
  678. | ((status & UART_RING) ? TIOCM_RI : 0)
  679. | ((status & UART_DCD) ? TIOCM_CD : 0);
  680. dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
  681. return result;
  682. }
  683. static int pl2303_carrier_raised(struct usb_serial_port *port)
  684. {
  685. struct pl2303_private *priv = usb_get_serial_port_data(port);
  686. if (priv->line_status & UART_DCD)
  687. return 1;
  688. return 0;
  689. }
  690. static int pl2303_ioctl(struct tty_struct *tty,
  691. unsigned int cmd, unsigned long arg)
  692. {
  693. struct serial_struct ser;
  694. struct usb_serial_port *port = tty->driver_data;
  695. switch (cmd) {
  696. case TIOCGSERIAL:
  697. memset(&ser, 0, sizeof ser);
  698. ser.type = PORT_16654;
  699. ser.line = port->minor;
  700. ser.port = port->port_number;
  701. ser.baud_base = 460800;
  702. if (copy_to_user((void __user *)arg, &ser, sizeof ser))
  703. return -EFAULT;
  704. return 0;
  705. default:
  706. break;
  707. }
  708. return -ENOIOCTLCMD;
  709. }
  710. static void pl2303_set_break(struct usb_serial_port *port, bool enable)
  711. {
  712. struct usb_serial *serial = port->serial;
  713. u16 state;
  714. int result;
  715. if (enable)
  716. state = BREAK_ON;
  717. else
  718. state = BREAK_OFF;
  719. dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
  720. state == BREAK_OFF ? "off" : "on");
  721. result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
  722. BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
  723. 0, NULL, 0, 100);
  724. if (result)
  725. dev_err(&port->dev, "error sending break = %d\n", result);
  726. }
  727. static void pl2303_break_ctl(struct tty_struct *tty, int state)
  728. {
  729. struct usb_serial_port *port = tty->driver_data;
  730. pl2303_set_break(port, state);
  731. }
  732. static void pl2303_update_line_status(struct usb_serial_port *port,
  733. unsigned char *data,
  734. unsigned int actual_length)
  735. {
  736. struct usb_serial *serial = port->serial;
  737. struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
  738. struct pl2303_private *priv = usb_get_serial_port_data(port);
  739. struct tty_struct *tty;
  740. unsigned long flags;
  741. unsigned int status_idx = UART_STATE_INDEX;
  742. u8 status;
  743. u8 delta;
  744. if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
  745. status_idx = 0;
  746. if (actual_length < status_idx + 1)
  747. return;
  748. status = data[status_idx];
  749. /* Save off the uart status for others to look at */
  750. spin_lock_irqsave(&priv->lock, flags);
  751. delta = priv->line_status ^ status;
  752. priv->line_status = status;
  753. spin_unlock_irqrestore(&priv->lock, flags);
  754. if (status & UART_BREAK_ERROR)
  755. usb_serial_handle_break(port);
  756. if (delta & UART_STATE_MSR_MASK) {
  757. if (delta & UART_CTS)
  758. port->icount.cts++;
  759. if (delta & UART_DSR)
  760. port->icount.dsr++;
  761. if (delta & UART_RING)
  762. port->icount.rng++;
  763. if (delta & UART_DCD) {
  764. port->icount.dcd++;
  765. tty = tty_port_tty_get(&port->port);
  766. if (tty) {
  767. usb_serial_handle_dcd_change(port, tty,
  768. status & UART_DCD);
  769. tty_kref_put(tty);
  770. }
  771. }
  772. wake_up_interruptible(&port->port.delta_msr_wait);
  773. }
  774. }
  775. static void pl2303_read_int_callback(struct urb *urb)
  776. {
  777. struct usb_serial_port *port = urb->context;
  778. unsigned char *data = urb->transfer_buffer;
  779. unsigned int actual_length = urb->actual_length;
  780. int status = urb->status;
  781. int retval;
  782. switch (status) {
  783. case 0:
  784. /* success */
  785. break;
  786. case -ECONNRESET:
  787. case -ENOENT:
  788. case -ESHUTDOWN:
  789. /* this urb is terminated, clean up */
  790. dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
  791. __func__, status);
  792. return;
  793. default:
  794. dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
  795. __func__, status);
  796. goto exit;
  797. }
  798. usb_serial_debug_data(&port->dev, __func__,
  799. urb->actual_length, urb->transfer_buffer);
  800. pl2303_update_line_status(port, data, actual_length);
  801. exit:
  802. retval = usb_submit_urb(urb, GFP_ATOMIC);
  803. if (retval) {
  804. dev_err(&port->dev,
  805. "%s - usb_submit_urb failed with result %d\n",
  806. __func__, retval);
  807. }
  808. }
  809. static void pl2303_process_read_urb(struct urb *urb)
  810. {
  811. struct usb_serial_port *port = urb->context;
  812. struct pl2303_private *priv = usb_get_serial_port_data(port);
  813. unsigned char *data = urb->transfer_buffer;
  814. char tty_flag = TTY_NORMAL;
  815. unsigned long flags;
  816. u8 line_status;
  817. int i;
  818. /* update line status */
  819. spin_lock_irqsave(&priv->lock, flags);
  820. line_status = priv->line_status;
  821. priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
  822. spin_unlock_irqrestore(&priv->lock, flags);
  823. if (!urb->actual_length)
  824. return;
  825. /*
  826. * Break takes precedence over parity, which takes precedence over
  827. * framing errors.
  828. */
  829. if (line_status & UART_BREAK_ERROR)
  830. tty_flag = TTY_BREAK;
  831. else if (line_status & UART_PARITY_ERROR)
  832. tty_flag = TTY_PARITY;
  833. else if (line_status & UART_FRAME_ERROR)
  834. tty_flag = TTY_FRAME;
  835. if (tty_flag != TTY_NORMAL)
  836. dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
  837. tty_flag);
  838. /* overrun is special, not associated with a char */
  839. if (line_status & UART_OVERRUN_ERROR)
  840. tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
  841. if (port->port.console && port->sysrq) {
  842. for (i = 0; i < urb->actual_length; ++i)
  843. if (!usb_serial_handle_sysrq_char(port, data[i]))
  844. tty_insert_flip_char(&port->port, data[i],
  845. tty_flag);
  846. } else {
  847. tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
  848. urb->actual_length);
  849. }
  850. tty_flip_buffer_push(&port->port);
  851. }
  852. static struct usb_serial_driver pl2303_device = {
  853. .driver = {
  854. .owner = THIS_MODULE,
  855. .name = "pl2303",
  856. },
  857. .id_table = id_table,
  858. .num_bulk_in = 1,
  859. .num_bulk_out = 1,
  860. .num_interrupt_in = 0, /* see pl2303_calc_num_ports */
  861. .bulk_in_size = 256,
  862. .bulk_out_size = 256,
  863. .open = pl2303_open,
  864. .close = pl2303_close,
  865. .dtr_rts = pl2303_dtr_rts,
  866. .carrier_raised = pl2303_carrier_raised,
  867. .ioctl = pl2303_ioctl,
  868. .break_ctl = pl2303_break_ctl,
  869. .set_termios = pl2303_set_termios,
  870. .tiocmget = pl2303_tiocmget,
  871. .tiocmset = pl2303_tiocmset,
  872. .tiocmiwait = usb_serial_generic_tiocmiwait,
  873. .process_read_urb = pl2303_process_read_urb,
  874. .read_int_callback = pl2303_read_int_callback,
  875. .probe = pl2303_probe,
  876. .calc_num_ports = pl2303_calc_num_ports,
  877. .attach = pl2303_startup,
  878. .release = pl2303_release,
  879. .port_probe = pl2303_port_probe,
  880. .port_remove = pl2303_port_remove,
  881. };
  882. static struct usb_serial_driver * const serial_drivers[] = {
  883. &pl2303_device, NULL
  884. };
  885. module_usb_serial_driver(serial_drivers, id_table);
  886. MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
  887. MODULE_LICENSE("GPL v2");