ssu100.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * usb-serial driver for Quatech SSU-100
  4. *
  5. * based on ftdi_sio.c and the original serqt_usb.c from Quatech
  6. *
  7. */
  8. #include <linux/errno.h>
  9. #include <linux/slab.h>
  10. #include <linux/tty.h>
  11. #include <linux/tty_driver.h>
  12. #include <linux/tty_flip.h>
  13. #include <linux/module.h>
  14. #include <linux/serial.h>
  15. #include <linux/usb.h>
  16. #include <linux/usb/serial.h>
  17. #include <linux/serial_reg.h>
  18. #include <linux/uaccess.h>
  19. #define QT_OPEN_CLOSE_CHANNEL 0xca
  20. #define QT_SET_GET_DEVICE 0xc2
  21. #define QT_SET_GET_REGISTER 0xc0
  22. #define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
  23. #define QT_SET_ATF 0xcd
  24. #define QT_GET_SET_UART 0xc1
  25. #define QT_TRANSFER_IN 0xc0
  26. #define QT_HW_FLOW_CONTROL_MASK 0xc5
  27. #define QT_SW_FLOW_CONTROL_MASK 0xc6
  28. #define SERIAL_MSR_MASK 0xf0
  29. #define SERIAL_CRTSCTS ((UART_MCR_RTS << 8) | UART_MSR_CTS)
  30. #define SERIAL_EVEN_PARITY (UART_LCR_PARITY | UART_LCR_EPAR)
  31. #define MAX_BAUD_RATE 460800
  32. #define ATC_DISABLED 0x00
  33. #define DUPMODE_BITS 0xc0
  34. #define RR_BITS 0x03
  35. #define LOOPMODE_BITS 0x41
  36. #define RS232_MODE 0x00
  37. #define RTSCTS_TO_CONNECTOR 0x40
  38. #define CLKS_X4 0x02
  39. #define FULLPWRBIT 0x00000080
  40. #define NEXT_BOARD_POWER_BIT 0x00000004
  41. #define DRIVER_DESC "Quatech SSU-100 USB to Serial Driver"
  42. #define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */
  43. #define QUATECH_SSU100 0xC020 /* SSU100 */
  44. static const struct usb_device_id id_table[] = {
  45. {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU100)},
  46. {} /* Terminating entry */
  47. };
  48. MODULE_DEVICE_TABLE(usb, id_table);
  49. struct ssu100_port_private {
  50. spinlock_t status_lock;
  51. u8 shadowLSR;
  52. u8 shadowMSR;
  53. };
  54. static inline int ssu100_control_msg(struct usb_device *dev,
  55. u8 request, u16 data, u16 index)
  56. {
  57. return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  58. request, 0x40, data, index,
  59. NULL, 0, 300);
  60. }
  61. static inline int ssu100_setdevice(struct usb_device *dev, u8 *data)
  62. {
  63. u16 x = ((u16)(data[1] << 8) | (u16)(data[0]));
  64. return ssu100_control_msg(dev, QT_SET_GET_DEVICE, x, 0);
  65. }
  66. static inline int ssu100_getdevice(struct usb_device *dev, u8 *data)
  67. {
  68. int ret;
  69. ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  70. QT_SET_GET_DEVICE, 0xc0, 0, 0,
  71. data, 3, 300);
  72. if (ret < 3) {
  73. if (ret >= 0)
  74. ret = -EIO;
  75. }
  76. return ret;
  77. }
  78. static inline int ssu100_getregister(struct usb_device *dev,
  79. unsigned short uart,
  80. unsigned short reg,
  81. u8 *data)
  82. {
  83. int ret;
  84. ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  85. QT_SET_GET_REGISTER, 0xc0, reg,
  86. uart, data, sizeof(*data), 300);
  87. if (ret < (int)sizeof(*data)) {
  88. if (ret >= 0)
  89. ret = -EIO;
  90. }
  91. return ret;
  92. }
  93. static inline int ssu100_setregister(struct usb_device *dev,
  94. unsigned short uart,
  95. unsigned short reg,
  96. u16 data)
  97. {
  98. u16 value = (data << 8) | reg;
  99. return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  100. QT_SET_GET_REGISTER, 0x40, value, uart,
  101. NULL, 0, 300);
  102. }
  103. #define set_mctrl(dev, set) update_mctrl((dev), (set), 0)
  104. #define clear_mctrl(dev, clear) update_mctrl((dev), 0, (clear))
  105. /* these do not deal with device that have more than 1 port */
  106. static inline int update_mctrl(struct usb_device *dev, unsigned int set,
  107. unsigned int clear)
  108. {
  109. unsigned urb_value;
  110. int result;
  111. if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
  112. dev_dbg(&dev->dev, "%s - DTR|RTS not being set|cleared\n", __func__);
  113. return 0; /* no change */
  114. }
  115. clear &= ~set; /* 'set' takes precedence over 'clear' */
  116. urb_value = 0;
  117. if (set & TIOCM_DTR)
  118. urb_value |= UART_MCR_DTR;
  119. if (set & TIOCM_RTS)
  120. urb_value |= UART_MCR_RTS;
  121. result = ssu100_setregister(dev, 0, UART_MCR, urb_value);
  122. if (result < 0)
  123. dev_dbg(&dev->dev, "%s Error from MODEM_CTRL urb\n", __func__);
  124. return result;
  125. }
  126. static int ssu100_initdevice(struct usb_device *dev)
  127. {
  128. u8 *data;
  129. int result = 0;
  130. data = kzalloc(3, GFP_KERNEL);
  131. if (!data)
  132. return -ENOMEM;
  133. result = ssu100_getdevice(dev, data);
  134. if (result < 0) {
  135. dev_dbg(&dev->dev, "%s - get_device failed %i\n", __func__, result);
  136. goto out;
  137. }
  138. data[1] &= ~FULLPWRBIT;
  139. result = ssu100_setdevice(dev, data);
  140. if (result < 0) {
  141. dev_dbg(&dev->dev, "%s - setdevice failed %i\n", __func__, result);
  142. goto out;
  143. }
  144. result = ssu100_control_msg(dev, QT_GET_SET_PREBUF_TRIG_LVL, 128, 0);
  145. if (result < 0) {
  146. dev_dbg(&dev->dev, "%s - set prebuffer level failed %i\n", __func__, result);
  147. goto out;
  148. }
  149. result = ssu100_control_msg(dev, QT_SET_ATF, ATC_DISABLED, 0);
  150. if (result < 0) {
  151. dev_dbg(&dev->dev, "%s - set ATFprebuffer level failed %i\n", __func__, result);
  152. goto out;
  153. }
  154. result = ssu100_getdevice(dev, data);
  155. if (result < 0) {
  156. dev_dbg(&dev->dev, "%s - get_device failed %i\n", __func__, result);
  157. goto out;
  158. }
  159. data[0] &= ~(RR_BITS | DUPMODE_BITS);
  160. data[0] |= CLKS_X4;
  161. data[1] &= ~(LOOPMODE_BITS);
  162. data[1] |= RS232_MODE;
  163. result = ssu100_setdevice(dev, data);
  164. if (result < 0) {
  165. dev_dbg(&dev->dev, "%s - setdevice failed %i\n", __func__, result);
  166. goto out;
  167. }
  168. out: kfree(data);
  169. return result;
  170. }
  171. static void ssu100_set_termios(struct tty_struct *tty,
  172. struct usb_serial_port *port,
  173. struct ktermios *old_termios)
  174. {
  175. struct usb_device *dev = port->serial->dev;
  176. struct ktermios *termios = &tty->termios;
  177. u16 baud, divisor, remainder;
  178. unsigned int cflag = termios->c_cflag;
  179. u16 urb_value = 0; /* will hold the new flags */
  180. int result;
  181. if (cflag & PARENB) {
  182. if (cflag & PARODD)
  183. urb_value |= UART_LCR_PARITY;
  184. else
  185. urb_value |= SERIAL_EVEN_PARITY;
  186. }
  187. switch (cflag & CSIZE) {
  188. case CS5:
  189. urb_value |= UART_LCR_WLEN5;
  190. break;
  191. case CS6:
  192. urb_value |= UART_LCR_WLEN6;
  193. break;
  194. case CS7:
  195. urb_value |= UART_LCR_WLEN7;
  196. break;
  197. default:
  198. case CS8:
  199. urb_value |= UART_LCR_WLEN8;
  200. break;
  201. }
  202. baud = tty_get_baud_rate(tty);
  203. if (!baud)
  204. baud = 9600;
  205. dev_dbg(&port->dev, "%s - got baud = %d\n", __func__, baud);
  206. divisor = MAX_BAUD_RATE / baud;
  207. remainder = MAX_BAUD_RATE % baud;
  208. if (((remainder * 2) >= baud) && (baud != 110))
  209. divisor++;
  210. urb_value = urb_value << 8;
  211. result = ssu100_control_msg(dev, QT_GET_SET_UART, divisor, urb_value);
  212. if (result < 0)
  213. dev_dbg(&port->dev, "%s - set uart failed\n", __func__);
  214. if (cflag & CRTSCTS)
  215. result = ssu100_control_msg(dev, QT_HW_FLOW_CONTROL_MASK,
  216. SERIAL_CRTSCTS, 0);
  217. else
  218. result = ssu100_control_msg(dev, QT_HW_FLOW_CONTROL_MASK,
  219. 0, 0);
  220. if (result < 0)
  221. dev_dbg(&port->dev, "%s - set HW flow control failed\n", __func__);
  222. if (I_IXOFF(tty) || I_IXON(tty)) {
  223. u16 x = ((u16)(START_CHAR(tty) << 8) | (u16)(STOP_CHAR(tty)));
  224. result = ssu100_control_msg(dev, QT_SW_FLOW_CONTROL_MASK,
  225. x, 0);
  226. } else
  227. result = ssu100_control_msg(dev, QT_SW_FLOW_CONTROL_MASK,
  228. 0, 0);
  229. if (result < 0)
  230. dev_dbg(&port->dev, "%s - set SW flow control failed\n", __func__);
  231. }
  232. static int ssu100_open(struct tty_struct *tty, struct usb_serial_port *port)
  233. {
  234. struct usb_device *dev = port->serial->dev;
  235. struct ssu100_port_private *priv = usb_get_serial_port_data(port);
  236. u8 *data;
  237. int result;
  238. unsigned long flags;
  239. data = kzalloc(2, GFP_KERNEL);
  240. if (!data)
  241. return -ENOMEM;
  242. result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  243. QT_OPEN_CLOSE_CHANNEL,
  244. QT_TRANSFER_IN, 0x01,
  245. 0, data, 2, 300);
  246. if (result < 2) {
  247. dev_dbg(&port->dev, "%s - open failed %i\n", __func__, result);
  248. if (result >= 0)
  249. result = -EIO;
  250. kfree(data);
  251. return result;
  252. }
  253. spin_lock_irqsave(&priv->status_lock, flags);
  254. priv->shadowLSR = data[0];
  255. priv->shadowMSR = data[1];
  256. spin_unlock_irqrestore(&priv->status_lock, flags);
  257. kfree(data);
  258. /* set to 9600 */
  259. result = ssu100_control_msg(dev, QT_GET_SET_UART, 0x30, 0x0300);
  260. if (result < 0)
  261. dev_dbg(&port->dev, "%s - set uart failed\n", __func__);
  262. if (tty)
  263. ssu100_set_termios(tty, port, &tty->termios);
  264. return usb_serial_generic_open(tty, port);
  265. }
  266. static int get_serial_info(struct tty_struct *tty,
  267. struct serial_struct *ss)
  268. {
  269. struct usb_serial_port *port = tty->driver_data;
  270. ss->line = port->minor;
  271. ss->port = 0;
  272. ss->irq = 0;
  273. ss->xmit_fifo_size = port->bulk_out_size;
  274. ss->baud_base = 9600;
  275. ss->close_delay = 5*HZ;
  276. ss->closing_wait = 30*HZ;
  277. return 0;
  278. }
  279. static int ssu100_attach(struct usb_serial *serial)
  280. {
  281. return ssu100_initdevice(serial->dev);
  282. }
  283. static int ssu100_port_probe(struct usb_serial_port *port)
  284. {
  285. struct ssu100_port_private *priv;
  286. priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  287. if (!priv)
  288. return -ENOMEM;
  289. spin_lock_init(&priv->status_lock);
  290. usb_set_serial_port_data(port, priv);
  291. return 0;
  292. }
  293. static int ssu100_port_remove(struct usb_serial_port *port)
  294. {
  295. struct ssu100_port_private *priv;
  296. priv = usb_get_serial_port_data(port);
  297. kfree(priv);
  298. return 0;
  299. }
  300. static int ssu100_tiocmget(struct tty_struct *tty)
  301. {
  302. struct usb_serial_port *port = tty->driver_data;
  303. struct usb_device *dev = port->serial->dev;
  304. u8 *d;
  305. int r;
  306. d = kzalloc(2, GFP_KERNEL);
  307. if (!d)
  308. return -ENOMEM;
  309. r = ssu100_getregister(dev, 0, UART_MCR, d);
  310. if (r < 0)
  311. goto mget_out;
  312. r = ssu100_getregister(dev, 0, UART_MSR, d+1);
  313. if (r < 0)
  314. goto mget_out;
  315. r = (d[0] & UART_MCR_DTR ? TIOCM_DTR : 0) |
  316. (d[0] & UART_MCR_RTS ? TIOCM_RTS : 0) |
  317. (d[1] & UART_MSR_CTS ? TIOCM_CTS : 0) |
  318. (d[1] & UART_MSR_DCD ? TIOCM_CAR : 0) |
  319. (d[1] & UART_MSR_RI ? TIOCM_RI : 0) |
  320. (d[1] & UART_MSR_DSR ? TIOCM_DSR : 0);
  321. mget_out:
  322. kfree(d);
  323. return r;
  324. }
  325. static int ssu100_tiocmset(struct tty_struct *tty,
  326. unsigned int set, unsigned int clear)
  327. {
  328. struct usb_serial_port *port = tty->driver_data;
  329. struct usb_device *dev = port->serial->dev;
  330. return update_mctrl(dev, set, clear);
  331. }
  332. static void ssu100_dtr_rts(struct usb_serial_port *port, int on)
  333. {
  334. struct usb_device *dev = port->serial->dev;
  335. /* Disable flow control */
  336. if (!on) {
  337. if (ssu100_setregister(dev, 0, UART_MCR, 0) < 0)
  338. dev_err(&port->dev, "error from flowcontrol urb\n");
  339. }
  340. /* drop RTS and DTR */
  341. if (on)
  342. set_mctrl(dev, TIOCM_DTR | TIOCM_RTS);
  343. else
  344. clear_mctrl(dev, TIOCM_DTR | TIOCM_RTS);
  345. }
  346. static void ssu100_update_msr(struct usb_serial_port *port, u8 msr)
  347. {
  348. struct ssu100_port_private *priv = usb_get_serial_port_data(port);
  349. unsigned long flags;
  350. spin_lock_irqsave(&priv->status_lock, flags);
  351. priv->shadowMSR = msr;
  352. spin_unlock_irqrestore(&priv->status_lock, flags);
  353. if (msr & UART_MSR_ANY_DELTA) {
  354. /* update input line counters */
  355. if (msr & UART_MSR_DCTS)
  356. port->icount.cts++;
  357. if (msr & UART_MSR_DDSR)
  358. port->icount.dsr++;
  359. if (msr & UART_MSR_DDCD)
  360. port->icount.dcd++;
  361. if (msr & UART_MSR_TERI)
  362. port->icount.rng++;
  363. wake_up_interruptible(&port->port.delta_msr_wait);
  364. }
  365. }
  366. static void ssu100_update_lsr(struct usb_serial_port *port, u8 lsr,
  367. char *tty_flag)
  368. {
  369. struct ssu100_port_private *priv = usb_get_serial_port_data(port);
  370. unsigned long flags;
  371. spin_lock_irqsave(&priv->status_lock, flags);
  372. priv->shadowLSR = lsr;
  373. spin_unlock_irqrestore(&priv->status_lock, flags);
  374. *tty_flag = TTY_NORMAL;
  375. if (lsr & UART_LSR_BRK_ERROR_BITS) {
  376. /* we always want to update icount, but we only want to
  377. * update tty_flag for one case */
  378. if (lsr & UART_LSR_BI) {
  379. port->icount.brk++;
  380. *tty_flag = TTY_BREAK;
  381. usb_serial_handle_break(port);
  382. }
  383. if (lsr & UART_LSR_PE) {
  384. port->icount.parity++;
  385. if (*tty_flag == TTY_NORMAL)
  386. *tty_flag = TTY_PARITY;
  387. }
  388. if (lsr & UART_LSR_FE) {
  389. port->icount.frame++;
  390. if (*tty_flag == TTY_NORMAL)
  391. *tty_flag = TTY_FRAME;
  392. }
  393. if (lsr & UART_LSR_OE) {
  394. port->icount.overrun++;
  395. tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
  396. }
  397. }
  398. }
  399. static void ssu100_process_read_urb(struct urb *urb)
  400. {
  401. struct usb_serial_port *port = urb->context;
  402. char *packet = urb->transfer_buffer;
  403. char flag = TTY_NORMAL;
  404. u32 len = urb->actual_length;
  405. int i;
  406. char *ch;
  407. if ((len >= 4) &&
  408. (packet[0] == 0x1b) && (packet[1] == 0x1b) &&
  409. ((packet[2] == 0x00) || (packet[2] == 0x01))) {
  410. if (packet[2] == 0x00)
  411. ssu100_update_lsr(port, packet[3], &flag);
  412. if (packet[2] == 0x01)
  413. ssu100_update_msr(port, packet[3]);
  414. len -= 4;
  415. ch = packet + 4;
  416. } else
  417. ch = packet;
  418. if (!len)
  419. return; /* status only */
  420. if (port->sysrq) {
  421. for (i = 0; i < len; i++, ch++) {
  422. if (!usb_serial_handle_sysrq_char(port, *ch))
  423. tty_insert_flip_char(&port->port, *ch, flag);
  424. }
  425. } else {
  426. tty_insert_flip_string_fixed_flag(&port->port, ch, flag, len);
  427. }
  428. tty_flip_buffer_push(&port->port);
  429. }
  430. static struct usb_serial_driver ssu100_device = {
  431. .driver = {
  432. .owner = THIS_MODULE,
  433. .name = "ssu100",
  434. },
  435. .description = DRIVER_DESC,
  436. .id_table = id_table,
  437. .num_ports = 1,
  438. .open = ssu100_open,
  439. .attach = ssu100_attach,
  440. .port_probe = ssu100_port_probe,
  441. .port_remove = ssu100_port_remove,
  442. .dtr_rts = ssu100_dtr_rts,
  443. .process_read_urb = ssu100_process_read_urb,
  444. .tiocmget = ssu100_tiocmget,
  445. .tiocmset = ssu100_tiocmset,
  446. .tiocmiwait = usb_serial_generic_tiocmiwait,
  447. .get_icount = usb_serial_generic_get_icount,
  448. .get_serial = get_serial_info,
  449. .set_termios = ssu100_set_termios,
  450. };
  451. static struct usb_serial_driver * const serial_drivers[] = {
  452. &ssu100_device, NULL
  453. };
  454. module_usb_serial_driver(serial_drivers, id_table);
  455. MODULE_DESCRIPTION(DRIVER_DESC);
  456. MODULE_LICENSE("GPL v2");