pl2303.c 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158
  1. /*
  2. * Prolific PL2303 USB to serial adaptor driver
  3. *
  4. * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
  5. * Copyright (C) 2003 IBM Corp.
  6. *
  7. * Original driver for 2.2.x by anonymous
  8. *
  9. * This program is free software; you can redistribute it and/or
  10. * modify it under the terms of the GNU General Public License version
  11. * 2 as published by the Free Software Foundation.
  12. *
  13. * See Documentation/usb/usb-serial.txt for more information on using this driver
  14. *
  15. */
  16. #include <linux/kernel.h>
  17. #include <linux/errno.h>
  18. #include <linux/init.h>
  19. #include <linux/slab.h>
  20. #include <linux/tty.h>
  21. #include <linux/tty_driver.h>
  22. #include <linux/tty_flip.h>
  23. #include <linux/serial.h>
  24. #include <linux/module.h>
  25. #include <linux/moduleparam.h>
  26. #include <linux/spinlock.h>
  27. #include <asm/uaccess.h>
  28. #include <linux/usb.h>
  29. #include <linux/usb/serial.h>
  30. #include "pl2303.h"
  31. /*
  32. * Version Information
  33. */
  34. #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
  35. static int debug;
  36. #define PL2303_CLOSING_WAIT (30*HZ)
  37. #define PL2303_BUF_SIZE 1024
  38. #define PL2303_TMP_BUF_SIZE 1024
  39. struct pl2303_buf {
  40. unsigned int buf_size;
  41. char *buf_buf;
  42. char *buf_get;
  43. char *buf_put;
  44. };
  45. static struct usb_device_id id_table [] = {
  46. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
  47. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
  48. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
  49. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
  50. { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
  51. { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
  52. { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
  53. { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
  54. { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
  55. { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
  56. { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
  57. { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
  58. { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
  59. { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
  60. { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
  61. { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
  62. { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
  63. { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
  64. { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
  65. { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
  66. { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
  67. { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
  68. { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
  69. { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
  70. { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
  71. { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
  72. { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
  73. { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
  74. { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
  75. { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
  76. { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
  77. { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
  78. { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
  79. { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
  80. { USB_DEVICE(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_ID) },
  81. { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
  82. { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
  83. { } /* Terminating entry */
  84. };
  85. MODULE_DEVICE_TABLE(usb, id_table);
  86. static struct usb_driver pl2303_driver = {
  87. .name = "pl2303",
  88. .probe = usb_serial_probe,
  89. .disconnect = usb_serial_disconnect,
  90. .id_table = id_table,
  91. .no_dynamic_id = 1,
  92. };
  93. #define SET_LINE_REQUEST_TYPE 0x21
  94. #define SET_LINE_REQUEST 0x20
  95. #define SET_CONTROL_REQUEST_TYPE 0x21
  96. #define SET_CONTROL_REQUEST 0x22
  97. #define CONTROL_DTR 0x01
  98. #define CONTROL_RTS 0x02
  99. #define BREAK_REQUEST_TYPE 0x21
  100. #define BREAK_REQUEST 0x23
  101. #define BREAK_ON 0xffff
  102. #define BREAK_OFF 0x0000
  103. #define GET_LINE_REQUEST_TYPE 0xa1
  104. #define GET_LINE_REQUEST 0x21
  105. #define VENDOR_WRITE_REQUEST_TYPE 0x40
  106. #define VENDOR_WRITE_REQUEST 0x01
  107. #define VENDOR_READ_REQUEST_TYPE 0xc0
  108. #define VENDOR_READ_REQUEST 0x01
  109. #define UART_STATE 0x08
  110. #define UART_STATE_TRANSIENT_MASK 0x74
  111. #define UART_DCD 0x01
  112. #define UART_DSR 0x02
  113. #define UART_BREAK_ERROR 0x04
  114. #define UART_RING 0x08
  115. #define UART_FRAME_ERROR 0x10
  116. #define UART_PARITY_ERROR 0x20
  117. #define UART_OVERRUN_ERROR 0x40
  118. #define UART_CTS 0x80
  119. enum pl2303_type {
  120. type_0, /* don't know the difference between type 0 and */
  121. type_1, /* type 1, until someone from prolific tells us... */
  122. HX, /* HX version of the pl2303 chip */
  123. };
  124. struct pl2303_private {
  125. spinlock_t lock;
  126. struct pl2303_buf *buf;
  127. int write_urb_in_use;
  128. wait_queue_head_t delta_msr_wait;
  129. u8 line_control;
  130. u8 line_status;
  131. u8 termios_initialized;
  132. enum pl2303_type type;
  133. };
  134. /*
  135. * pl2303_buf_alloc
  136. *
  137. * Allocate a circular buffer and all associated memory.
  138. */
  139. static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
  140. {
  141. struct pl2303_buf *pb;
  142. if (size == 0)
  143. return NULL;
  144. pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
  145. if (pb == NULL)
  146. return NULL;
  147. pb->buf_buf = kmalloc(size, GFP_KERNEL);
  148. if (pb->buf_buf == NULL) {
  149. kfree(pb);
  150. return NULL;
  151. }
  152. pb->buf_size = size;
  153. pb->buf_get = pb->buf_put = pb->buf_buf;
  154. return pb;
  155. }
  156. /*
  157. * pl2303_buf_free
  158. *
  159. * Free the buffer and all associated memory.
  160. */
  161. static void pl2303_buf_free(struct pl2303_buf *pb)
  162. {
  163. if (pb) {
  164. kfree(pb->buf_buf);
  165. kfree(pb);
  166. }
  167. }
  168. /*
  169. * pl2303_buf_clear
  170. *
  171. * Clear out all data in the circular buffer.
  172. */
  173. static void pl2303_buf_clear(struct pl2303_buf *pb)
  174. {
  175. if (pb != NULL)
  176. pb->buf_get = pb->buf_put;
  177. /* equivalent to a get of all data available */
  178. }
  179. /*
  180. * pl2303_buf_data_avail
  181. *
  182. * Return the number of bytes of data available in the circular
  183. * buffer.
  184. */
  185. static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
  186. {
  187. if (pb == NULL)
  188. return 0;
  189. return ((pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size);
  190. }
  191. /*
  192. * pl2303_buf_space_avail
  193. *
  194. * Return the number of bytes of space available in the circular
  195. * buffer.
  196. */
  197. static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
  198. {
  199. if (pb == NULL)
  200. return 0;
  201. return ((pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size);
  202. }
  203. /*
  204. * pl2303_buf_put
  205. *
  206. * Copy data data from a user buffer and put it into the circular buffer.
  207. * Restrict to the amount of space available.
  208. *
  209. * Return the number of bytes copied.
  210. */
  211. static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
  212. unsigned int count)
  213. {
  214. unsigned int len;
  215. if (pb == NULL)
  216. return 0;
  217. len = pl2303_buf_space_avail(pb);
  218. if (count > len)
  219. count = len;
  220. if (count == 0)
  221. return 0;
  222. len = pb->buf_buf + pb->buf_size - pb->buf_put;
  223. if (count > len) {
  224. memcpy(pb->buf_put, buf, len);
  225. memcpy(pb->buf_buf, buf+len, count - len);
  226. pb->buf_put = pb->buf_buf + count - len;
  227. } else {
  228. memcpy(pb->buf_put, buf, count);
  229. if (count < len)
  230. pb->buf_put += count;
  231. else /* count == len */
  232. pb->buf_put = pb->buf_buf;
  233. }
  234. return count;
  235. }
  236. /*
  237. * pl2303_buf_get
  238. *
  239. * Get data from the circular buffer and copy to the given buffer.
  240. * Restrict to the amount of data available.
  241. *
  242. * Return the number of bytes copied.
  243. */
  244. static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
  245. unsigned int count)
  246. {
  247. unsigned int len;
  248. if (pb == NULL)
  249. return 0;
  250. len = pl2303_buf_data_avail(pb);
  251. if (count > len)
  252. count = len;
  253. if (count == 0)
  254. return 0;
  255. len = pb->buf_buf + pb->buf_size - pb->buf_get;
  256. if (count > len) {
  257. memcpy(buf, pb->buf_get, len);
  258. memcpy(buf+len, pb->buf_buf, count - len);
  259. pb->buf_get = pb->buf_buf + count - len;
  260. } else {
  261. memcpy(buf, pb->buf_get, count);
  262. if (count < len)
  263. pb->buf_get += count;
  264. else /* count == len */
  265. pb->buf_get = pb->buf_buf;
  266. }
  267. return count;
  268. }
  269. static int pl2303_startup(struct usb_serial *serial)
  270. {
  271. struct pl2303_private *priv;
  272. enum pl2303_type type = type_0;
  273. int i;
  274. if (serial->dev->descriptor.bDeviceClass == 0x02)
  275. type = type_0;
  276. else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
  277. type = HX;
  278. else if (serial->dev->descriptor.bDeviceClass == 0x00)
  279. type = type_1;
  280. else if (serial->dev->descriptor.bDeviceClass == 0xFF)
  281. type = type_1;
  282. dbg("device type: %d", type);
  283. for (i = 0; i < serial->num_ports; ++i) {
  284. priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
  285. if (!priv)
  286. goto cleanup;
  287. spin_lock_init(&priv->lock);
  288. priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
  289. if (priv->buf == NULL) {
  290. kfree(priv);
  291. goto cleanup;
  292. }
  293. init_waitqueue_head(&priv->delta_msr_wait);
  294. priv->type = type;
  295. usb_set_serial_port_data(serial->port[i], priv);
  296. }
  297. return 0;
  298. cleanup:
  299. for (--i; i>=0; --i) {
  300. priv = usb_get_serial_port_data(serial->port[i]);
  301. pl2303_buf_free(priv->buf);
  302. kfree(priv);
  303. usb_set_serial_port_data(serial->port[i], NULL);
  304. }
  305. return -ENOMEM;
  306. }
  307. static int set_control_lines(struct usb_device *dev, u8 value)
  308. {
  309. int retval;
  310. retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  311. SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
  312. value, 0, NULL, 0, 100);
  313. dbg("%s - value = %d, retval = %d", __FUNCTION__, value, retval);
  314. return retval;
  315. }
  316. static void pl2303_send(struct usb_serial_port *port)
  317. {
  318. int count, result;
  319. struct pl2303_private *priv = usb_get_serial_port_data(port);
  320. unsigned long flags;
  321. dbg("%s - port %d", __FUNCTION__, port->number);
  322. spin_lock_irqsave(&priv->lock, flags);
  323. if (priv->write_urb_in_use) {
  324. spin_unlock_irqrestore(&priv->lock, flags);
  325. return;
  326. }
  327. count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
  328. port->bulk_out_size);
  329. if (count == 0) {
  330. spin_unlock_irqrestore(&priv->lock, flags);
  331. return;
  332. }
  333. priv->write_urb_in_use = 1;
  334. spin_unlock_irqrestore(&priv->lock, flags);
  335. usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count,
  336. port->write_urb->transfer_buffer);
  337. port->write_urb->transfer_buffer_length = count;
  338. port->write_urb->dev = port->serial->dev;
  339. result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
  340. if (result) {
  341. dev_err(&port->dev, "%s - failed submitting write urb,"
  342. " error %d\n", __FUNCTION__, result);
  343. priv->write_urb_in_use = 0;
  344. // TODO: reschedule pl2303_send
  345. }
  346. usb_serial_port_softint(port);
  347. }
  348. static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,
  349. int count)
  350. {
  351. struct pl2303_private *priv = usb_get_serial_port_data(port);
  352. unsigned long flags;
  353. dbg("%s - port %d, %d bytes", __FUNCTION__, port->number, count);
  354. if (!count)
  355. return count;
  356. spin_lock_irqsave(&priv->lock, flags);
  357. count = pl2303_buf_put(priv->buf, buf, count);
  358. spin_unlock_irqrestore(&priv->lock, flags);
  359. pl2303_send(port);
  360. return count;
  361. }
  362. static int pl2303_write_room(struct usb_serial_port *port)
  363. {
  364. struct pl2303_private *priv = usb_get_serial_port_data(port);
  365. int room = 0;
  366. unsigned long flags;
  367. dbg("%s - port %d", __FUNCTION__, port->number);
  368. spin_lock_irqsave(&priv->lock, flags);
  369. room = pl2303_buf_space_avail(priv->buf);
  370. spin_unlock_irqrestore(&priv->lock, flags);
  371. dbg("%s - returns %d", __FUNCTION__, room);
  372. return room;
  373. }
  374. static int pl2303_chars_in_buffer(struct usb_serial_port *port)
  375. {
  376. struct pl2303_private *priv = usb_get_serial_port_data(port);
  377. int chars = 0;
  378. unsigned long flags;
  379. dbg("%s - port %d", __FUNCTION__, port->number);
  380. spin_lock_irqsave(&priv->lock, flags);
  381. chars = pl2303_buf_data_avail(priv->buf);
  382. spin_unlock_irqrestore(&priv->lock, flags);
  383. dbg("%s - returns %d", __FUNCTION__, chars);
  384. return chars;
  385. }
  386. static void pl2303_set_termios(struct usb_serial_port *port,
  387. struct ktermios *old_termios)
  388. {
  389. struct usb_serial *serial = port->serial;
  390. struct pl2303_private *priv = usb_get_serial_port_data(port);
  391. unsigned long flags;
  392. unsigned int cflag;
  393. unsigned char *buf;
  394. int baud;
  395. int i;
  396. u8 control;
  397. dbg("%s - port %d", __FUNCTION__, port->number);
  398. spin_lock_irqsave(&priv->lock, flags);
  399. if (!priv->termios_initialized) {
  400. *(port->tty->termios) = tty_std_termios;
  401. port->tty->termios->c_cflag = B9600 | CS8 | CREAD |
  402. HUPCL | CLOCAL;
  403. port->tty->termios->c_ispeed = 9600;
  404. port->tty->termios->c_ospeed = 9600;
  405. priv->termios_initialized = 1;
  406. }
  407. spin_unlock_irqrestore(&priv->lock, flags);
  408. cflag = port->tty->termios->c_cflag;
  409. buf = kzalloc(7, GFP_KERNEL);
  410. if (!buf) {
  411. dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
  412. return;
  413. }
  414. i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
  415. GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
  416. 0, 0, buf, 7, 100);
  417. dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
  418. buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
  419. if (cflag & CSIZE) {
  420. switch (cflag & CSIZE) {
  421. case CS5: buf[6] = 5; break;
  422. case CS6: buf[6] = 6; break;
  423. case CS7: buf[6] = 7; break;
  424. default:
  425. case CS8: buf[6] = 8; break;
  426. }
  427. dbg("%s - data bits = %d", __FUNCTION__, buf[6]);
  428. }
  429. baud = tty_get_baud_rate(port->tty);;
  430. dbg("%s - baud = %d", __FUNCTION__, baud);
  431. if (baud) {
  432. buf[0] = baud & 0xff;
  433. buf[1] = (baud >> 8) & 0xff;
  434. buf[2] = (baud >> 16) & 0xff;
  435. buf[3] = (baud >> 24) & 0xff;
  436. }
  437. /* For reference buf[4]=0 is 1 stop bits */
  438. /* For reference buf[4]=1 is 1.5 stop bits */
  439. /* For reference buf[4]=2 is 2 stop bits */
  440. if (cflag & CSTOPB) {
  441. buf[4] = 2;
  442. dbg("%s - stop bits = 2", __FUNCTION__);
  443. } else {
  444. buf[4] = 0;
  445. dbg("%s - stop bits = 1", __FUNCTION__);
  446. }
  447. if (cflag & PARENB) {
  448. /* For reference buf[5]=0 is none parity */
  449. /* For reference buf[5]=1 is odd parity */
  450. /* For reference buf[5]=2 is even parity */
  451. /* For reference buf[5]=3 is mark parity */
  452. /* For reference buf[5]=4 is space parity */
  453. if (cflag & PARODD) {
  454. buf[5] = 1;
  455. dbg("%s - parity = odd", __FUNCTION__);
  456. } else {
  457. buf[5] = 2;
  458. dbg("%s - parity = even", __FUNCTION__);
  459. }
  460. } else {
  461. buf[5] = 0;
  462. dbg("%s - parity = none", __FUNCTION__);
  463. }
  464. i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
  465. SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
  466. 0, 0, buf, 7, 100);
  467. dbg("0x21:0x20:0:0 %d", i);
  468. /* change control lines if we are switching to or from B0 */
  469. spin_lock_irqsave(&priv->lock, flags);
  470. control = priv->line_control;
  471. if ((cflag & CBAUD) == B0)
  472. priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
  473. else
  474. priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
  475. if (control != priv->line_control) {
  476. control = priv->line_control;
  477. spin_unlock_irqrestore(&priv->lock, flags);
  478. set_control_lines(serial->dev, control);
  479. } else {
  480. spin_unlock_irqrestore(&priv->lock, flags);
  481. }
  482. buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
  483. i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
  484. GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
  485. 0, 0, buf, 7, 100);
  486. dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
  487. buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
  488. if (cflag & CRTSCTS) {
  489. __u16 index;
  490. if (priv->type == HX)
  491. index = 0x61;
  492. else
  493. index = 0x41;
  494. i = usb_control_msg(serial->dev,
  495. usb_sndctrlpipe(serial->dev, 0),
  496. VENDOR_WRITE_REQUEST,
  497. VENDOR_WRITE_REQUEST_TYPE,
  498. 0x0, index, NULL, 0, 100);
  499. dbg("0x40:0x1:0x0:0x%x %d", index, i);
  500. } else {
  501. i = usb_control_msg(serial->dev,
  502. usb_sndctrlpipe(serial->dev, 0),
  503. VENDOR_WRITE_REQUEST,
  504. VENDOR_WRITE_REQUEST_TYPE,
  505. 0x0, 0x0, NULL, 0, 100);
  506. dbg ("0x40:0x1:0x0:0x0 %d", i);
  507. }
  508. /* FIXME: Need to read back resulting baud rate */
  509. if (baud)
  510. tty_encode_baud_rate(port->tty, baud, baud);
  511. kfree(buf);
  512. }
  513. static void pl2303_close(struct usb_serial_port *port, struct file *filp)
  514. {
  515. struct pl2303_private *priv = usb_get_serial_port_data(port);
  516. unsigned long flags;
  517. unsigned int c_cflag;
  518. int bps;
  519. long timeout;
  520. wait_queue_t wait;
  521. dbg("%s - port %d", __FUNCTION__, port->number);
  522. /* wait for data to drain from the buffer */
  523. spin_lock_irqsave(&priv->lock, flags);
  524. timeout = PL2303_CLOSING_WAIT;
  525. init_waitqueue_entry(&wait, current);
  526. add_wait_queue(&port->tty->write_wait, &wait);
  527. for (;;) {
  528. set_current_state(TASK_INTERRUPTIBLE);
  529. if (pl2303_buf_data_avail(priv->buf) == 0 ||
  530. timeout == 0 || signal_pending(current) ||
  531. !usb_get_intfdata(port->serial->interface)) /* disconnect */
  532. break;
  533. spin_unlock_irqrestore(&priv->lock, flags);
  534. timeout = schedule_timeout(timeout);
  535. spin_lock_irqsave(&priv->lock, flags);
  536. }
  537. set_current_state(TASK_RUNNING);
  538. remove_wait_queue(&port->tty->write_wait, &wait);
  539. /* clear out any remaining data in the buffer */
  540. pl2303_buf_clear(priv->buf);
  541. spin_unlock_irqrestore(&priv->lock, flags);
  542. /* wait for characters to drain from the device */
  543. /* (this is long enough for the entire 256 byte */
  544. /* pl2303 hardware buffer to drain with no flow */
  545. /* control for data rates of 1200 bps or more, */
  546. /* for lower rates we should really know how much */
  547. /* data is in the buffer to compute a delay */
  548. /* that is not unnecessarily long) */
  549. bps = tty_get_baud_rate(port->tty);
  550. if (bps > 1200)
  551. timeout = max((HZ*2560)/bps,HZ/10);
  552. else
  553. timeout = 2*HZ;
  554. schedule_timeout_interruptible(timeout);
  555. /* shutdown our urbs */
  556. dbg("%s - shutting down urbs", __FUNCTION__);
  557. usb_kill_urb(port->write_urb);
  558. usb_kill_urb(port->read_urb);
  559. usb_kill_urb(port->interrupt_in_urb);
  560. if (port->tty) {
  561. c_cflag = port->tty->termios->c_cflag;
  562. if (c_cflag & HUPCL) {
  563. /* drop DTR and RTS */
  564. spin_lock_irqsave(&priv->lock, flags);
  565. priv->line_control = 0;
  566. spin_unlock_irqrestore(&priv->lock, flags);
  567. set_control_lines(port->serial->dev, 0);
  568. }
  569. }
  570. }
  571. static int pl2303_open(struct usb_serial_port *port, struct file *filp)
  572. {
  573. struct ktermios tmp_termios;
  574. struct usb_serial *serial = port->serial;
  575. struct pl2303_private *priv = usb_get_serial_port_data(port);
  576. unsigned char *buf;
  577. int result;
  578. dbg("%s - port %d", __FUNCTION__, port->number);
  579. if (priv->type != HX) {
  580. usb_clear_halt(serial->dev, port->write_urb->pipe);
  581. usb_clear_halt(serial->dev, port->read_urb->pipe);
  582. }
  583. buf = kmalloc(10, GFP_KERNEL);
  584. if (buf==NULL)
  585. return -ENOMEM;
  586. #define FISH(a,b,c,d) \
  587. result=usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev,0), \
  588. b, a, c, d, buf, 1, 100); \
  589. dbg("0x%x:0x%x:0x%x:0x%x %d - %x",a,b,c,d,result,buf[0]);
  590. #define SOUP(a,b,c,d) \
  591. result=usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev,0), \
  592. b, a, c, d, NULL, 0, 100); \
  593. dbg("0x%x:0x%x:0x%x:0x%x %d",a,b,c,d,result);
  594. FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
  595. SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 0);
  596. FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
  597. FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
  598. FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
  599. SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 1);
  600. FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
  601. FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
  602. SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0, 1);
  603. SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 1, 0);
  604. if (priv->type == HX) {
  605. /* HX chip */
  606. SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x44);
  607. /* reset upstream data pipes */
  608. SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 8, 0);
  609. SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 9, 0);
  610. } else {
  611. SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x24);
  612. }
  613. kfree(buf);
  614. /* Setup termios */
  615. if (port->tty) {
  616. pl2303_set_termios(port, &tmp_termios);
  617. }
  618. //FIXME: need to assert RTS and DTR if CRTSCTS off
  619. dbg("%s - submitting read urb", __FUNCTION__);
  620. port->read_urb->dev = serial->dev;
  621. result = usb_submit_urb(port->read_urb, GFP_KERNEL);
  622. if (result) {
  623. dev_err(&port->dev, "%s - failed submitting read urb,"
  624. " error %d\n", __FUNCTION__, result);
  625. pl2303_close(port, NULL);
  626. return -EPROTO;
  627. }
  628. dbg("%s - submitting interrupt urb", __FUNCTION__);
  629. port->interrupt_in_urb->dev = serial->dev;
  630. result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
  631. if (result) {
  632. dev_err(&port->dev, "%s - failed submitting interrupt urb,"
  633. " error %d\n", __FUNCTION__, result);
  634. pl2303_close(port, NULL);
  635. return -EPROTO;
  636. }
  637. return 0;
  638. }
  639. static int pl2303_tiocmset(struct usb_serial_port *port, struct file *file,
  640. unsigned int set, unsigned int clear)
  641. {
  642. struct pl2303_private *priv = usb_get_serial_port_data(port);
  643. unsigned long flags;
  644. u8 control;
  645. if (!usb_get_intfdata(port->serial->interface))
  646. return -ENODEV;
  647. spin_lock_irqsave(&priv->lock, flags);
  648. if (set & TIOCM_RTS)
  649. priv->line_control |= CONTROL_RTS;
  650. if (set & TIOCM_DTR)
  651. priv->line_control |= CONTROL_DTR;
  652. if (clear & TIOCM_RTS)
  653. priv->line_control &= ~CONTROL_RTS;
  654. if (clear & TIOCM_DTR)
  655. priv->line_control &= ~CONTROL_DTR;
  656. control = priv->line_control;
  657. spin_unlock_irqrestore(&priv->lock, flags);
  658. return set_control_lines(port->serial->dev, control);
  659. }
  660. static int pl2303_tiocmget(struct usb_serial_port *port, struct file *file)
  661. {
  662. struct pl2303_private *priv = usb_get_serial_port_data(port);
  663. unsigned long flags;
  664. unsigned int mcr;
  665. unsigned int status;
  666. unsigned int result;
  667. dbg("%s (%d)", __FUNCTION__, port->number);
  668. if (!usb_get_intfdata(port->serial->interface))
  669. return -ENODEV;
  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. dbg("%s - result = %x", __FUNCTION__, result);
  681. return result;
  682. }
  683. static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
  684. {
  685. struct pl2303_private *priv = usb_get_serial_port_data(port);
  686. unsigned long flags;
  687. unsigned int prevstatus;
  688. unsigned int status;
  689. unsigned int changed;
  690. spin_lock_irqsave(&priv->lock, flags);
  691. prevstatus = priv->line_status;
  692. spin_unlock_irqrestore(&priv->lock, flags);
  693. while (1) {
  694. interruptible_sleep_on(&priv->delta_msr_wait);
  695. /* see if a signal did it */
  696. if (signal_pending(current))
  697. return -ERESTARTSYS;
  698. spin_lock_irqsave(&priv->lock, flags);
  699. status = priv->line_status;
  700. spin_unlock_irqrestore(&priv->lock, flags);
  701. changed=prevstatus^status;
  702. if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
  703. ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
  704. ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
  705. ((arg & TIOCM_CTS) && (changed & UART_CTS)) ) {
  706. return 0;
  707. }
  708. prevstatus = status;
  709. }
  710. /* NOTREACHED */
  711. return 0;
  712. }
  713. static int pl2303_ioctl(struct usb_serial_port *port, struct file *file,
  714. unsigned int cmd, unsigned long arg)
  715. {
  716. dbg("%s (%d) cmd = 0x%04x", __FUNCTION__, port->number, cmd);
  717. switch (cmd) {
  718. case TIOCMIWAIT:
  719. dbg("%s (%d) TIOCMIWAIT", __FUNCTION__, port->number);
  720. return wait_modem_info(port, arg);
  721. default:
  722. dbg("%s not supported = 0x%04x", __FUNCTION__, cmd);
  723. break;
  724. }
  725. return -ENOIOCTLCMD;
  726. }
  727. static void pl2303_break_ctl(struct usb_serial_port *port, int break_state)
  728. {
  729. struct usb_serial *serial = port->serial;
  730. u16 state;
  731. int result;
  732. dbg("%s - port %d", __FUNCTION__, port->number);
  733. if (break_state == 0)
  734. state = BREAK_OFF;
  735. else
  736. state = BREAK_ON;
  737. dbg("%s - turning break %s", __FUNCTION__, state==BREAK_OFF ? "off" : "on");
  738. result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
  739. BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
  740. 0, NULL, 0, 100);
  741. if (result)
  742. dbg("%s - error sending break = %d", __FUNCTION__, result);
  743. }
  744. static void pl2303_shutdown(struct usb_serial *serial)
  745. {
  746. int i;
  747. struct pl2303_private *priv;
  748. dbg("%s", __FUNCTION__);
  749. for (i = 0; i < serial->num_ports; ++i) {
  750. priv = usb_get_serial_port_data(serial->port[i]);
  751. if (priv) {
  752. pl2303_buf_free(priv->buf);
  753. kfree(priv);
  754. usb_set_serial_port_data(serial->port[i], NULL);
  755. }
  756. }
  757. }
  758. static void pl2303_update_line_status(struct usb_serial_port *port,
  759. unsigned char *data,
  760. unsigned int actual_length)
  761. {
  762. struct pl2303_private *priv = usb_get_serial_port_data(port);
  763. unsigned long flags;
  764. u8 status_idx = UART_STATE;
  765. u8 length = UART_STATE + 1;
  766. u16 idv, idp;
  767. idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
  768. idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
  769. if (idv == SIEMENS_VENDOR_ID) {
  770. if (idp == SIEMENS_PRODUCT_ID_X65 ||
  771. idp == SIEMENS_PRODUCT_ID_SX1 ||
  772. idp == SIEMENS_PRODUCT_ID_X75) {
  773. length = 1;
  774. status_idx = 0;
  775. }
  776. }
  777. if (actual_length < length)
  778. return;
  779. /* Save off the uart status for others to look at */
  780. spin_lock_irqsave(&priv->lock, flags);
  781. priv->line_status = data[status_idx];
  782. spin_unlock_irqrestore(&priv->lock, flags);
  783. wake_up_interruptible(&priv->delta_msr_wait);
  784. }
  785. static void pl2303_read_int_callback(struct urb *urb)
  786. {
  787. struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
  788. unsigned char *data = urb->transfer_buffer;
  789. unsigned int actual_length = urb->actual_length;
  790. int status = urb->status;
  791. int retval;
  792. dbg("%s (%d)", __FUNCTION__, port->number);
  793. switch (status) {
  794. case 0:
  795. /* success */
  796. break;
  797. case -ECONNRESET:
  798. case -ENOENT:
  799. case -ESHUTDOWN:
  800. /* this urb is terminated, clean up */
  801. dbg("%s - urb shutting down with status: %d", __FUNCTION__,
  802. status);
  803. return;
  804. default:
  805. dbg("%s - nonzero urb status received: %d", __FUNCTION__,
  806. status);
  807. goto exit;
  808. }
  809. usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
  810. urb->actual_length, urb->transfer_buffer);
  811. pl2303_update_line_status(port, data, actual_length);
  812. exit:
  813. retval = usb_submit_urb(urb, GFP_ATOMIC);
  814. if (retval)
  815. dev_err(&urb->dev->dev,
  816. "%s - usb_submit_urb failed with result %d\n",
  817. __FUNCTION__, retval);
  818. }
  819. static void pl2303_read_bulk_callback(struct urb *urb)
  820. {
  821. struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
  822. struct pl2303_private *priv = usb_get_serial_port_data(port);
  823. struct tty_struct *tty;
  824. unsigned char *data = urb->transfer_buffer;
  825. unsigned long flags;
  826. int i;
  827. int result;
  828. int status = urb->status;
  829. u8 line_status;
  830. char tty_flag;
  831. dbg("%s - port %d", __FUNCTION__, port->number);
  832. if (status) {
  833. dbg("%s - urb status = %d", __FUNCTION__, status);
  834. if (!port->open_count) {
  835. dbg("%s - port is closed, exiting.", __FUNCTION__);
  836. return;
  837. }
  838. if (status == -EPROTO) {
  839. /* PL2303 mysteriously fails with -EPROTO reschedule
  840. * the read */
  841. dbg("%s - caught -EPROTO, resubmitting the urb",
  842. __FUNCTION__);
  843. urb->dev = port->serial->dev;
  844. result = usb_submit_urb(urb, GFP_ATOMIC);
  845. if (result)
  846. dev_err(&urb->dev->dev, "%s - failed"
  847. " resubmitting read urb, error %d\n",
  848. __FUNCTION__, result);
  849. return;
  850. }
  851. dbg("%s - unable to handle the error, exiting.", __FUNCTION__);
  852. return;
  853. }
  854. usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
  855. urb->actual_length, data);
  856. /* get tty_flag from status */
  857. tty_flag = TTY_NORMAL;
  858. spin_lock_irqsave(&priv->lock, flags);
  859. line_status = priv->line_status;
  860. priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
  861. spin_unlock_irqrestore(&priv->lock, flags);
  862. wake_up_interruptible(&priv->delta_msr_wait);
  863. /* break takes precedence over parity, */
  864. /* which takes precedence over framing errors */
  865. if (line_status & UART_BREAK_ERROR )
  866. tty_flag = TTY_BREAK;
  867. else if (line_status & UART_PARITY_ERROR)
  868. tty_flag = TTY_PARITY;
  869. else if (line_status & UART_FRAME_ERROR)
  870. tty_flag = TTY_FRAME;
  871. dbg("%s - tty_flag = %d", __FUNCTION__, tty_flag);
  872. tty = port->tty;
  873. if (tty && urb->actual_length) {
  874. tty_buffer_request_room(tty, urb->actual_length + 1);
  875. /* overrun is special, not associated with a char */
  876. if (line_status & UART_OVERRUN_ERROR)
  877. tty_insert_flip_char(tty, 0, TTY_OVERRUN);
  878. for (i = 0; i < urb->actual_length; ++i)
  879. tty_insert_flip_char(tty, data[i], tty_flag);
  880. tty_flip_buffer_push(tty);
  881. }
  882. /* Schedule the next read _if_ we are still open */
  883. if (port->open_count) {
  884. urb->dev = port->serial->dev;
  885. result = usb_submit_urb(urb, GFP_ATOMIC);
  886. if (result)
  887. dev_err(&urb->dev->dev, "%s - failed resubmitting"
  888. " read urb, error %d\n", __FUNCTION__, result);
  889. }
  890. return;
  891. }
  892. static void pl2303_write_bulk_callback(struct urb *urb)
  893. {
  894. struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
  895. struct pl2303_private *priv = usb_get_serial_port_data(port);
  896. int result;
  897. int status = urb->status;
  898. dbg("%s - port %d", __FUNCTION__, port->number);
  899. switch (status) {
  900. case 0:
  901. /* success */
  902. break;
  903. case -ECONNRESET:
  904. case -ENOENT:
  905. case -ESHUTDOWN:
  906. /* this urb is terminated, clean up */
  907. dbg("%s - urb shutting down with status: %d", __FUNCTION__,
  908. status);
  909. priv->write_urb_in_use = 0;
  910. return;
  911. default:
  912. /* error in the urb, so we have to resubmit it */
  913. dbg("%s - Overflow in write", __FUNCTION__);
  914. dbg("%s - nonzero write bulk status received: %d", __FUNCTION__,
  915. status);
  916. port->write_urb->transfer_buffer_length = 1;
  917. port->write_urb->dev = port->serial->dev;
  918. result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
  919. if (result)
  920. dev_err(&urb->dev->dev, "%s - failed resubmitting write"
  921. " urb, error %d\n", __FUNCTION__, result);
  922. else
  923. return;
  924. }
  925. priv->write_urb_in_use = 0;
  926. /* send any buffered data */
  927. pl2303_send(port);
  928. }
  929. /* All of the device info needed for the PL2303 SIO serial converter */
  930. static struct usb_serial_driver pl2303_device = {
  931. .driver = {
  932. .owner = THIS_MODULE,
  933. .name = "pl2303",
  934. },
  935. .id_table = id_table,
  936. .usb_driver = &pl2303_driver,
  937. .num_interrupt_in = NUM_DONT_CARE,
  938. .num_bulk_in = 1,
  939. .num_bulk_out = 1,
  940. .num_ports = 1,
  941. .open = pl2303_open,
  942. .close = pl2303_close,
  943. .write = pl2303_write,
  944. .ioctl = pl2303_ioctl,
  945. .break_ctl = pl2303_break_ctl,
  946. .set_termios = pl2303_set_termios,
  947. .tiocmget = pl2303_tiocmget,
  948. .tiocmset = pl2303_tiocmset,
  949. .read_bulk_callback = pl2303_read_bulk_callback,
  950. .read_int_callback = pl2303_read_int_callback,
  951. .write_bulk_callback = pl2303_write_bulk_callback,
  952. .write_room = pl2303_write_room,
  953. .chars_in_buffer = pl2303_chars_in_buffer,
  954. .attach = pl2303_startup,
  955. .shutdown = pl2303_shutdown,
  956. };
  957. static int __init pl2303_init(void)
  958. {
  959. int retval;
  960. retval = usb_serial_register(&pl2303_device);
  961. if (retval)
  962. goto failed_usb_serial_register;
  963. retval = usb_register(&pl2303_driver);
  964. if (retval)
  965. goto failed_usb_register;
  966. info(DRIVER_DESC);
  967. return 0;
  968. failed_usb_register:
  969. usb_serial_deregister(&pl2303_device);
  970. failed_usb_serial_register:
  971. return retval;
  972. }
  973. static void __exit pl2303_exit(void)
  974. {
  975. usb_deregister(&pl2303_driver);
  976. usb_serial_deregister(&pl2303_device);
  977. }
  978. module_init(pl2303_init);
  979. module_exit(pl2303_exit);
  980. MODULE_DESCRIPTION(DRIVER_DESC);
  981. MODULE_LICENSE("GPL");
  982. module_param(debug, bool, S_IRUGO | S_IWUSR);
  983. MODULE_PARM_DESC(debug, "Debug enabled or not");