belkin_sa.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604
  1. /*
  2. * Belkin USB Serial Adapter Driver
  3. *
  4. * Copyright (C) 2000 William Greathouse (wgreathouse@smva.com)
  5. * Copyright (C) 2000-2001 Greg Kroah-Hartman (greg@kroah.com)
  6. *
  7. * This program is largely derived from work by the linux-usb group
  8. * and associated source files. Please see the usb/serial files for
  9. * individual credits and copyrights.
  10. *
  11. * This program is free software; you can redistribute it and/or modify
  12. * it under the terms of the GNU General Public License as published by
  13. * the Free Software Foundation; either version 2 of the License, or
  14. * (at your option) any later version.
  15. *
  16. * See Documentation/usb/usb-serial.txt for more information on using this
  17. * driver
  18. *
  19. * TODO:
  20. * -- Add true modem contol line query capability. Currently we track the
  21. * states reported by the interrupt and the states we request.
  22. * -- Add error reporting back to application for UART error conditions.
  23. * Just point me at how to implement this and I'll do it. I've put the
  24. * framework in, but haven't analyzed the "tty_flip" interface yet.
  25. * -- Add support for flush commands
  26. * -- Add everything that is missing :)
  27. *
  28. * 27-Nov-2001 gkh
  29. * compressed all the differnent device entries into 1.
  30. *
  31. * 30-May-2001 gkh
  32. * switched from using spinlock to a semaphore, which fixes lots of
  33. * problems.
  34. *
  35. * 08-Apr-2001 gb
  36. * - Identify version on module load.
  37. *
  38. * 12-Mar-2001 gkh
  39. * - Added support for the GoHubs GO-COM232 device which is the same as the
  40. * Peracom device.
  41. *
  42. * 06-Nov-2000 gkh
  43. * - Added support for the old Belkin and Peracom devices.
  44. * - Made the port able to be opened multiple times.
  45. * - Added some defaults incase the line settings are things these devices
  46. * can't support.
  47. *
  48. * 18-Oct-2000 William Greathouse
  49. * Released into the wild (linux-usb-devel)
  50. *
  51. * 17-Oct-2000 William Greathouse
  52. * Add code to recognize firmware version and set hardware flow control
  53. * appropriately. Belkin states that firmware prior to 3.05 does not
  54. * operate correctly in hardware handshake mode. I have verified this
  55. * on firmware 2.05 -- for both RTS and DTR input flow control, the control
  56. * line is not reset. The test performed by the Belkin Win* driver is
  57. * to enable hardware flow control for firmware 2.06 or greater and
  58. * for 1.00 or prior. I am only enabling for 2.06 or greater.
  59. *
  60. * 12-Oct-2000 William Greathouse
  61. * First cut at supporting Belkin USB Serial Adapter F5U103
  62. * I did not have a copy of the original work to support this
  63. * adapter, so pardon any stupid mistakes. All of the information
  64. * I am using to write this driver was acquired by using a modified
  65. * UsbSnoop on Windows2000 and from examining the other USB drivers.
  66. */
  67. #include <linux/kernel.h>
  68. #include <linux/errno.h>
  69. #include <linux/init.h>
  70. #include <linux/slab.h>
  71. #include <linux/tty.h>
  72. #include <linux/tty_driver.h>
  73. #include <linux/tty_flip.h>
  74. #include <linux/module.h>
  75. #include <linux/spinlock.h>
  76. #include <linux/uaccess.h>
  77. #include <linux/usb.h>
  78. #include <linux/usb/serial.h>
  79. #include "belkin_sa.h"
  80. static int debug;
  81. /*
  82. * Version Information
  83. */
  84. #define DRIVER_VERSION "v1.2"
  85. #define DRIVER_AUTHOR "William Greathouse <wgreathouse@smva.com>"
  86. #define DRIVER_DESC "USB Belkin Serial converter driver"
  87. /* function prototypes for a Belkin USB Serial Adapter F5U103 */
  88. static int belkin_sa_startup(struct usb_serial *serial);
  89. static void belkin_sa_shutdown(struct usb_serial *serial);
  90. static int belkin_sa_open(struct tty_struct *tty,
  91. struct usb_serial_port *port, struct file *filp);
  92. static void belkin_sa_close(struct usb_serial_port *port);
  93. static void belkin_sa_read_int_callback(struct urb *urb);
  94. static void belkin_sa_set_termios(struct tty_struct *tty,
  95. struct usb_serial_port *port, struct ktermios * old);
  96. static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state);
  97. static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file);
  98. static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
  99. unsigned int set, unsigned int clear);
  100. static struct usb_device_id id_table_combined [] = {
  101. { USB_DEVICE(BELKIN_SA_VID, BELKIN_SA_PID) },
  102. { USB_DEVICE(BELKIN_OLD_VID, BELKIN_OLD_PID) },
  103. { USB_DEVICE(PERACOM_VID, PERACOM_PID) },
  104. { USB_DEVICE(GOHUBS_VID, GOHUBS_PID) },
  105. { USB_DEVICE(GOHUBS_VID, HANDYLINK_PID) },
  106. { USB_DEVICE(BELKIN_DOCKSTATION_VID, BELKIN_DOCKSTATION_PID) },
  107. { } /* Terminating entry */
  108. };
  109. MODULE_DEVICE_TABLE(usb, id_table_combined);
  110. static struct usb_driver belkin_driver = {
  111. .name = "belkin",
  112. .probe = usb_serial_probe,
  113. .disconnect = usb_serial_disconnect,
  114. .id_table = id_table_combined,
  115. .no_dynamic_id = 1,
  116. };
  117. /* All of the device info needed for the serial converters */
  118. static struct usb_serial_driver belkin_device = {
  119. .driver = {
  120. .owner = THIS_MODULE,
  121. .name = "belkin",
  122. },
  123. .description = "Belkin / Peracom / GoHubs USB Serial Adapter",
  124. .usb_driver = &belkin_driver,
  125. .id_table = id_table_combined,
  126. .num_ports = 1,
  127. .open = belkin_sa_open,
  128. .close = belkin_sa_close,
  129. .read_int_callback = belkin_sa_read_int_callback,
  130. /* How we get the status info */
  131. .set_termios = belkin_sa_set_termios,
  132. .break_ctl = belkin_sa_break_ctl,
  133. .tiocmget = belkin_sa_tiocmget,
  134. .tiocmset = belkin_sa_tiocmset,
  135. .attach = belkin_sa_startup,
  136. .shutdown = belkin_sa_shutdown,
  137. };
  138. struct belkin_sa_private {
  139. spinlock_t lock;
  140. unsigned long control_state;
  141. unsigned char last_lsr;
  142. unsigned char last_msr;
  143. int bad_flow_control;
  144. };
  145. /*
  146. * ***************************************************************************
  147. * Belkin USB Serial Adapter F5U103 specific driver functions
  148. * ***************************************************************************
  149. */
  150. #define WDR_TIMEOUT 5000 /* default urb timeout */
  151. /* assumes that struct usb_serial *serial is available */
  152. #define BSA_USB_CMD(c, v) usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), \
  153. (c), BELKIN_SA_SET_REQUEST_TYPE, \
  154. (v), 0, NULL, 0, WDR_TIMEOUT)
  155. /* do some startup allocations not currently performed by usb_serial_probe() */
  156. static int belkin_sa_startup(struct usb_serial *serial)
  157. {
  158. struct usb_device *dev = serial->dev;
  159. struct belkin_sa_private *priv;
  160. /* allocate the private data structure */
  161. priv = kmalloc(sizeof(struct belkin_sa_private), GFP_KERNEL);
  162. if (!priv)
  163. return -1; /* error */
  164. /* set initial values for control structures */
  165. spin_lock_init(&priv->lock);
  166. priv->control_state = 0;
  167. priv->last_lsr = 0;
  168. priv->last_msr = 0;
  169. /* see comments at top of file */
  170. priv->bad_flow_control =
  171. (le16_to_cpu(dev->descriptor.bcdDevice) <= 0x0206) ? 1 : 0;
  172. dev_info(&dev->dev, "bcdDevice: %04x, bfc: %d\n",
  173. le16_to_cpu(dev->descriptor.bcdDevice),
  174. priv->bad_flow_control);
  175. init_waitqueue_head(&serial->port[0]->write_wait);
  176. usb_set_serial_port_data(serial->port[0], priv);
  177. return 0;
  178. }
  179. static void belkin_sa_shutdown(struct usb_serial *serial)
  180. {
  181. struct belkin_sa_private *priv;
  182. int i;
  183. dbg("%s", __func__);
  184. /* stop reads and writes on all ports */
  185. for (i = 0; i < serial->num_ports; ++i) {
  186. /* My special items, the standard routines free my urbs */
  187. priv = usb_get_serial_port_data(serial->port[i]);
  188. kfree(priv);
  189. }
  190. }
  191. static int belkin_sa_open(struct tty_struct *tty,
  192. struct usb_serial_port *port, struct file *filp)
  193. {
  194. int retval = 0;
  195. dbg("%s port %d", __func__, port->number);
  196. /*Start reading from the device*/
  197. /* TODO: Look at possibility of submitting multiple URBs to device to
  198. * enhance buffering. Win trace shows 16 initial read URBs.
  199. */
  200. port->read_urb->dev = port->serial->dev;
  201. retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
  202. if (retval) {
  203. dev_err(&port->dev, "usb_submit_urb(read bulk) failed\n");
  204. goto exit;
  205. }
  206. port->interrupt_in_urb->dev = port->serial->dev;
  207. retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
  208. if (retval) {
  209. usb_kill_urb(port->read_urb);
  210. dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
  211. }
  212. exit:
  213. return retval;
  214. } /* belkin_sa_open */
  215. static void belkin_sa_close(struct usb_serial_port *port)
  216. {
  217. dbg("%s port %d", __func__, port->number);
  218. /* shutdown our bulk reads and writes */
  219. usb_kill_urb(port->write_urb);
  220. usb_kill_urb(port->read_urb);
  221. usb_kill_urb(port->interrupt_in_urb);
  222. } /* belkin_sa_close */
  223. static void belkin_sa_read_int_callback(struct urb *urb)
  224. {
  225. struct usb_serial_port *port = urb->context;
  226. struct belkin_sa_private *priv;
  227. unsigned char *data = urb->transfer_buffer;
  228. int retval;
  229. int status = urb->status;
  230. unsigned long flags;
  231. switch (status) {
  232. case 0:
  233. /* success */
  234. break;
  235. case -ECONNRESET:
  236. case -ENOENT:
  237. case -ESHUTDOWN:
  238. /* this urb is terminated, clean up */
  239. dbg("%s - urb shutting down with status: %d",
  240. __func__, status);
  241. return;
  242. default:
  243. dbg("%s - nonzero urb status received: %d",
  244. __func__, status);
  245. goto exit;
  246. }
  247. usb_serial_debug_data(debug, &port->dev, __func__,
  248. urb->actual_length, data);
  249. /* Handle known interrupt data */
  250. /* ignore data[0] and data[1] */
  251. priv = usb_get_serial_port_data(port);
  252. spin_lock_irqsave(&priv->lock, flags);
  253. priv->last_msr = data[BELKIN_SA_MSR_INDEX];
  254. /* Record Control Line states */
  255. if (priv->last_msr & BELKIN_SA_MSR_DSR)
  256. priv->control_state |= TIOCM_DSR;
  257. else
  258. priv->control_state &= ~TIOCM_DSR;
  259. if (priv->last_msr & BELKIN_SA_MSR_CTS)
  260. priv->control_state |= TIOCM_CTS;
  261. else
  262. priv->control_state &= ~TIOCM_CTS;
  263. if (priv->last_msr & BELKIN_SA_MSR_RI)
  264. priv->control_state |= TIOCM_RI;
  265. else
  266. priv->control_state &= ~TIOCM_RI;
  267. if (priv->last_msr & BELKIN_SA_MSR_CD)
  268. priv->control_state |= TIOCM_CD;
  269. else
  270. priv->control_state &= ~TIOCM_CD;
  271. /* Now to report any errors */
  272. priv->last_lsr = data[BELKIN_SA_LSR_INDEX];
  273. #if 0
  274. /*
  275. * fill in the flip buffer here, but I do not know the relation
  276. * to the current/next receive buffer or characters. I need
  277. * to look in to this before committing any code.
  278. */
  279. if (priv->last_lsr & BELKIN_SA_LSR_ERR) {
  280. tty = tty_port_tty_get(&port->port);
  281. /* Overrun Error */
  282. if (priv->last_lsr & BELKIN_SA_LSR_OE) {
  283. }
  284. /* Parity Error */
  285. if (priv->last_lsr & BELKIN_SA_LSR_PE) {
  286. }
  287. /* Framing Error */
  288. if (priv->last_lsr & BELKIN_SA_LSR_FE) {
  289. }
  290. /* Break Indicator */
  291. if (priv->last_lsr & BELKIN_SA_LSR_BI) {
  292. }
  293. tty_kref_put(tty);
  294. }
  295. #endif
  296. spin_unlock_irqrestore(&priv->lock, flags);
  297. exit:
  298. retval = usb_submit_urb(urb, GFP_ATOMIC);
  299. if (retval)
  300. dev_err(&port->dev, "%s - usb_submit_urb failed with "
  301. "result %d\n", __func__, retval);
  302. }
  303. static void belkin_sa_set_termios(struct tty_struct *tty,
  304. struct usb_serial_port *port, struct ktermios *old_termios)
  305. {
  306. struct usb_serial *serial = port->serial;
  307. struct belkin_sa_private *priv = usb_get_serial_port_data(port);
  308. unsigned int iflag;
  309. unsigned int cflag;
  310. unsigned int old_iflag = 0;
  311. unsigned int old_cflag = 0;
  312. __u16 urb_value = 0; /* Will hold the new flags */
  313. unsigned long flags;
  314. unsigned long control_state;
  315. int bad_flow_control;
  316. speed_t baud;
  317. struct ktermios *termios = tty->termios;
  318. iflag = termios->c_iflag;
  319. cflag = termios->c_cflag;
  320. termios->c_cflag &= ~CMSPAR;
  321. /* get a local copy of the current port settings */
  322. spin_lock_irqsave(&priv->lock, flags);
  323. control_state = priv->control_state;
  324. bad_flow_control = priv->bad_flow_control;
  325. spin_unlock_irqrestore(&priv->lock, flags);
  326. old_iflag = old_termios->c_iflag;
  327. old_cflag = old_termios->c_cflag;
  328. /* Set the baud rate */
  329. if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
  330. /* reassert DTR and (maybe) RTS on transition from B0 */
  331. if ((old_cflag & CBAUD) == B0) {
  332. control_state |= (TIOCM_DTR|TIOCM_RTS);
  333. if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 1) < 0)
  334. dev_err(&port->dev, "Set DTR error\n");
  335. /* don't set RTS if using hardware flow control */
  336. if (!(old_cflag & CRTSCTS))
  337. if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST
  338. , 1) < 0)
  339. dev_err(&port->dev, "Set RTS error\n");
  340. }
  341. }
  342. baud = tty_get_baud_rate(tty);
  343. if (baud) {
  344. urb_value = BELKIN_SA_BAUD(baud);
  345. /* Clip to maximum speed */
  346. if (urb_value == 0)
  347. urb_value = 1;
  348. /* Turn it back into a resulting real baud rate */
  349. baud = BELKIN_SA_BAUD(urb_value);
  350. /* Report the actual baud rate back to the caller */
  351. tty_encode_baud_rate(tty, baud, baud);
  352. if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)
  353. dev_err(&port->dev, "Set baudrate error\n");
  354. } else {
  355. /* Disable flow control */
  356. if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST,
  357. BELKIN_SA_FLOW_NONE) < 0)
  358. dev_err(&port->dev, "Disable flowcontrol error\n");
  359. /* Drop RTS and DTR */
  360. control_state &= ~(TIOCM_DTR | TIOCM_RTS);
  361. if (BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, 0) < 0)
  362. dev_err(&port->dev, "DTR LOW error\n");
  363. if (BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, 0) < 0)
  364. dev_err(&port->dev, "RTS LOW error\n");
  365. }
  366. /* set the parity */
  367. if ((cflag ^ old_cflag) & (PARENB | PARODD)) {
  368. if (cflag & PARENB)
  369. urb_value = (cflag & PARODD) ? BELKIN_SA_PARITY_ODD
  370. : BELKIN_SA_PARITY_EVEN;
  371. else
  372. urb_value = BELKIN_SA_PARITY_NONE;
  373. if (BSA_USB_CMD(BELKIN_SA_SET_PARITY_REQUEST, urb_value) < 0)
  374. dev_err(&port->dev, "Set parity error\n");
  375. }
  376. /* set the number of data bits */
  377. if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
  378. switch (cflag & CSIZE) {
  379. case CS5:
  380. urb_value = BELKIN_SA_DATA_BITS(5);
  381. break;
  382. case CS6:
  383. urb_value = BELKIN_SA_DATA_BITS(6);
  384. break;
  385. case CS7:
  386. urb_value = BELKIN_SA_DATA_BITS(7);
  387. break;
  388. case CS8:
  389. urb_value = BELKIN_SA_DATA_BITS(8);
  390. break;
  391. default: dbg("CSIZE was not CS5-CS8, using default of 8");
  392. urb_value = BELKIN_SA_DATA_BITS(8);
  393. break;
  394. }
  395. if (BSA_USB_CMD(BELKIN_SA_SET_DATA_BITS_REQUEST, urb_value) < 0)
  396. dev_err(&port->dev, "Set data bits error\n");
  397. }
  398. /* set the number of stop bits */
  399. if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
  400. urb_value = (cflag & CSTOPB) ? BELKIN_SA_STOP_BITS(2)
  401. : BELKIN_SA_STOP_BITS(1);
  402. if (BSA_USB_CMD(BELKIN_SA_SET_STOP_BITS_REQUEST,
  403. urb_value) < 0)
  404. dev_err(&port->dev, "Set stop bits error\n");
  405. }
  406. /* Set flow control */
  407. if (((iflag ^ old_iflag) & (IXOFF | IXON)) ||
  408. ((cflag ^ old_cflag) & CRTSCTS)) {
  409. urb_value = 0;
  410. if ((iflag & IXOFF) || (iflag & IXON))
  411. urb_value |= (BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
  412. else
  413. urb_value &= ~(BELKIN_SA_FLOW_OXON | BELKIN_SA_FLOW_IXON);
  414. if (cflag & CRTSCTS)
  415. urb_value |= (BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
  416. else
  417. urb_value &= ~(BELKIN_SA_FLOW_OCTS | BELKIN_SA_FLOW_IRTS);
  418. if (bad_flow_control)
  419. urb_value &= ~(BELKIN_SA_FLOW_IRTS);
  420. if (BSA_USB_CMD(BELKIN_SA_SET_FLOW_CTRL_REQUEST, urb_value) < 0)
  421. dev_err(&port->dev, "Set flow control error\n");
  422. }
  423. /* save off the modified port settings */
  424. spin_lock_irqsave(&priv->lock, flags);
  425. priv->control_state = control_state;
  426. spin_unlock_irqrestore(&priv->lock, flags);
  427. } /* belkin_sa_set_termios */
  428. static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state)
  429. {
  430. struct usb_serial_port *port = tty->driver_data;
  431. struct usb_serial *serial = port->serial;
  432. if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0)
  433. dev_err(&port->dev, "Set break_ctl %d\n", break_state);
  434. }
  435. static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file)
  436. {
  437. struct usb_serial_port *port = tty->driver_data;
  438. struct belkin_sa_private *priv = usb_get_serial_port_data(port);
  439. unsigned long control_state;
  440. unsigned long flags;
  441. dbg("%s", __func__);
  442. spin_lock_irqsave(&priv->lock, flags);
  443. control_state = priv->control_state;
  444. spin_unlock_irqrestore(&priv->lock, flags);
  445. return control_state;
  446. }
  447. static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
  448. unsigned int set, unsigned int clear)
  449. {
  450. struct usb_serial_port *port = tty->driver_data;
  451. struct usb_serial *serial = port->serial;
  452. struct belkin_sa_private *priv = usb_get_serial_port_data(port);
  453. unsigned long control_state;
  454. unsigned long flags;
  455. int retval;
  456. int rts = 0;
  457. int dtr = 0;
  458. dbg("%s", __func__);
  459. spin_lock_irqsave(&priv->lock, flags);
  460. control_state = priv->control_state;
  461. if (set & TIOCM_RTS) {
  462. control_state |= TIOCM_RTS;
  463. rts = 1;
  464. }
  465. if (set & TIOCM_DTR) {
  466. control_state |= TIOCM_DTR;
  467. dtr = 1;
  468. }
  469. if (clear & TIOCM_RTS) {
  470. control_state &= ~TIOCM_RTS;
  471. rts = 0;
  472. }
  473. if (clear & TIOCM_DTR) {
  474. control_state &= ~TIOCM_DTR;
  475. dtr = 0;
  476. }
  477. priv->control_state = control_state;
  478. spin_unlock_irqrestore(&priv->lock, flags);
  479. retval = BSA_USB_CMD(BELKIN_SA_SET_RTS_REQUEST, rts);
  480. if (retval < 0) {
  481. dev_err(&port->dev, "Set RTS error %d\n", retval);
  482. goto exit;
  483. }
  484. retval = BSA_USB_CMD(BELKIN_SA_SET_DTR_REQUEST, dtr);
  485. if (retval < 0) {
  486. dev_err(&port->dev, "Set DTR error %d\n", retval);
  487. goto exit;
  488. }
  489. exit:
  490. return retval;
  491. }
  492. static int __init belkin_sa_init(void)
  493. {
  494. int retval;
  495. retval = usb_serial_register(&belkin_device);
  496. if (retval)
  497. goto failed_usb_serial_register;
  498. retval = usb_register(&belkin_driver);
  499. if (retval)
  500. goto failed_usb_register;
  501. printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
  502. DRIVER_DESC "\n");
  503. return 0;
  504. failed_usb_register:
  505. usb_serial_deregister(&belkin_device);
  506. failed_usb_serial_register:
  507. return retval;
  508. }
  509. static void __exit belkin_sa_exit (void)
  510. {
  511. usb_deregister(&belkin_driver);
  512. usb_serial_deregister(&belkin_device);
  513. }
  514. module_init(belkin_sa_init);
  515. module_exit(belkin_sa_exit);
  516. MODULE_AUTHOR(DRIVER_AUTHOR);
  517. MODULE_DESCRIPTION(DRIVER_DESC);
  518. MODULE_VERSION(DRIVER_VERSION);
  519. MODULE_LICENSE("GPL");
  520. module_param(debug, bool, S_IRUGO | S_IWUSR);
  521. MODULE_PARM_DESC(debug, "Debug enabled or not");