dev-serial.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646
  1. /*
  2. * FTDI FT232BM Device emulation
  3. *
  4. * Copyright (c) 2006 CodeSourcery.
  5. * Copyright (c) 2008 Samuel Thibault <samuel.thibault@ens-lyon.org>
  6. * Written by Paul Brook, reused for FTDI by Samuel Thibault
  7. *
  8. * This code is licensed under the LGPL.
  9. */
  10. #include "qemu-common.h"
  11. #include "qemu/error-report.h"
  12. #include "hw/usb.h"
  13. #include "hw/usb/desc.h"
  14. #include "char/char.h"
  15. //#define DEBUG_Serial
  16. #ifdef DEBUG_Serial
  17. #define DPRINTF(fmt, ...) \
  18. do { printf("usb-serial: " fmt , ## __VA_ARGS__); } while (0)
  19. #else
  20. #define DPRINTF(fmt, ...) do {} while(0)
  21. #endif
  22. #define RECV_BUF 384
  23. /* Commands */
  24. #define FTDI_RESET 0
  25. #define FTDI_SET_MDM_CTRL 1
  26. #define FTDI_SET_FLOW_CTRL 2
  27. #define FTDI_SET_BAUD 3
  28. #define FTDI_SET_DATA 4
  29. #define FTDI_GET_MDM_ST 5
  30. #define FTDI_SET_EVENT_CHR 6
  31. #define FTDI_SET_ERROR_CHR 7
  32. #define FTDI_SET_LATENCY 9
  33. #define FTDI_GET_LATENCY 10
  34. #define DeviceOutVendor ((USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8)
  35. #define DeviceInVendor ((USB_DIR_IN |USB_TYPE_VENDOR|USB_RECIP_DEVICE)<<8)
  36. /* RESET */
  37. #define FTDI_RESET_SIO 0
  38. #define FTDI_RESET_RX 1
  39. #define FTDI_RESET_TX 2
  40. /* SET_MDM_CTRL */
  41. #define FTDI_DTR 1
  42. #define FTDI_SET_DTR (FTDI_DTR << 8)
  43. #define FTDI_RTS 2
  44. #define FTDI_SET_RTS (FTDI_RTS << 8)
  45. /* SET_FLOW_CTRL */
  46. #define FTDI_RTS_CTS_HS 1
  47. #define FTDI_DTR_DSR_HS 2
  48. #define FTDI_XON_XOFF_HS 4
  49. /* SET_DATA */
  50. #define FTDI_PARITY (0x7 << 8)
  51. #define FTDI_ODD (0x1 << 8)
  52. #define FTDI_EVEN (0x2 << 8)
  53. #define FTDI_MARK (0x3 << 8)
  54. #define FTDI_SPACE (0x4 << 8)
  55. #define FTDI_STOP (0x3 << 11)
  56. #define FTDI_STOP1 (0x0 << 11)
  57. #define FTDI_STOP15 (0x1 << 11)
  58. #define FTDI_STOP2 (0x2 << 11)
  59. /* GET_MDM_ST */
  60. /* TODO: should be sent every 40ms */
  61. #define FTDI_CTS (1<<4) // CTS line status
  62. #define FTDI_DSR (1<<5) // DSR line status
  63. #define FTDI_RI (1<<6) // RI line status
  64. #define FTDI_RLSD (1<<7) // Receive Line Signal Detect
  65. /* Status */
  66. #define FTDI_DR (1<<0) // Data Ready
  67. #define FTDI_OE (1<<1) // Overrun Err
  68. #define FTDI_PE (1<<2) // Parity Err
  69. #define FTDI_FE (1<<3) // Framing Err
  70. #define FTDI_BI (1<<4) // Break Interrupt
  71. #define FTDI_THRE (1<<5) // Transmitter Holding Register
  72. #define FTDI_TEMT (1<<6) // Transmitter Empty
  73. #define FTDI_FIFO (1<<7) // Error in FIFO
  74. typedef struct {
  75. USBDevice dev;
  76. uint8_t recv_buf[RECV_BUF];
  77. uint16_t recv_ptr;
  78. uint16_t recv_used;
  79. uint8_t event_chr;
  80. uint8_t error_chr;
  81. uint8_t event_trigger;
  82. QEMUSerialSetParams params;
  83. int latency; /* ms */
  84. CharDriverState *cs;
  85. } USBSerialState;
  86. enum {
  87. STR_MANUFACTURER = 1,
  88. STR_PRODUCT_SERIAL,
  89. STR_PRODUCT_BRAILLE,
  90. STR_SERIALNUMBER,
  91. };
  92. static const USBDescStrings desc_strings = {
  93. [STR_MANUFACTURER] = "QEMU",
  94. [STR_PRODUCT_SERIAL] = "QEMU USB SERIAL",
  95. [STR_PRODUCT_BRAILLE] = "QEMU USB BAUM BRAILLE",
  96. [STR_SERIALNUMBER] = "1",
  97. };
  98. static const USBDescIface desc_iface0 = {
  99. .bInterfaceNumber = 0,
  100. .bNumEndpoints = 2,
  101. .bInterfaceClass = 0xff,
  102. .bInterfaceSubClass = 0xff,
  103. .bInterfaceProtocol = 0xff,
  104. .eps = (USBDescEndpoint[]) {
  105. {
  106. .bEndpointAddress = USB_DIR_IN | 0x01,
  107. .bmAttributes = USB_ENDPOINT_XFER_BULK,
  108. .wMaxPacketSize = 64,
  109. },{
  110. .bEndpointAddress = USB_DIR_OUT | 0x02,
  111. .bmAttributes = USB_ENDPOINT_XFER_BULK,
  112. .wMaxPacketSize = 64,
  113. },
  114. }
  115. };
  116. static const USBDescDevice desc_device = {
  117. .bcdUSB = 0x0200,
  118. .bMaxPacketSize0 = 8,
  119. .bNumConfigurations = 1,
  120. .confs = (USBDescConfig[]) {
  121. {
  122. .bNumInterfaces = 1,
  123. .bConfigurationValue = 1,
  124. .bmAttributes = 0x80,
  125. .bMaxPower = 50,
  126. .nif = 1,
  127. .ifs = &desc_iface0,
  128. },
  129. },
  130. };
  131. static const USBDesc desc_serial = {
  132. .id = {
  133. .idVendor = 0x0403,
  134. .idProduct = 0x6001,
  135. .bcdDevice = 0x0400,
  136. .iManufacturer = STR_MANUFACTURER,
  137. .iProduct = STR_PRODUCT_SERIAL,
  138. .iSerialNumber = STR_SERIALNUMBER,
  139. },
  140. .full = &desc_device,
  141. .str = desc_strings,
  142. };
  143. static const USBDesc desc_braille = {
  144. .id = {
  145. .idVendor = 0x0403,
  146. .idProduct = 0xfe72,
  147. .bcdDevice = 0x0400,
  148. .iManufacturer = STR_MANUFACTURER,
  149. .iProduct = STR_PRODUCT_BRAILLE,
  150. .iSerialNumber = STR_SERIALNUMBER,
  151. },
  152. .full = &desc_device,
  153. .str = desc_strings,
  154. };
  155. static void usb_serial_reset(USBSerialState *s)
  156. {
  157. /* TODO: Set flow control to none */
  158. s->event_chr = 0x0d;
  159. s->event_trigger = 0;
  160. s->recv_ptr = 0;
  161. s->recv_used = 0;
  162. /* TODO: purge in char driver */
  163. }
  164. static void usb_serial_handle_reset(USBDevice *dev)
  165. {
  166. USBSerialState *s = (USBSerialState *)dev;
  167. DPRINTF("Reset\n");
  168. usb_serial_reset(s);
  169. /* TODO: Reset char device, send BREAK? */
  170. }
  171. static uint8_t usb_get_modem_lines(USBSerialState *s)
  172. {
  173. int flags;
  174. uint8_t ret;
  175. if (qemu_chr_fe_ioctl(s->cs, CHR_IOCTL_SERIAL_GET_TIOCM, &flags) == -ENOTSUP)
  176. return FTDI_CTS|FTDI_DSR|FTDI_RLSD;
  177. ret = 0;
  178. if (flags & CHR_TIOCM_CTS)
  179. ret |= FTDI_CTS;
  180. if (flags & CHR_TIOCM_DSR)
  181. ret |= FTDI_DSR;
  182. if (flags & CHR_TIOCM_RI)
  183. ret |= FTDI_RI;
  184. if (flags & CHR_TIOCM_CAR)
  185. ret |= FTDI_RLSD;
  186. return ret;
  187. }
  188. static void usb_serial_handle_control(USBDevice *dev, USBPacket *p,
  189. int request, int value, int index, int length, uint8_t *data)
  190. {
  191. USBSerialState *s = (USBSerialState *)dev;
  192. int ret;
  193. DPRINTF("got control %x, value %x\n",request, value);
  194. ret = usb_desc_handle_control(dev, p, request, value, index, length, data);
  195. if (ret >= 0) {
  196. return;
  197. }
  198. switch (request) {
  199. case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
  200. break;
  201. /* Class specific requests. */
  202. case DeviceOutVendor | FTDI_RESET:
  203. switch (value) {
  204. case FTDI_RESET_SIO:
  205. usb_serial_reset(s);
  206. break;
  207. case FTDI_RESET_RX:
  208. s->recv_ptr = 0;
  209. s->recv_used = 0;
  210. /* TODO: purge from char device */
  211. break;
  212. case FTDI_RESET_TX:
  213. /* TODO: purge from char device */
  214. break;
  215. }
  216. break;
  217. case DeviceOutVendor | FTDI_SET_MDM_CTRL:
  218. {
  219. static int flags;
  220. qemu_chr_fe_ioctl(s->cs,CHR_IOCTL_SERIAL_GET_TIOCM, &flags);
  221. if (value & FTDI_SET_RTS) {
  222. if (value & FTDI_RTS)
  223. flags |= CHR_TIOCM_RTS;
  224. else
  225. flags &= ~CHR_TIOCM_RTS;
  226. }
  227. if (value & FTDI_SET_DTR) {
  228. if (value & FTDI_DTR)
  229. flags |= CHR_TIOCM_DTR;
  230. else
  231. flags &= ~CHR_TIOCM_DTR;
  232. }
  233. qemu_chr_fe_ioctl(s->cs,CHR_IOCTL_SERIAL_SET_TIOCM, &flags);
  234. break;
  235. }
  236. case DeviceOutVendor | FTDI_SET_FLOW_CTRL:
  237. /* TODO: ioctl */
  238. break;
  239. case DeviceOutVendor | FTDI_SET_BAUD: {
  240. static const int subdivisors8[8] = { 0, 4, 2, 1, 3, 5, 6, 7 };
  241. int subdivisor8 = subdivisors8[((value & 0xc000) >> 14)
  242. | ((index & 1) << 2)];
  243. int divisor = value & 0x3fff;
  244. /* chip special cases */
  245. if (divisor == 1 && subdivisor8 == 0)
  246. subdivisor8 = 4;
  247. if (divisor == 0 && subdivisor8 == 0)
  248. divisor = 1;
  249. s->params.speed = (48000000 / 2) / (8 * divisor + subdivisor8);
  250. qemu_chr_fe_ioctl(s->cs, CHR_IOCTL_SERIAL_SET_PARAMS, &s->params);
  251. break;
  252. }
  253. case DeviceOutVendor | FTDI_SET_DATA:
  254. switch (value & FTDI_PARITY) {
  255. case 0:
  256. s->params.parity = 'N';
  257. break;
  258. case FTDI_ODD:
  259. s->params.parity = 'O';
  260. break;
  261. case FTDI_EVEN:
  262. s->params.parity = 'E';
  263. break;
  264. default:
  265. DPRINTF("unsupported parity %d\n", value & FTDI_PARITY);
  266. goto fail;
  267. }
  268. switch (value & FTDI_STOP) {
  269. case FTDI_STOP1:
  270. s->params.stop_bits = 1;
  271. break;
  272. case FTDI_STOP2:
  273. s->params.stop_bits = 2;
  274. break;
  275. default:
  276. DPRINTF("unsupported stop bits %d\n", value & FTDI_STOP);
  277. goto fail;
  278. }
  279. qemu_chr_fe_ioctl(s->cs, CHR_IOCTL_SERIAL_SET_PARAMS, &s->params);
  280. /* TODO: TX ON/OFF */
  281. break;
  282. case DeviceInVendor | FTDI_GET_MDM_ST:
  283. data[0] = usb_get_modem_lines(s) | 1;
  284. data[1] = 0;
  285. p->actual_length = 2;
  286. break;
  287. case DeviceOutVendor | FTDI_SET_EVENT_CHR:
  288. /* TODO: handle it */
  289. s->event_chr = value;
  290. break;
  291. case DeviceOutVendor | FTDI_SET_ERROR_CHR:
  292. /* TODO: handle it */
  293. s->error_chr = value;
  294. break;
  295. case DeviceOutVendor | FTDI_SET_LATENCY:
  296. s->latency = value;
  297. break;
  298. case DeviceInVendor | FTDI_GET_LATENCY:
  299. data[0] = s->latency;
  300. p->actual_length = 1;
  301. break;
  302. default:
  303. fail:
  304. DPRINTF("got unsupported/bogus control %x, value %x\n", request, value);
  305. p->status = USB_RET_STALL;
  306. break;
  307. }
  308. }
  309. static void usb_serial_handle_data(USBDevice *dev, USBPacket *p)
  310. {
  311. USBSerialState *s = (USBSerialState *)dev;
  312. uint8_t devep = p->ep->nr;
  313. struct iovec *iov;
  314. uint8_t header[2];
  315. int i, first_len, len;
  316. switch (p->pid) {
  317. case USB_TOKEN_OUT:
  318. if (devep != 2)
  319. goto fail;
  320. for (i = 0; i < p->iov.niov; i++) {
  321. iov = p->iov.iov + i;
  322. qemu_chr_fe_write(s->cs, iov->iov_base, iov->iov_len);
  323. }
  324. p->actual_length = p->iov.size;
  325. break;
  326. case USB_TOKEN_IN:
  327. if (devep != 1)
  328. goto fail;
  329. first_len = RECV_BUF - s->recv_ptr;
  330. len = p->iov.size;
  331. if (len <= 2) {
  332. p->status = USB_RET_NAK;
  333. break;
  334. }
  335. header[0] = usb_get_modem_lines(s) | 1;
  336. /* We do not have the uart details */
  337. /* handle serial break */
  338. if (s->event_trigger && s->event_trigger & FTDI_BI) {
  339. s->event_trigger &= ~FTDI_BI;
  340. header[1] = FTDI_BI;
  341. usb_packet_copy(p, header, 2);
  342. break;
  343. } else {
  344. header[1] = 0;
  345. }
  346. len -= 2;
  347. if (len > s->recv_used)
  348. len = s->recv_used;
  349. if (!len) {
  350. p->status = USB_RET_NAK;
  351. break;
  352. }
  353. if (first_len > len)
  354. first_len = len;
  355. usb_packet_copy(p, header, 2);
  356. usb_packet_copy(p, s->recv_buf + s->recv_ptr, first_len);
  357. if (len > first_len)
  358. usb_packet_copy(p, s->recv_buf, len - first_len);
  359. s->recv_used -= len;
  360. s->recv_ptr = (s->recv_ptr + len) % RECV_BUF;
  361. break;
  362. default:
  363. DPRINTF("Bad token\n");
  364. fail:
  365. p->status = USB_RET_STALL;
  366. break;
  367. }
  368. }
  369. static void usb_serial_handle_destroy(USBDevice *dev)
  370. {
  371. USBSerialState *s = (USBSerialState *)dev;
  372. qemu_chr_add_handlers(s->cs, NULL, NULL, NULL, NULL);
  373. }
  374. static int usb_serial_can_read(void *opaque)
  375. {
  376. USBSerialState *s = opaque;
  377. if (!s->dev.attached) {
  378. return 0;
  379. }
  380. return RECV_BUF - s->recv_used;
  381. }
  382. static void usb_serial_read(void *opaque, const uint8_t *buf, int size)
  383. {
  384. USBSerialState *s = opaque;
  385. int first_size, start;
  386. /* room in the buffer? */
  387. if (size > (RECV_BUF - s->recv_used))
  388. size = RECV_BUF - s->recv_used;
  389. start = s->recv_ptr + s->recv_used;
  390. if (start < RECV_BUF) {
  391. /* copy data to end of buffer */
  392. first_size = RECV_BUF - start;
  393. if (first_size > size)
  394. first_size = size;
  395. memcpy(s->recv_buf + start, buf, first_size);
  396. /* wrap around to front if needed */
  397. if (size > first_size)
  398. memcpy(s->recv_buf, buf + first_size, size - first_size);
  399. } else {
  400. start -= RECV_BUF;
  401. memcpy(s->recv_buf + start, buf, size);
  402. }
  403. s->recv_used += size;
  404. }
  405. static void usb_serial_event(void *opaque, int event)
  406. {
  407. USBSerialState *s = opaque;
  408. switch (event) {
  409. case CHR_EVENT_BREAK:
  410. s->event_trigger |= FTDI_BI;
  411. break;
  412. case CHR_EVENT_FOCUS:
  413. break;
  414. case CHR_EVENT_OPENED:
  415. if (!s->dev.attached) {
  416. usb_device_attach(&s->dev);
  417. }
  418. break;
  419. case CHR_EVENT_CLOSED:
  420. if (s->dev.attached) {
  421. usb_device_detach(&s->dev);
  422. }
  423. break;
  424. }
  425. }
  426. static int usb_serial_initfn(USBDevice *dev)
  427. {
  428. USBSerialState *s = DO_UPCAST(USBSerialState, dev, dev);
  429. usb_desc_create_serial(dev);
  430. usb_desc_init(dev);
  431. dev->auto_attach = 0;
  432. if (!s->cs) {
  433. error_report("Property chardev is required");
  434. return -1;
  435. }
  436. qemu_chr_add_handlers(s->cs, usb_serial_can_read, usb_serial_read,
  437. usb_serial_event, s);
  438. usb_serial_handle_reset(dev);
  439. if (s->cs->opened && !dev->attached) {
  440. usb_device_attach(dev);
  441. }
  442. return 0;
  443. }
  444. static USBDevice *usb_serial_init(USBBus *bus, const char *filename)
  445. {
  446. USBDevice *dev;
  447. CharDriverState *cdrv;
  448. uint32_t vendorid = 0, productid = 0;
  449. char label[32];
  450. static int index;
  451. while (*filename && *filename != ':') {
  452. const char *p;
  453. char *e;
  454. if (strstart(filename, "vendorid=", &p)) {
  455. vendorid = strtol(p, &e, 16);
  456. if (e == p || (*e && *e != ',' && *e != ':')) {
  457. error_report("bogus vendor ID %s", p);
  458. return NULL;
  459. }
  460. filename = e;
  461. } else if (strstart(filename, "productid=", &p)) {
  462. productid = strtol(p, &e, 16);
  463. if (e == p || (*e && *e != ',' && *e != ':')) {
  464. error_report("bogus product ID %s", p);
  465. return NULL;
  466. }
  467. filename = e;
  468. } else {
  469. error_report("unrecognized serial USB option %s", filename);
  470. return NULL;
  471. }
  472. while(*filename == ',')
  473. filename++;
  474. }
  475. if (!*filename) {
  476. error_report("character device specification needed");
  477. return NULL;
  478. }
  479. filename++;
  480. snprintf(label, sizeof(label), "usbserial%d", index++);
  481. cdrv = qemu_chr_new(label, filename, NULL);
  482. if (!cdrv)
  483. return NULL;
  484. dev = usb_create(bus, "usb-serial");
  485. if (!dev) {
  486. return NULL;
  487. }
  488. qdev_prop_set_chr(&dev->qdev, "chardev", cdrv);
  489. if (vendorid)
  490. qdev_prop_set_uint16(&dev->qdev, "vendorid", vendorid);
  491. if (productid)
  492. qdev_prop_set_uint16(&dev->qdev, "productid", productid);
  493. qdev_init_nofail(&dev->qdev);
  494. return dev;
  495. }
  496. static USBDevice *usb_braille_init(USBBus *bus, const char *unused)
  497. {
  498. USBDevice *dev;
  499. CharDriverState *cdrv;
  500. cdrv = qemu_chr_new("braille", "braille", NULL);
  501. if (!cdrv)
  502. return NULL;
  503. dev = usb_create(bus, "usb-braille");
  504. qdev_prop_set_chr(&dev->qdev, "chardev", cdrv);
  505. qdev_init_nofail(&dev->qdev);
  506. return dev;
  507. }
  508. static const VMStateDescription vmstate_usb_serial = {
  509. .name = "usb-serial",
  510. .unmigratable = 1,
  511. };
  512. static Property serial_properties[] = {
  513. DEFINE_PROP_CHR("chardev", USBSerialState, cs),
  514. DEFINE_PROP_END_OF_LIST(),
  515. };
  516. static void usb_serial_class_initfn(ObjectClass *klass, void *data)
  517. {
  518. DeviceClass *dc = DEVICE_CLASS(klass);
  519. USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
  520. uc->init = usb_serial_initfn;
  521. uc->product_desc = "QEMU USB Serial";
  522. uc->usb_desc = &desc_serial;
  523. uc->handle_reset = usb_serial_handle_reset;
  524. uc->handle_control = usb_serial_handle_control;
  525. uc->handle_data = usb_serial_handle_data;
  526. uc->handle_destroy = usb_serial_handle_destroy;
  527. dc->vmsd = &vmstate_usb_serial;
  528. dc->props = serial_properties;
  529. }
  530. static const TypeInfo serial_info = {
  531. .name = "usb-serial",
  532. .parent = TYPE_USB_DEVICE,
  533. .instance_size = sizeof(USBSerialState),
  534. .class_init = usb_serial_class_initfn,
  535. };
  536. static Property braille_properties[] = {
  537. DEFINE_PROP_CHR("chardev", USBSerialState, cs),
  538. DEFINE_PROP_END_OF_LIST(),
  539. };
  540. static void usb_braille_class_initfn(ObjectClass *klass, void *data)
  541. {
  542. DeviceClass *dc = DEVICE_CLASS(klass);
  543. USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
  544. uc->init = usb_serial_initfn;
  545. uc->product_desc = "QEMU USB Braille";
  546. uc->usb_desc = &desc_braille;
  547. uc->handle_reset = usb_serial_handle_reset;
  548. uc->handle_control = usb_serial_handle_control;
  549. uc->handle_data = usb_serial_handle_data;
  550. uc->handle_destroy = usb_serial_handle_destroy;
  551. dc->vmsd = &vmstate_usb_serial;
  552. dc->props = braille_properties;
  553. }
  554. static const TypeInfo braille_info = {
  555. .name = "usb-braille",
  556. .parent = TYPE_USB_DEVICE,
  557. .instance_size = sizeof(USBSerialState),
  558. .class_init = usb_braille_class_initfn,
  559. };
  560. static void usb_serial_register_types(void)
  561. {
  562. type_register_static(&serial_info);
  563. usb_legacy_register("usb-serial", "serial", usb_serial_init);
  564. type_register_static(&braille_info);
  565. usb_legacy_register("usb-braille", "braille", usb_braille_init);
  566. }
  567. type_init(usb_serial_register_types)