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

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

Linux/Unix编程

开发平台：

Unix_Linux

dabusb.c：源码内容
  1. /*****************************************************************************/
  3. /*
  4.  *      dabusb.c  --  dab usb driver.
  5.  *
  6.  *      Copyright (C) 1999  Deti Fliegl (deti@fliegl.de)
  7.  *
  8.  *      This program is free software; you can redistribute it and/or modify
  9.  *      it under the terms of the GNU General Public License as published by
  10.  *      the Free Software Foundation; either version 2 of the License, or
  11.  *      (at your option) any later version.
  12.  *
  13.  *      This program is distributed in the hope that it will be useful,
  14.  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *      GNU General Public License for more details.
  17.  *
  18.  *      You should have received a copy of the GNU General Public License
  19.  *      along with this program; if not, write to the Free Software
  20.  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  *
  22.  *
  23.  *
  24.  *  $Id: dabusb.c,v 1.54 2000/07/24 21:39:39 deti Exp $
  25.  *
  26.  */
  28. /*****************************************************************************/
  30. #include <linux/module.h>
  31. #include <linux/socket.h>
  32. #include <linux/miscdevice.h>
  33. #include <linux/list.h>
  34. #include <linux/vmalloc.h>
  35. #include <linux/slab.h>
  36. #include <linux/init.h>
  37. #include <asm/uaccess.h>
  38. #include <asm/atomic.h>
  39. #include <linux/delay.h>
  40. #include <linux/usb.h>
  41. #include <linux/smp_lock.h>
  43. #include "dabusb.h"
  44. #include "dabfirmware.h"
  46. /*
  47.  * Version Information
  48.  */
  49. #define DRIVER_VERSION "v1.54"
  50. #define DRIVER_AUTHOR "Deti Fliegl, deti@fliegl.de"
  51. #define DRIVER_DESC "DAB-USB Interface Driver for Linux (c)1999"
  53. /* --------------------------------------------------------------------- */
  55. #define NRDABUSB 4
  57. /*-------------------------------------------------------------------*/
  59. static dabusb_t dabusb[NRDABUSB];
  60. static int buffers = 256;
  62. /*-------------------------------------------------------------------*/
  64. static int dabusb_add_buf_tail (pdabusb_t s, struct list_head *dst, struct list_head *src)
  65. {
  66. unsigned long flags;
  67. struct list_head *tmp;
  68. int ret = 0;
  70. spin_lock_irqsave (&s->lock, flags);
  72. if (list_empty (src)) {
  73. // no elements in source buffer
  74. ret = -1;
  75. goto err;
  76. }
  77. tmp = src->next;
  78. list_del (tmp);
  79. list_add_tail (tmp, dst);
  81.   err: spin_unlock_irqrestore (&s->lock, flags);
  82. return ret;
  83. }
  84. /*-------------------------------------------------------------------*/
  85. #ifdef DEBUG 
  86. static void dump_urb (struct urb *purb)
  87. {
  88. dbg("urb                   :%p", purb);
  89. dbg("next                  :%p", purb->next);
  90. dbg("dev                   :%p", purb->dev);
  91. dbg("pipe                  :%08X", purb->pipe);
  92. dbg("status                :%d", purb->status);
  93. dbg("transfer_flags        :%08X", purb->transfer_flags);
  94. dbg("transfer_buffer       :%p", purb->transfer_buffer);
  95. dbg("transfer_buffer_length:%d", purb->transfer_buffer_length);
  96. dbg("actual_length         :%d", purb->actual_length);
  97. dbg("setup_packet          :%p", purb->setup_packet);
  98. dbg("start_frame           :%d", purb->start_frame);
  99. dbg("number_of_packets     :%d", purb->number_of_packets);
  100. dbg("interval              :%d", purb->interval);
  101. dbg("error_count           :%d", purb->error_count);
  102. dbg("context               :%p", purb->context);
  103. dbg("complete              :%p", purb->complete);
  104. }
  105. #endif
  106. /*-------------------------------------------------------------------*/
  107. static int dabusb_cancel_queue (pdabusb_t s, struct list_head *q)
  108. {
  109. unsigned long flags;
  110. struct list_head *p;
  111. pbuff_t b;
  113. dbg("dabusb_cancel_queue");
  115. spin_lock_irqsave (&s->lock, flags);
  117. for (p = q->next; p != q; p = p->next) {
  118. b = list_entry (p, buff_t, buff_list);
  120. #ifdef DEBUG
  121. dump_urb(b->purb);
  122. #endif
  123. usb_unlink_urb (b->purb);
  124. }
  125. spin_unlock_irqrestore (&s->lock, flags);
  126. return 0;
  127. }
  128. /*-------------------------------------------------------------------*/
  129. static int dabusb_free_queue (struct list_head *q)
  130. {
  131. struct list_head *tmp;
  132. struct list_head *p;
  133. pbuff_t b;
  135. dbg("dabusb_free_queue");
  136. for (p = q->next; p != q;) {
  137. b = list_entry (p, buff_t, buff_list);
  139. #ifdef DEBUG 
  140. dump_urb(b->purb);
  141. #endif
  142. if (b->purb->transfer_buffer)
  143. kfree (b->purb->transfer_buffer);
  144. usb_free_urb(b->purb);
  145. tmp = p->next;
  146. list_del (p);
  147. kfree (b);
  148. p = tmp;
  149. }
  151. return 0;
  152. }
  153. /*-------------------------------------------------------------------*/
  154. static int dabusb_free_buffers (pdabusb_t s)
  155. {
  156. unsigned long flags;
  157. dbg("dabusb_free_buffers");
  159. spin_lock_irqsave(&s->lock, flags);
  161. dabusb_free_queue (&s->free_buff_list);
  162. dabusb_free_queue (&s->rec_buff_list);
  164. spin_unlock_irqrestore(&s->lock, flags);
  166. s->got_mem = 0;
  167. return 0;
  168. }
  169. /*-------------------------------------------------------------------*/
  170. static void dabusb_iso_complete (struct urb *purb)
  171. {
  172. pbuff_t b = purb->context;
  173. pdabusb_t s = b->s;
  174. int i;
  175. int len;
  176. int dst = 0;
  177. void *buf = purb->transfer_buffer;
  179. dbg("dabusb_iso_complete");
  181. // process if URB was not killed
  182. if (purb->status != -ENOENT) {
  183. unsigned int pipe = usb_rcvisocpipe (purb->dev, _DABUSB_ISOPIPE);
  184. int pipesize = usb_maxpacket (purb->dev, pipe, usb_pipeout (pipe));
  185. for (i = 0; i < purb->number_of_packets; i++)
  186. if (!purb->iso_frame_desc[i].status) {
  187. len = purb->iso_frame_desc[i].actual_length;
  188. if (len <= pipesize) {
  189. memcpy (buf + dst, buf + purb->iso_frame_desc[i].offset, len);
  190. dst += len;
  191. }
  192. else
  193. err("dabusb_iso_complete: invalid len %d", len);
  194. }
  195. else
  196. warn("dabusb_iso_complete: corrupted packet status: %d", purb->iso_frame_desc[i].status);
  197. if (dst != purb->actual_length)
  198. err("dst!=purb->actual_length:%d!=%d", dst, purb->actual_length);
  199. }
  201. if (atomic_dec_and_test (&s->pending_io) && !s->remove_pending && s->state != _stopped) {
  202. s->overruns++;
  203. err("overrun (%d)", s->overruns);
  204. }
  205. wake_up (&s->wait);
  206. }
  207. /*-------------------------------------------------------------------*/
  208. static int dabusb_alloc_buffers (pdabusb_t s)
  209. {
  210. int buffers = 0;
  211. pbuff_t b;
  212. unsigned int pipe = usb_rcvisocpipe (s->usbdev, _DABUSB_ISOPIPE);
  213. int pipesize = usb_maxpacket (s->usbdev, pipe, usb_pipeout (pipe));
  214. int packets = _ISOPIPESIZE / pipesize;
  215. int transfer_buffer_length = packets * pipesize;
  216. int i;
  218. dbg("dabusb_alloc_buffers pipesize:%d packets:%d transfer_buffer_len:%d",
  219.  pipesize, packets, transfer_buffer_length);
  221. while (buffers < (s->total_buffer_size << 10)) {
  222. b = (pbuff_t) kmalloc (sizeof (buff_t), GFP_KERNEL);
  223. if (!b) {
  224. err("kmalloc(sizeof(buff_t))==NULL");
  225. goto err;
  226. }
  227. memset (b, 0, sizeof (buff_t));
  228. b->s = s;
  229. b->purb = usb_alloc_urb(packets);
  230. if (!b->purb) {
  231. err("usb_alloc_urb == NULL");
  232. kfree (b);
  233. goto err;
  234. }
  236. b->purb->transfer_buffer = kmalloc (transfer_buffer_length, GFP_KERNEL);
  237. if (!b->purb->transfer_buffer) {
  238. kfree (b->purb);
  239. kfree (b);
  240. err("kmalloc(%d)==NULL", transfer_buffer_length);
  241. goto err;
  242. }
  244. b->purb->transfer_buffer_length = transfer_buffer_length;
  245. b->purb->number_of_packets = packets;
  246. b->purb->complete = dabusb_iso_complete;
  247. b->purb->context = b;
  248. b->purb->dev = s->usbdev;
  249. b->purb->pipe = pipe;
  250. b->purb->transfer_flags = USB_ISO_ASAP;
  252. for (i = 0; i < packets; i++) {
  253. b->purb->iso_frame_desc[i].offset = i * pipesize;
  254. b->purb->iso_frame_desc[i].length = pipesize;
  255. }
  257. buffers += transfer_buffer_length;
  258. list_add_tail (&b->buff_list, &s->free_buff_list);
  259. }
  260. s->got_mem = buffers;
  262. return 0;
  264. err:
  265. dabusb_free_buffers (s);
  266. return -ENOMEM;
  267. }
  268. /*-------------------------------------------------------------------*/
  269. static int dabusb_bulk (pdabusb_t s, pbulk_transfer_t pb)
  270. {
  271. int ret;
  272. unsigned int pipe;
  273. int actual_length;
  275. dbg("dabusb_bulk");
  277. if (!pb->pipe)
  278. pipe = usb_rcvbulkpipe (s->usbdev, 2);
  279. else
  280. pipe = usb_sndbulkpipe (s->usbdev, 2);
  282. ret=usb_bulk_msg(s->usbdev, pipe, pb->data, pb->size, &actual_length, 100);
  283. if(ret<0) {
  284. err("dabusb: usb_bulk_msg failed(%d)",ret);
  286. if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
  287. err("set_interface failed");
  288. return -EINVAL;
  289. }
  291. }
  293. if( ret == -EPIPE ) {
  294. warn("CLEAR_FEATURE request to remove STALL condition.");
  295. if(usb_clear_halt(s->usbdev, usb_pipeendpoint(pipe)))
  296. err("request failed");
  297. }
  299. pb->size = actual_length;
  300. return ret;
  301. }
  302. /* --------------------------------------------------------------------- */
  303. static int dabusb_writemem (pdabusb_t s, int pos, unsigned char *data, int len)
  304. {
  305. int ret;
  306. unsigned char *transfer_buffer =  kmalloc (len, GFP_KERNEL);
  308. if (!transfer_buffer) {
  309. err("dabusb_writemem: kmalloc(%d) failed.", len);
  310. return -ENOMEM;
  311. }
  313. memcpy (transfer_buffer, data, len);
  315. ret=usb_control_msg(s->usbdev, usb_sndctrlpipe( s->usbdev, 0 ), 0xa0, 0x40, pos, 0, transfer_buffer, len, 300);
  317. kfree (transfer_buffer);
  318. return ret;
  319. }
  320. /* --------------------------------------------------------------------- */
  321. static int dabusb_8051_reset (pdabusb_t s, unsigned char reset_bit)
  322. {
  323. dbg("dabusb_8051_reset: %d",reset_bit);
  324. return dabusb_writemem (s, CPUCS_REG, &reset_bit, 1);
  325. }
  326. /* --------------------------------------------------------------------- */
  327. static int dabusb_loadmem (pdabusb_t s, const char *fname)
  328. {
  329. int ret;
  330. PINTEL_HEX_RECORD ptr = firmware;
  332. dbg("Enter dabusb_loadmem (internal)");
  334. ret = dabusb_8051_reset (s, 1);
  335. while (ptr->Type == 0) {
  337. dbg("dabusb_writemem: %04X %p %d)", ptr->Address, ptr->Data, ptr->Length);
  339. ret = dabusb_writemem (s, ptr->Address, ptr->Data, ptr->Length);
  340. if (ret < 0) {
  341. err("dabusb_writemem failed (%d %04X %p %d)", ret, ptr->Address, ptr->Data, ptr->Length);
  342. break;
  343. }
  344. ptr++;
  345. }
  346. ret = dabusb_8051_reset (s, 0);
  348. dbg("dabusb_loadmem: exit");
  350. return ret;
  351. }
  352. /* --------------------------------------------------------------------- */
  353. static int dabusb_fpga_clear (pdabusb_t s, pbulk_transfer_t b)
  354. {
  355. b->size = 4;
  356. b->data[0] = 0x2a;
  357. b->data[1] = 0;
  358. b->data[2] = 0;
  359. b->data[3] = 0;
  361. dbg("dabusb_fpga_clear");
  363. return dabusb_bulk (s, b);
  364. }
  365. /* --------------------------------------------------------------------- */
  366. static int dabusb_fpga_init (pdabusb_t s, pbulk_transfer_t b)
  367. {
  368. b->size = 4;
  369. b->data[0] = 0x2c;
  370. b->data[1] = 0;
  371. b->data[2] = 0;
  372. b->data[3] = 0;
  374. dbg("dabusb_fpga_init");
  376. return dabusb_bulk (s, b);
  377. }
  378. /* --------------------------------------------------------------------- */
  379. static int dabusb_fpga_download (pdabusb_t s, const char *fname)
  380. {
  381. pbulk_transfer_t b = kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
  382. unsigned int blen, n;
  383. int ret;
  384. unsigned char *buf = bitstream;
  386. dbg("Enter dabusb_fpga_download (internal)");
  388. if (!b) {
  389. err("kmalloc(sizeof(bulk_transfer_t))==NULL");
  390. return -ENOMEM;
  391. }
  393. b->pipe = 1;
  394. ret = dabusb_fpga_clear (s, b);
  395. mdelay (10);
  396. blen = buf[73] + (buf[72] << 8);
  398. dbg("Bitstream len: %i", blen);
  400. b->data[0] = 0x2b;
  401. b->data[1] = 0;
  402. b->data[2] = 0;
  403. b->data[3] = 60;
  405. for (n = 0; n <= blen + 60; n += 60) {
  406. // some cclks for startup
  407. b->size = 64;
  408. memcpy (b->data + 4, buf + 74 + n, 60);
  409. ret = dabusb_bulk (s, b);
  410. if (ret < 0) {
  411. err("dabusb_bulk failed.");
  412. break;
  413. }
  414. mdelay (1);
  415. }
  417. ret = dabusb_fpga_init (s, b);
  418. kfree (b);
  420. dbg("exit dabusb_fpga_download");
  422. return ret;
  423. }
  425. static int dabusb_stop (pdabusb_t s)
  426. {
  427. dbg("dabusb_stop");
  429. s->state = _stopped;
  430. dabusb_cancel_queue (s, &s->rec_buff_list);
  432. dbg("pending_io: %d", s->pending_io.counter);
  434. s->pending_io.counter = 0;
  435. return 0;
  436. }
  438. static int dabusb_startrek (pdabusb_t s)
  439. {
  440. if (!s->got_mem && s->state != _started) {
  442. dbg("dabusb_startrek");
  444. if (dabusb_alloc_buffers (s) < 0)
  445. return -ENOMEM;
  446. dabusb_stop (s);
  447. s->state = _started;
  448. s->readptr = 0;
  449. }
  451. if (!list_empty (&s->free_buff_list)) {
  452. pbuff_t end;
  453. int ret;
  455. while (!dabusb_add_buf_tail (s, &s->rec_buff_list, &s->free_buff_list)) {
  457. dbg("submitting: end:%p s->rec_buff_list:%p", s->rec_buff_list.prev, &s->rec_buff_list);
  459. end = list_entry (s->rec_buff_list.prev, buff_t, buff_list);
  461. ret = usb_submit_urb (end->purb);
  462. if (ret) {
  463. err("usb_submit_urb returned:%d", ret);
  464. if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
  465. err("startrek: dabusb_add_buf_tail failed");
  466. break;
  467. }
  468. else
  469. atomic_inc (&s->pending_io);
  470. }
  471. dbg("pending_io: %d",s->pending_io.counter);
  472. }
  474. return 0;
  475. }
  477. static ssize_t dabusb_read (struct file *file, char *buf, size_t count, loff_t * ppos)
  478. {
  479. pdabusb_t s = (pdabusb_t) file->private_data;
  480. unsigned long flags;
  481. unsigned ret = 0;
  482. int rem;
  483. int cnt;
  484. pbuff_t b;
  485. struct urb *purb = NULL;
  487. dbg("dabusb_read");
  489. if (*ppos)
  490. return -ESPIPE;
  492. if (s->remove_pending)
  493. return -EIO;
  496. if (!s->usbdev)
  497. return -EIO;
  499. while (count > 0) {
  500. dabusb_startrek (s);
  502. spin_lock_irqsave (&s->lock, flags);
  504. if (list_empty (&s->rec_buff_list)) {
  506. spin_unlock_irqrestore(&s->lock, flags);
  508. err("error: rec_buf_list is empty");
  509. goto err;
  510. }
  512. b = list_entry (s->rec_buff_list.next, buff_t, buff_list);
  513. purb = b->purb;
  515. spin_unlock_irqrestore(&s->lock, flags);
  517. if (purb->status == -EINPROGRESS) {
  518. if (file->f_flags & O_NONBLOCK) // return nonblocking
  519.  {
  520. if (!ret)
  521. ret = -EAGAIN;
  522. goto err;
  523. }
  525. interruptible_sleep_on (&s->wait);
  527. if (signal_pending (current)) {
  528. if (!ret)
  529. ret = -ERESTARTSYS;
  530. goto err;
  531. }
  533. spin_lock_irqsave (&s->lock, flags);
  535. if (list_empty (&s->rec_buff_list)) {
  536. spin_unlock_irqrestore(&s->lock, flags);
  537. err("error: still no buffer available.");
  538. goto err;
  539. }
  540. spin_unlock_irqrestore(&s->lock, flags);
  541. s->readptr = 0;
  542. }
  543. if (s->remove_pending) {
  544. ret = -EIO;
  545. goto err;
  546. }
  548. rem = purb->actual_length - s->readptr; // set remaining bytes to copy
  550. if (count >= rem)
  551. cnt = rem;
  552. else
  553. cnt = count;
  555. dbg("copy_to_user:%p %p %d",buf, purb->transfer_buffer + s->readptr, cnt);
  557. if (copy_to_user (buf, purb->transfer_buffer + s->readptr, cnt)) {
  558. err("read: copy_to_user failed");
  559. if (!ret)
  560. ret = -EFAULT;
  561. goto err;
  562. }
  564. s->readptr += cnt;
  565. count -= cnt;
  566. buf += cnt;
  567. ret += cnt;
  569. if (s->readptr == purb->actual_length) {
  570. // finished, take next buffer
  571. if (dabusb_add_buf_tail (s, &s->free_buff_list, &s->rec_buff_list))
  572. err("read: dabusb_add_buf_tail failed");
  573. s->readptr = 0;
  574. }
  575. }
  576.       err: //up(&s->mutex);
  577. return ret;
  578. }
  580. static int dabusb_open (struct inode *inode, struct file *file)
  581. {
  582. int devnum = MINOR (inode->i_rdev);
  583. pdabusb_t s;
  585. if (devnum < DABUSB_MINOR || devnum >= (DABUSB_MINOR + NRDABUSB))
  586. return -EIO;
  588. s = &dabusb[devnum - DABUSB_MINOR];
  590. dbg("dabusb_open");
  591. down (&s->mutex);
  593. while (!s->usbdev || s->opened) {
  594. up (&s->mutex);
  596. if (file->f_flags & O_NONBLOCK) {
  597. return -EBUSY;
  598. }
  599. schedule_timeout (HZ / 2);
  601. if (signal_pending (current)) {
  602. return -EAGAIN;
  603. }
  604. down (&s->mutex);
  605. }
  606. if (usb_set_interface (s->usbdev, _DABUSB_IF, 1) < 0) {
  607. err("set_interface failed");
  608. up(&s->mutex);
  609. return -EINVAL;
  610. }
  611. s->opened = 1;
  612. up (&s->mutex);
  614. file->f_pos = 0;
  615. file->private_data = s;
  617. return 0;
  618. }
  620. static int dabusb_release (struct inode *inode, struct file *file)
  621. {
  622. pdabusb_t s = (pdabusb_t) file->private_data;
  624. dbg("dabusb_release");
  626. lock_kernel();
  627. down (&s->mutex);
  628. dabusb_stop (s);
  629. dabusb_free_buffers (s);
  630. up (&s->mutex);
  632. if (!s->remove_pending) {
  633. if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0)
  634. err("set_interface failed");
  635. }
  636. else
  637. wake_up (&s->remove_ok);
  639. s->opened = 0;
  640. unlock_kernel();
  641. return 0;
  642. }
  644. static int dabusb_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  645. {
  646. pdabusb_t s = (pdabusb_t) file->private_data;
  647. pbulk_transfer_t pbulk;
  648. int ret = 0;
  649. int version = DABUSB_VERSION;
  651. dbg("dabusb_ioctl");
  653. if (s->remove_pending)
  654. return -EIO;
  656. down (&s->mutex);
  658. if (!s->usbdev) {
  659. up (&s->mutex);
  660. return -EIO;
  661. }
  663. switch (cmd) {
  665. case IOCTL_DAB_BULK:
  666. pbulk = (pbulk_transfer_t) kmalloc (sizeof (bulk_transfer_t), GFP_KERNEL);
  668. if (!pbulk) {
  669. ret = -ENOMEM;
  670. break;
  671. }
  673. if (copy_from_user (pbulk, (void *) arg, sizeof (bulk_transfer_t))) {
  674. ret = -EFAULT;
  675. kfree (pbulk);
  676. break;
  677. }
  679. ret=dabusb_bulk (s, pbulk);
  680. if(ret==0)
  681. ret = copy_to_user ((void *) arg, pbulk, sizeof (bulk_transfer_t));
  682. kfree (pbulk);
  683. break;
  685. case IOCTL_DAB_OVERRUNS:
  686. ret = put_user (s->overruns, (unsigned int *) arg);
  687. break;
  689. case IOCTL_DAB_VERSION:
  690. ret = put_user (version, (unsigned int *) arg);
  691. break;
  693. default:
  694. ret = -ENOIOCTLCMD;
  695. break;
  696. }
  697. up (&s->mutex);
  698. return ret;
  699. }
  701. static struct file_operations dabusb_fops =
  702. {
  703. owner: THIS_MODULE,
  704. llseek: no_llseek,
  705. read: dabusb_read,
  706. ioctl: dabusb_ioctl,
  707. open: dabusb_open,
  708. release: dabusb_release,
  709. };
  711. static int dabusb_find_struct (void)
  712. {
  713. int u;
  715. for (u = 0; u < NRDABUSB; u++) {
  716. pdabusb_t s = &dabusb[u];
  717. if (!s->usbdev)
  718. return u;
  719. }
  720. return -1;
  721. }
  723. /* --------------------------------------------------------------------- */
  724. static void *dabusb_probe (struct usb_device *usbdev, unsigned int ifnum,
  725.    const struct usb_device_id *id)
  726. {
  727. int devnum;
  728. pdabusb_t s;
  730. dbg("dabusb: probe: vendor id 0x%x, device id 0x%x ifnum:%d",
  731.   usbdev->descriptor.idVendor, usbdev->descriptor.idProduct, ifnum);
  733. /* We don't handle multiple configurations */
  734. if (usbdev->descriptor.bNumConfigurations != 1)
  735. return NULL;
  737. if (ifnum != _DABUSB_IF && usbdev->descriptor.idProduct == 0x9999)
  738. return NULL;
  740. devnum = dabusb_find_struct ();
  741. if (devnum == -1)
  742. return NULL;
  744. s = &dabusb[devnum];
  746. down (&s->mutex);
  747. s->remove_pending = 0;
  748. s->usbdev = usbdev;
  750. if (usb_set_configuration (usbdev, usbdev->config[0].bConfigurationValue) < 0) {
  751. err("set_configuration failed");
  752. goto reject;
  753. }
  754. if (usbdev->descriptor.idProduct == 0x2131) {
  755. dabusb_loadmem (s, NULL);
  756. goto reject;
  757. }
  758. else {
  759. dabusb_fpga_download (s, NULL);
  761. if (usb_set_interface (s->usbdev, _DABUSB_IF, 0) < 0) {
  762. err("set_interface failed");
  763. goto reject;
  764. }
  765. }
  766. dbg("bound to interface: %d", ifnum);
  767. up (&s->mutex);
  768. MOD_INC_USE_COUNT;
  769. return s;
  771.       reject:
  772. up (&s->mutex);
  773. s->usbdev = NULL;
  774. return NULL;
  775. }
  777. static void dabusb_disconnect (struct usb_device *usbdev, void *ptr)
  778. {
  779. pdabusb_t s = (pdabusb_t) ptr;
  781. dbg("dabusb_disconnect");
  783. s->remove_pending = 1;
  784. wake_up (&s->wait);
  785. if (s->state == _started)
  786. sleep_on (&s->remove_ok);
  787. s->usbdev = NULL;
  788. s->overruns = 0;
  789. MOD_DEC_USE_COUNT;
  790. }
  792. static struct usb_device_id dabusb_ids [] = {
  793. { USB_DEVICE(0x0547, 0x2131) },
  794. { USB_DEVICE(0x0547, 0x9999) },
  795. { } /* Terminating entry */
  796. };
  798. MODULE_DEVICE_TABLE (usb, dabusb_ids);
  800. static struct usb_driver dabusb_driver =
  801. {
  802. name: "dabusb",
  803. probe: dabusb_probe,
  804. disconnect: dabusb_disconnect,
  805. fops: &dabusb_fops,
  806. minor: DABUSB_MINOR,
  807. id_table: dabusb_ids,
  808. };
  810. /* --------------------------------------------------------------------- */
  812. static int __init dabusb_init (void)
  813. {
  814. unsigned u;
  816. /* initialize struct */
  817. for (u = 0; u < NRDABUSB; u++) {
  818. pdabusb_t s = &dabusb[u];
  819. memset (s, 0, sizeof (dabusb_t));
  820. init_MUTEX (&s->mutex);
  821. s->usbdev = NULL;
  822. s->total_buffer_size = buffers;
  823. init_waitqueue_head (&s->wait);
  824. init_waitqueue_head (&s->remove_ok);
  825. spin_lock_init (&s->lock);
  826. INIT_LIST_HEAD (&s->free_buff_list);
  827. INIT_LIST_HEAD (&s->rec_buff_list);
  828. }
  830. /* register misc device */
  831. if (usb_register(&dabusb_driver))
  832. return -1;
  834. dbg("dabusb_init: driver registered");
  836. info(DRIVER_VERSION ":" DRIVER_DESC);
  838. return 0;
  839. }
  841. static void __exit dabusb_cleanup (void)
  842. {
  843. dbg("dabusb_cleanup");
  845. usb_deregister (&dabusb_driver);
  846. }
  848. /* --------------------------------------------------------------------- */
  850. MODULE_AUTHOR( DRIVER_AUTHOR );
  851. MODULE_DESCRIPTION( DRIVER_DESC );
  852. MODULE_LICENSE("GPL");
  854. MODULE_PARM (buffers, "i");
  855. MODULE_PARM_DESC (buffers, "Number of buffers (default=256)");
  857. module_init (dabusb_init);
  858. module_exit (dabusb_cleanup);
  860. /* --------------------------------------------------------------------- */