开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
uss720.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：18k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

uss720.c：源码内容
  1. /*****************************************************************************/
  3. /*
  4.  * uss720.c  --  USS720 USB Parport Cable.
  5.  *
  6.  * Copyright (C) 1999
  7.  *     Thomas Sailer (sailer@ife.ee.ethz.ch)
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22.  *
  23.  *  Based on parport_pc.c
  24.  *
  25.  *  History:
  26.  *   0.1  04.08.99  Created
  27.  *   0.2  07.08.99  Some fixes mainly suggested by Tim Waugh
  28.  *     Interrupt handling currently disabled because
  29.  *     usb_request_irq crashes somewhere within ohci.c
  30.  *     for no apparent reason (that is for me, anyway)
  31.  *     ECP currently untested
  32.  *   0.3  10.08.99  fixing merge errors
  33.  *   0.4  13.08.99  Added Vendor/Product ID of Brad Hard's cable
  34.  *   0.5  20.09.99  usb_control_msg wrapper used
  35.  *        Nov01.00  usb_device_table support by Adam J. Richter
  36.  *        08.04.01  Identify version on module load.  gb
  37.  *
  38.  */
  40. /*****************************************************************************/
  42. #include <linux/module.h>
  43. #include <linux/socket.h>
  44. #include <linux/parport.h>
  45. #include <linux/init.h>
  46. #include <linux/usb.h>
  48. /*
  49.  * Version Information
  50.  */
  51. #define DRIVER_VERSION "v0.5"
  52. #define DRIVER_AUTHOR "Thomas M. Sailer, sailer@ife.ee.ethz.ch"
  53. #define DRIVER_DESC "USB Parport Cable driver for Cables using the Lucent Technologies USS720 Chip"
  55. /* --------------------------------------------------------------------- */
  57. struct parport_uss720_private {
  58. struct usb_device *usbdev;
  59. void *irqhandle;
  60. unsigned int irqpipe;
  61. unsigned char reg[7];  /* USB registers */
  62. };
  64. /* --------------------------------------------------------------------- */
  66. static int get_1284_register(struct parport *pp, unsigned char reg, unsigned char *val)
  67. {
  68. struct parport_uss720_private *priv = pp->private_data;
  69. struct usb_device *usbdev = priv->usbdev;
  70. static const unsigned char regindex[9] = {
  71. 4, 0, 1, 5, 5, 0, 2, 3, 6
  72. };
  73. int ret;
  75. if (!usbdev)
  76. return -1;
  77. ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev,0), 3, 0xc0, ((unsigned int)reg) << 8, 0, priv->reg, 7, HZ);
  78. if (ret != 7) {
  79. printk(KERN_DEBUG "uss720: get_1284_register(%d) failed, status 0x%x expected 7n",
  80.        (unsigned int)reg, ret);
  81. ret = -1;
  82. } else {
  83. #if 0
  84. printk(KERN_DEBUG "uss720: get_1284_register(%d) return %02x %02x %02x %02x %02x %02x %02xn",
  85.        (unsigned int)reg, (unsigned int)priv->reg[0], (unsigned int)priv->reg[1],
  86.        (unsigned int)priv->reg[2], (unsigned int)priv->reg[3], (unsigned int)priv->reg[4],
  87.        (unsigned int)priv->reg[5], (unsigned int)priv->reg[6]);
  88. #endif
  89. /* if nAck interrupts are enabled and we have an interrupt, call the interrupt procedure */
  90. if (priv->reg[2] & priv->reg[1] & 0x10)
  91. parport_generic_irq(0, pp, NULL);
  92. ret = 0;
  93. }
  94. if (val)
  95. *val = priv->reg[(reg >= 9) ? 0 : regindex[reg]];
  96. return ret;
  97. }
  99. static int set_1284_register(struct parport *pp, unsigned char reg, unsigned char val)
  100. {
  101. struct parport_uss720_private *priv = pp->private_data;
  102. struct usb_device *usbdev = priv->usbdev;
  103. int ret;
  105. if (!usbdev)
  106. return -1;
  107. ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev,0), 4, 0x40, (((unsigned int)reg) << 8) | val, 0, NULL, 0, HZ);
  108. if (ret) {
  109. printk(KERN_DEBUG "uss720: set_1284_register(%u,0x%02x) failed, status 0x%xn", 
  110.        (unsigned int)reg, (unsigned int)val, ret);
  111. } else {
  112. #if 0
  113. printk(KERN_DEBUG "uss720: set_1284_register(%u,0x%02x)n", 
  114.        (unsigned int)reg, (unsigned int)val);
  115. #endif
  116. }
  117. return ret;
  118. }
  120. /* --------------------------------------------------------------------- */
  122. /* ECR modes */
  123. #define ECR_SPP 00
  124. #define ECR_PS2 01
  125. #define ECR_PPF 02
  126. #define ECR_ECP 03
  127. #define ECR_EPP 04
  129. /* Safely change the mode bits in the ECR */
  130. static int change_mode(struct parport *pp, int m)
  131. {
  132. struct parport_uss720_private *priv = pp->private_data;
  133. int mode;
  135. if (get_1284_register(pp, 6, NULL))
  136. return -EIO;
  137. /* Bits <7:5> contain the mode. */
  138. mode = (priv->reg[2] >> 5) & 0x7;
  139. if (mode == m)
  140. return 0;
  141. /* We have to go through mode 000 or 001 */
  142. if (mode > ECR_PS2 && m > ECR_PS2)
  143. if (change_mode(pp, ECR_PS2))
  144. return -EIO;
  146. if (m <= ECR_PS2 && !(priv->reg[1] & 0x20)) {
  147. /* This mode resets the FIFO, so we may
  148.  * have to wait for it to drain first. */
  149. long expire = jiffies + pp->physport->cad->timeout;
  150. switch (mode) {
  151. case ECR_PPF: /* Parallel Port FIFO mode */
  152. case ECR_ECP: /* ECP Parallel Port mode */
  153. /* Poll slowly. */
  154. for (;;) {
  155. if (get_1284_register(pp, 6, NULL))
  156. return -EIO;
  157. if (priv->reg[2] & 0x01)
  158. break;
  159. if (time_after_eq (jiffies, expire))
  160. /* The FIFO is stuck. */
  161. return -EBUSY;
  162. set_current_state(TASK_INTERRUPTIBLE);
  163. schedule_timeout((HZ + 99) / 100);
  164. if (signal_pending (current))
  165. break;
  166. }
  167. }
  168. }
  169. /* Set the mode. */
  170. if (set_1284_register(pp, 6, m << 5))
  171. return -EIO;
  172. return 0;
  173. }
  175. /*
  176.  * Clear TIMEOUT BIT in EPP MODE
  177.  */
  178. static int clear_epp_timeout(struct parport *pp)
  179. {
  180. unsigned char stat;
  182. if (get_1284_register(pp, 1, &stat))
  183. return 1;
  184. return stat & 1;
  185. }
  187. /*
  188.  * Access functions.
  189.  */
  190. #if 0
  191. static int uss720_irq(int usbstatus, void *buffer, int len, void *dev_id)
  192. {
  193. struct parport *pp = (struct parport *)dev_id;
  194. struct parport_uss720_private *priv = pp->private_data;
  196. if (usbstatus != USB_ST_NOERROR || len < 4 || !buffer)
  197. return 1;
  198. memcpy(priv->reg, buffer, 4);
  199. /* if nAck interrupts are enabled and we have an interrupt, call the interrupt procedure */
  200. if (priv->reg[2] & priv->reg[1] & 0x10)
  201. parport_generic_irq(0, pp, NULL);
  202. return 1;
  203. }
  204. #endif
  206. static void parport_uss720_write_data(struct parport *pp, unsigned char d)
  207. {
  208. set_1284_register(pp, 0, d);
  209. }
  211. static unsigned char parport_uss720_read_data(struct parport *pp)
  212. {
  213. unsigned char ret;
  215. if (get_1284_register(pp, 0, &ret))
  216. return 0;
  217. return ret;
  218. }
  220. static void parport_uss720_write_control(struct parport *pp, unsigned char d)
  221. {
  222. struct parport_uss720_private *priv = pp->private_data;
  224. d = (d & 0xf) | (priv->reg[1] & 0xf0);
  225. if (set_1284_register(pp, 2, d))
  226. return;
  227. priv->reg[1] = d;
  228. }
  230. static unsigned char parport_uss720_read_control(struct parport *pp)
  231. {
  232. struct parport_uss720_private *priv = pp->private_data;
  233. return priv->reg[1] & 0xf; /* Use soft copy */
  234. }
  236. static unsigned char parport_uss720_frob_control(struct parport *pp, unsigned char mask, unsigned char val)
  237. {
  238. struct parport_uss720_private *priv = pp->private_data;
  239. unsigned char d;
  241. mask &= 0x0f;
  242. val &= 0x0f;
  243. d = (priv->reg[1] & (~mask)) ^ val;
  244. if (set_1284_register(pp, 2, d))
  245. return 0;
  246. priv->reg[1] = d;
  247. return d & 0xf;
  248. }
  250. static unsigned char parport_uss720_read_status(struct parport *pp)
  251. {
  252. unsigned char ret;
  254. if (get_1284_register(pp, 1, &ret))
  255. return 0;
  256. return ret & 0xf8;
  257. }
  259. static void parport_uss720_disable_irq(struct parport *pp)
  260. {
  261. struct parport_uss720_private *priv = pp->private_data;
  262. unsigned char d;
  264. d = priv->reg[1] & ~0x10;
  265. if (set_1284_register(pp, 2, d))
  266. return;
  267. priv->reg[1] = d;
  268. }
  270. static void parport_uss720_enable_irq(struct parport *pp)
  271. {
  272. struct parport_uss720_private *priv = pp->private_data;
  273. unsigned char d;
  275. d = priv->reg[1] | 0x10;
  276. if (set_1284_register(pp, 2, d))
  277. return;
  278. priv->reg[1] = d;
  279. }
  281. static void parport_uss720_data_forward (struct parport *pp)
  282. {
  283. struct parport_uss720_private *priv = pp->private_data;
  284. unsigned char d;
  286. d = priv->reg[1] & ~0x20;
  287. if (set_1284_register(pp, 2, d))
  288. return;
  289. priv->reg[1] = d;
  290. }
  292. static void parport_uss720_data_reverse (struct parport *pp)
  293. {
  294. struct parport_uss720_private *priv = pp->private_data;
  295. unsigned char d;
  297. d = priv->reg[1] | 0x20;
  298. if (set_1284_register(pp, 2, d))
  299. return;
  300. priv->reg[1] = d;
  301. }
  303. static void parport_uss720_init_state(struct pardevice *dev, struct parport_state *s)
  304. {
  305. s->u.pc.ctr = 0xc | (dev->irq_func ? 0x10 : 0x0);
  306. s->u.pc.ecr = 0x24;
  307. }
  309. static void parport_uss720_save_state(struct parport *pp, struct parport_state *s)
  310. {
  311. struct parport_uss720_private *priv = pp->private_data;
  313. if (get_1284_register(pp, 2, NULL))
  314. return;
  315. s->u.pc.ctr = priv->reg[1];
  316. s->u.pc.ecr = priv->reg[2];
  317. }
  319. static void parport_uss720_restore_state(struct parport *pp, struct parport_state *s)
  320. {
  321. set_1284_register(pp, 2, s->u.pc.ctr);
  322. set_1284_register(pp, 6, s->u.pc.ecr);
  323. get_1284_register(pp, 2, NULL);
  324. }
  326. static size_t parport_uss720_epp_read_data(struct parport *pp, void *buf, size_t length, int flags)
  327. {
  328. struct parport_uss720_private *priv = pp->private_data;
  329. size_t got = 0;
  331. if (change_mode(pp, ECR_EPP))
  332. return 0;
  333. for (; got < length; got++) {
  334. if (get_1284_register(pp, 4, (char *)buf))
  335. break;
  336. ((char*)buf)++;
  337. if (priv->reg[0] & 0x01) {
  338. clear_epp_timeout(pp);
  339. break;
  340. }
  341. }
  342. change_mode(pp, ECR_PS2);
  343. return got;
  344. }
  346. static size_t parport_uss720_epp_write_data(struct parport *pp, const void *buf, size_t length, int flags)
  347. {
  348. #if 0
  349. struct parport_uss720_private *priv = pp->private_data;
  350. size_t written = 0;
  352. if (change_mode(pp, ECR_EPP))
  353. return 0;
  354. for (; written < length; written++) {
  355. if (set_1284_register(pp, 4, (char *)buf))
  356. break;
  357. ((char*)buf)++;
  358. if (get_1284_register(pp, 1, NULL))
  359. break;
  360. if (priv->reg[0] & 0x01) {
  361. clear_epp_timeout(pp);
  362. break;
  363. }
  364. }
  365. change_mode(pp, ECR_PS2);
  366. return written;
  367. #else
  368. struct parport_uss720_private *priv = pp->private_data;
  369. struct usb_device *usbdev = priv->usbdev;
  370. int rlen;
  371. int i;
  373. if (!usbdev)
  374. return 0;
  375. if (change_mode(pp, ECR_EPP))
  376. return 0;
  377. i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buf, length, &rlen, HZ*20);
  378. if (i)
  379. printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %un", buf, length, rlen);
  380. change_mode(pp, ECR_PS2);
  381. return rlen;
  382. #endif
  383. }
  385. static size_t parport_uss720_epp_read_addr(struct parport *pp, void *buf, size_t length, int flags)
  386. {
  387. struct parport_uss720_private *priv = pp->private_data;
  388. size_t got = 0;
  390. if (change_mode(pp, ECR_EPP))
  391. return 0;
  392. for (; got < length; got++) {
  393. if (get_1284_register(pp, 3, (char *)buf))
  394. break;
  395. ((char*)buf)++;
  396. if (priv->reg[0] & 0x01) {
  397. clear_epp_timeout(pp);
  398. break;
  399. }
  400. }
  401. change_mode(pp, ECR_PS2);
  402. return got;
  403. }
  405. static size_t parport_uss720_epp_write_addr(struct parport *pp, const void *buf, size_t length, int flags)
  406. {
  407. struct parport_uss720_private *priv = pp->private_data;
  408. size_t written = 0;
  410. if (change_mode(pp, ECR_EPP))
  411. return 0;
  412. for (; written < length; written++) {
  413. if (set_1284_register(pp, 3, *(char *)buf))
  414. break;
  415. ((char*)buf)++;
  416. if (get_1284_register(pp, 1, NULL))
  417. break;
  418. if (priv->reg[0] & 0x01) {
  419. clear_epp_timeout(pp);
  420. break;
  421. }
  422. }
  423. change_mode(pp, ECR_PS2);
  424. return written;
  425. }
  427. static size_t parport_uss720_ecp_write_data(struct parport *pp, const void *buffer, size_t len, int flags)
  428. {
  429. struct parport_uss720_private *priv = pp->private_data;
  430. struct usb_device *usbdev = priv->usbdev;
  431. int rlen;
  432. int i;
  434. if (!usbdev)
  435. return 0;
  436. if (change_mode(pp, ECR_ECP))
  437. return 0;
  438. i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, HZ*20);
  439. if (i)
  440. printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %un", buffer, len, rlen);
  441. change_mode(pp, ECR_PS2);
  442. return rlen;
  443. }
  445. static size_t parport_uss720_ecp_read_data(struct parport *pp, void *buffer, size_t len, int flags)
  446. {
  447. struct parport_uss720_private *priv = pp->private_data;
  448. struct usb_device *usbdev = priv->usbdev;
  449. int rlen;
  450. int i;
  452. if (!usbdev)
  453. return 0;
  454. if (change_mode(pp, ECR_ECP))
  455. return 0;
  456. i = usb_bulk_msg(usbdev, usb_rcvbulkpipe(usbdev, 2), buffer, len, &rlen, HZ*20);
  457. if (i)
  458. printk(KERN_ERR "uss720: recvbulk ep 2 buf %p len %Zu rlen %un", buffer, len, rlen);
  459. change_mode(pp, ECR_PS2);
  460. return rlen;
  461. }
  463. static size_t parport_uss720_ecp_write_addr(struct parport *pp, const void *buffer, size_t len, int flags)
  464. {
  465. size_t written = 0;
  467. if (change_mode(pp, ECR_ECP))
  468. return 0;
  469. for (; written < len; written++) {
  470. if (set_1284_register(pp, 5, *(char *)buffer))
  471. break;
  472. ((char*)buffer)++;
  473. }
  474. change_mode(pp, ECR_PS2);
  475. return written;
  476. }
  478. static size_t parport_uss720_write_compat(struct parport *pp, const void *buffer, size_t len, int flags)
  479. {
  480. struct parport_uss720_private *priv = pp->private_data;
  481. struct usb_device *usbdev = priv->usbdev;
  482. int rlen;
  483. int i;
  485. if (!usbdev)
  486. return 0;
  487. if (change_mode(pp, ECR_PPF))
  488. return 0;
  489. i = usb_bulk_msg(usbdev, usb_sndbulkpipe(usbdev, 1), (void *)buffer, len, &rlen, HZ*20);
  490. if (i)
  491. printk(KERN_ERR "uss720: sendbulk ep 1 buf %p len %Zu rlen %un", buffer, len, rlen);
  492. change_mode(pp, ECR_PS2);
  493. return rlen;
  494. }
  496. void parport_uss720_inc_use_count(void)
  497. {
  498. MOD_INC_USE_COUNT;
  499. }
  501. void parport_uss720_dec_use_count(void)
  502. {
  503. MOD_DEC_USE_COUNT;
  504. }
  506. /* --------------------------------------------------------------------- */
  508. static struct parport_operations parport_uss720_ops = 
  509. {
  510. parport_uss720_write_data,
  511. parport_uss720_read_data,
  513. parport_uss720_write_control,
  514. parport_uss720_read_control,
  515. parport_uss720_frob_control,
  517. parport_uss720_read_status,
  519. parport_uss720_enable_irq,
  520. parport_uss720_disable_irq,
  522. parport_uss720_data_forward,
  523. parport_uss720_data_reverse,
  525. parport_uss720_init_state,
  526. parport_uss720_save_state,
  527. parport_uss720_restore_state,
  529. parport_uss720_inc_use_count,
  530. parport_uss720_dec_use_count,
  532. parport_uss720_epp_write_data,
  533. parport_uss720_epp_read_data,
  534. parport_uss720_epp_write_addr,
  535. parport_uss720_epp_read_addr,
  537. parport_uss720_ecp_write_data,
  538. parport_uss720_ecp_read_data,
  539. parport_uss720_ecp_write_addr,
  541. parport_uss720_write_compat,
  542. parport_ieee1284_read_nibble,
  543. parport_ieee1284_read_byte,
  544. };
  546. /* --------------------------------------------------------------------- */
  548. static void * uss720_probe(struct usb_device *usbdev, unsigned int ifnum,
  549.    const struct usb_device_id *id)
  550. {
  551. struct usb_interface_descriptor *interface;
  552. struct usb_endpoint_descriptor *endpoint;
  553. struct parport_uss720_private *priv;
  554. struct parport *pp;
  555. int i;
  557. printk(KERN_DEBUG "uss720: probe: vendor id 0x%x, device id 0x%xn",
  558.        usbdev->descriptor.idVendor, usbdev->descriptor.idProduct);
  560. /* our known interfaces have 3 alternate settings */
  561. if (usbdev->actconfig->interface[ifnum].num_altsetting != 3)
  562. return NULL;
  564. i = usb_set_interface(usbdev, ifnum, 2);
  565. printk(KERN_DEBUG "uss720: set inteface result %dn", i);
  567. interface = &usbdev->actconfig->interface[ifnum].altsetting[2];
  569. /*
  570.  * Allocate parport interface 
  571.  */
  572. printk(KERN_INFO "uss720: (C) 1999 by Thomas Sailer, <sailer@ife.ee.ethz.ch>n");
  574. if (!(priv = kmalloc(sizeof(struct parport_uss720_private), GFP_KERNEL)))
  575. return NULL;
  576. if (!(pp = parport_register_port(0, PARPORT_IRQ_NONE, PARPORT_DMA_NONE, &parport_uss720_ops))) {
  577. printk(KERN_WARNING "usb-uss720: could not register parportn");
  578. goto probe_abort;
  579. }
  581. pp->private_data = priv;
  582. priv->usbdev = usbdev;
  583. pp->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_TRISTATE | PARPORT_MODE_EPP | PARPORT_MODE_ECP | PARPORT_MODE_COMPAT;
  585. /* set the USS720 control register to manual mode, no ECP compression, enable all ints */
  586. set_1284_register(pp, 7, 0x00);
  587. set_1284_register(pp, 6, 0x30);  /* PS/2 mode */
  588. set_1284_register(pp, 2, 0x0c);
  589. /* debugging */
  590. get_1284_register(pp, 0, NULL);
  591. printk("uss720: reg: %02x %02x %02x %02x %02x %02x %02xn",
  592.        priv->reg[0], priv->reg[1], priv->reg[2], priv->reg[3], priv->reg[4], priv->reg[5], priv->reg[6]);
  594. endpoint = &interface->endpoint[2];
  595. printk(KERN_DEBUG "uss720: epaddr %d interval %dn", endpoint->bEndpointAddress, endpoint->bInterval);
  596. #if 0
  597. priv->irqpipe = usb_rcvctrlpipe(usbdev, endpoint->bEndpointAddress);
  598. i = usb_request_irq(usbdev, priv->irqpipe,
  599.   uss720_irq, endpoint->bInterval,
  600.   pp, &priv->irqhandle);
  601. if (i) {
  602. printk (KERN_WARNING "usb-uss720: usb_request_irq failed (0x%x)n", i);
  603. goto probe_abort_port;
  604. }
  605. #endif
  606. parport_proc_register(pp);
  607. parport_announce_port(pp);
  609. MOD_INC_USE_COUNT;
  610. return pp;
  612. #if 0
  613. probe_abort_port:
  614. parport_unregister_port(pp);
  615. #endif
  616. probe_abort:
  617. kfree(priv);
  618. return NULL;
  619. }
  621. static void uss720_disconnect(struct usb_device *usbdev, void *ptr)
  622. {
  623. struct parport *pp = (struct parport *)ptr;
  624. struct parport_uss720_private *priv = pp->private_data;
  626. #if 0
  627. usb_release_irq(usbdev, priv->irqhandle, priv->irqpipe);
  628. #endif
  629. priv->usbdev = NULL;
  630. parport_proc_unregister(pp);
  631. parport_unregister_port(pp);
  632. kfree(priv);
  633. MOD_DEC_USE_COUNT;
  634. }
  636. /* table of cables that work through this driver */
  637. static struct usb_device_id uss720_table [] = {
  638. { USB_DEVICE(0x047e, 0x1001) },
  639. { USB_DEVICE(0x0557, 0x2001) },
  640. { USB_DEVICE(0x0729, 0x1284) },
  641. { USB_DEVICE(0x1293, 0x0002) },
  642. { } /* Terminating entry */
  643. };
  645. MODULE_DEVICE_TABLE (usb, uss720_table);
  648. static struct usb_driver uss720_driver = {
  649. name: "uss720",
  650. probe: uss720_probe,
  651. disconnect: uss720_disconnect,
  652. id_table: uss720_table,
  653. };
  655. /* --------------------------------------------------------------------- */
  657. MODULE_AUTHOR( DRIVER_AUTHOR );
  658. MODULE_DESCRIPTION( DRIVER_DESC );
  659. MODULE_LICENSE("GPL");
  661. static int __init uss720_init(void)
  662. {
  663. if (usb_register(&uss720_driver) < 0)
  664. return -1;
  666. info(DRIVER_VERSION ":" DRIVER_DESC);
  667. return 0;
  668. }
  670. static void __exit uss720_cleanup(void)
  671. {
  672. usb_deregister(&uss720_driver);
  673. }
  675. module_init(uss720_init);
  676. module_exit(uss720_cleanup);
  678. /* --------------------------------------------------------------------- */