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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
cpia_usb.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

cpia_usb.c：源码内容
  1. /*
  2.  * cpia_usb CPiA USB driver
  3.  *
  4.  * Supports CPiA based parallel port Video Camera's.
  5.  *
  6.  * Copyright (C) 1999        Jochen Scharrlach <Jochen.Scharrlach@schwaben.de>
  7.  * Copyright (C) 1999, 2000  Johannes Erdfelt <johannes@erdfelt.com>
  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.  */
  24. #include <linux/module.h>
  25. #include <linux/kernel.h>
  26. #include <linux/init.h>
  27. #include <linux/wait.h>
  28. #include <linux/sched.h>
  29. #include <linux/list.h>
  30. #include <linux/slab.h>
  31. #include <linux/vmalloc.h>
  32. #include <linux/usb.h>
  34. #include "cpia.h"
  36. #define USB_REQ_CPIA_GRAB_FRAME 0xC1
  37. #define USB_REQ_CPIA_UPLOAD_FRAME 0xC2
  38. #define  WAIT_FOR_NEXT_FRAME 0
  39. #define  FORCE_FRAME_UPLOAD 1
  41. #define FRAMES_PER_DESC 10
  42. #define FRAME_SIZE_PER_DESC 960 /* Shouldn't be hardcoded */
  43. #define CPIA_NUMSBUF 2
  44. #define STREAM_BUF_SIZE (PAGE_SIZE * 4)
  45. #define SCRATCH_BUF_SIZE (STREAM_BUF_SIZE * 2)
  47. struct cpia_sbuf {
  48. char *data;
  49. urb_t *urb;
  50. };
  52. #define FRAMEBUF_LEN (CPIA_MAX_FRAME_SIZE+100)
  53. enum framebuf_status {
  54. FRAME_EMPTY,
  55. FRAME_READING,
  56. FRAME_READY,
  57. FRAME_ERROR,
  58. };
  60. struct framebuf {
  61. int length;
  62. enum framebuf_status status;
  63. u8 data[FRAMEBUF_LEN];
  64. struct framebuf *next;
  65. };
  67. struct usb_cpia {
  68. /* Device structure */
  69. struct usb_device *dev;
  71. unsigned char iface;
  72. wait_queue_head_t wq_stream;
  74. int cursbuf; /* Current receiving sbuf */
  75. struct cpia_sbuf sbuf[CPIA_NUMSBUF]; /* Double buffering */
  77. int streaming;
  78. int open;
  79. int present;
  80. struct framebuf *buffers[3];
  81. struct framebuf *curbuff, *workbuff;
  82. };
  84. static int cpia_usb_open(void *privdata);
  85. static int cpia_usb_registerCallback(void *privdata, void (*cb) (void *cbdata),
  86.              void *cbdata);
  87. static int cpia_usb_transferCmd(void *privdata, u8 *command, u8 *data);
  88. static int cpia_usb_streamStart(void *privdata);
  89. static int cpia_usb_streamStop(void *privdata);
  90. static int cpia_usb_streamRead(void *privdata, u8 *frame, int noblock);
  91. static int cpia_usb_close(void *privdata);
  93. #define ABOUT "USB driver for Vision CPiA based cameras"
  95. static struct cpia_camera_ops cpia_usb_ops = {
  96. cpia_usb_open,
  97. cpia_usb_registerCallback,
  98. cpia_usb_transferCmd,
  99. cpia_usb_streamStart,
  100. cpia_usb_streamStop,
  101. cpia_usb_streamRead,
  102. cpia_usb_close,
  103. 0
  104. };
  106. static struct cam_data *cam_list;
  107. static spinlock_t cam_list_lock_usb;
  109. static void cpia_usb_complete(struct urb *urb)
  110. {
  111. int i;
  112. char *cdata;
  113. struct usb_cpia *ucpia;
  115. if (!urb || !urb->context)
  116. return;
  118. ucpia = (struct usb_cpia *) urb->context;
  120. if (!ucpia->dev || !ucpia->streaming || !ucpia->present || !ucpia->open)
  121. return;
  123. if (ucpia->workbuff->status == FRAME_EMPTY) {
  124. ucpia->workbuff->status = FRAME_READING;
  125. ucpia->workbuff->length = 0;
  126. }
  127.     
  128. for (i = 0; i < urb->number_of_packets; i++) {
  129. int n = urb->iso_frame_desc[i].actual_length;
  130. int st = urb->iso_frame_desc[i].status;
  132. cdata = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
  134. if (st)
  135. printk(KERN_DEBUG "cpia data error: [%d] len=%d, status=%Xn", i, n, st);
  137. if (FRAMEBUF_LEN < ucpia->workbuff->length + n) {
  138. printk(KERN_DEBUG "cpia: scratch buf overflow!scr_len: %d, n: %dn", ucpia->workbuff->length, n);
  139. return;
  140. }
  141.     
  142. if (n) {
  143. if ((ucpia->workbuff->length > 0) || 
  144.     (0x19 == cdata[0] && 0x68 == cdata[1])) {
  145. memcpy(ucpia->workbuff->data + ucpia->workbuff->length, cdata, n);
  146. ucpia->workbuff->length += n;
  147. } else
  148. DBG("Ignoring packet!n");
  149. } else {
  150. if (ucpia->workbuff->length > 4 &&
  151.     0xff == ucpia->workbuff->data[ucpia->workbuff->length-1] &&
  152.     0xff == ucpia->workbuff->data[ucpia->workbuff->length-2] &&
  153.     0xff == ucpia->workbuff->data[ucpia->workbuff->length-3] &&
  154.     0xff == ucpia->workbuff->data[ucpia->workbuff->length-4]) {
  155. ucpia->workbuff->status = FRAME_READY;
  156. ucpia->curbuff = ucpia->workbuff;
  157. ucpia->workbuff = ucpia->workbuff->next;
  158. ucpia->workbuff->status = FRAME_EMPTY;
  159. ucpia->workbuff->length = 0;
  160.   
  161. if (waitqueue_active(&ucpia->wq_stream))
  162. wake_up_interruptible(&ucpia->wq_stream);
  163. }
  164. }
  165. }
  166. }
  168. static int cpia_usb_open(void *privdata)
  169. {
  170. struct usb_cpia *ucpia = (struct usb_cpia *) privdata;
  171. urb_t *urb;
  172. int ret, retval = 0, fx, err;
  173.   
  174. if (!ucpia)
  175. return -EINVAL;
  177. ucpia->sbuf[0].data = kmalloc(FRAMES_PER_DESC * FRAME_SIZE_PER_DESC, GFP_KERNEL);
  178. if (!ucpia->sbuf[0].data)
  179. return -EINVAL;
  181. ucpia->sbuf[1].data = kmalloc(FRAMES_PER_DESC * FRAME_SIZE_PER_DESC, GFP_KERNEL);
  182. if (!ucpia->sbuf[1].data) {
  183. retval = -EINVAL;
  184. goto error_0;
  185. }
  187. ret = usb_set_interface(ucpia->dev, ucpia->iface, 3);
  188. if (ret < 0) {
  189. printk(KERN_ERR "cpia_usb_open: usb_set_interface error (ret = %d)n", ret);
  190. retval = -EBUSY;
  191. goto error_1;
  192. }
  194. ucpia->buffers[0]->status = FRAME_EMPTY;
  195. ucpia->buffers[0]->length = 0;
  196. ucpia->buffers[1]->status = FRAME_EMPTY;
  197. ucpia->buffers[1]->length = 0;
  198. ucpia->buffers[2]->status = FRAME_EMPTY;
  199. ucpia->buffers[2]->length = 0;
  200. ucpia->curbuff = ucpia->buffers[0];
  201. ucpia->workbuff = ucpia->buffers[1];
  203. /* We double buffer the Iso lists */
  204. urb = usb_alloc_urb(FRAMES_PER_DESC);
  205. if (!urb) {
  206. printk(KERN_ERR "cpia_init_isoc: usb_alloc_urb 0n");
  207. retval = -ENOMEM;
  208. goto error_1;
  209. }
  211. ucpia->sbuf[0].urb = urb;
  212. urb->dev = ucpia->dev;
  213. urb->context = ucpia;
  214. urb->pipe = usb_rcvisocpipe(ucpia->dev, 1);
  215. urb->transfer_flags = USB_ISO_ASAP;
  216. urb->transfer_buffer = ucpia->sbuf[0].data;
  217. urb->complete = cpia_usb_complete;
  218. urb->number_of_packets = FRAMES_PER_DESC;
  219. urb->transfer_buffer_length = FRAME_SIZE_PER_DESC * FRAMES_PER_DESC;
  220. for (fx = 0; fx < FRAMES_PER_DESC; fx++) {
  221. urb->iso_frame_desc[fx].offset = FRAME_SIZE_PER_DESC * fx;
  222. urb->iso_frame_desc[fx].length = FRAME_SIZE_PER_DESC;
  223. }
  225. urb = usb_alloc_urb(FRAMES_PER_DESC);
  226. if (!urb) {
  227. printk(KERN_ERR "cpia_init_isoc: usb_alloc_urb 1n");
  228. retval = -ENOMEM;
  229. goto error_urb0;
  230. }
  232. ucpia->sbuf[1].urb = urb;
  233. urb->dev = ucpia->dev;
  234. urb->context = ucpia;
  235. urb->pipe = usb_rcvisocpipe(ucpia->dev, 1);
  236. urb->transfer_flags = USB_ISO_ASAP;
  237. urb->transfer_buffer = ucpia->sbuf[1].data;
  238. urb->complete = cpia_usb_complete;
  239. urb->number_of_packets = FRAMES_PER_DESC;
  240. urb->transfer_buffer_length = FRAME_SIZE_PER_DESC * FRAMES_PER_DESC;
  241. for (fx = 0; fx < FRAMES_PER_DESC; fx++) {
  242. urb->iso_frame_desc[fx].offset = FRAME_SIZE_PER_DESC * fx;
  243. urb->iso_frame_desc[fx].length = FRAME_SIZE_PER_DESC;
  244. }
  246. ucpia->sbuf[1].urb->next = ucpia->sbuf[0].urb;
  247. ucpia->sbuf[0].urb->next = ucpia->sbuf[1].urb;
  249. err = usb_submit_urb(ucpia->sbuf[0].urb);
  250. if (err) {
  251. printk(KERN_ERR "cpia_init_isoc: usb_submit_urb 0 ret %dn",
  252. err);
  253. goto error_urb1;
  254. }
  255. err = usb_submit_urb(ucpia->sbuf[1].urb);
  256. if (err) {
  257. printk(KERN_ERR "cpia_init_isoc: usb_submit_urb 1 ret %dn",
  258. err);
  259. goto error_urb1;
  260. }
  262. ucpia->streaming = 1;
  263. ucpia->open = 1;
  265. return 0;
  267. error_urb1: /* free urb 1 */
  268. usb_free_urb(ucpia->sbuf[1].urb);
  270. error_urb0: /* free urb 0 */
  271. usb_free_urb(ucpia->sbuf[0].urb);
  273. error_1:
  274. kfree (ucpia->sbuf[1].data);
  275. error_0:
  276. kfree (ucpia->sbuf[0].data);
  278. return retval;
  279. }
  281. //
  282. // convenience functions
  283. //
  285. /****************************************************************************
  286.  *
  287.  *  WritePacket
  288.  *
  289.  ***************************************************************************/
  290. static int WritePacket(struct usb_device *udev, const u8 *packet, u8 *buf, size_t size)
  291. {
  292. if (!packet)
  293. return -EINVAL;
  295. return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
  296.  packet[1] + (packet[0] << 8),
  297.  USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  298.  packet[2] + (packet[3] << 8), 
  299.  packet[4] + (packet[5] << 8), buf, size, HZ);
  300. }
  302. /****************************************************************************
  303.  *
  304.  *  ReadPacket
  305.  *
  306.  ***************************************************************************/
  307. static int ReadPacket(struct usb_device *udev, u8 *packet, u8 *buf, size_t size)
  308. {
  309. if (!packet || size <= 0)
  310. return -EINVAL;
  312. return usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
  313.  packet[1] + (packet[0] << 8),
  314.  USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  315.  packet[2] + (packet[3] << 8), 
  316.  packet[4] + (packet[5] << 8), buf, size, HZ);
  317. }
  319. static int cpia_usb_transferCmd(void *privdata, u8 *command, u8 *data)
  320. {
  321. int err = 0;
  322. int databytes;
  323. struct usb_cpia *ucpia = (struct usb_cpia *)privdata;
  324. struct usb_device *udev = ucpia->dev;
  326. if (!udev) {
  327. DBG("Internal driver error: udev is NULLn");
  328. return -EINVAL;
  329. }
  331. if (!command) {
  332. DBG("Internal driver error: command is NULLn");
  333. return -EINVAL;
  334. }
  336. databytes = (((int)command[7])<<8) | command[6];
  338. if (command[0] == DATA_IN) {
  339. u8 buffer[8];
  341. if (!data) {
  342. DBG("Internal driver error: data is NULLn");
  343. return -EINVAL;
  344. }
  346. err = ReadPacket(udev, command, buffer, 8);
  347. if (err < 0)
  348. return err;
  350. memcpy(data, buffer, databytes);
  351. } else if(command[0] == DATA_OUT)
  352. WritePacket(udev, command, data, databytes);
  353. else {
  354. DBG("Unexpected first byte of command: %xn", command[0]);
  355. err = -EINVAL;
  356. }
  358. return 0;
  359. }
  361. static int cpia_usb_registerCallback(void *privdata, void (*cb) (void *cbdata),
  362. void *cbdata)
  363. {
  364. return -ENODEV;
  365. }
  367. static int cpia_usb_streamStart(void *privdata)
  368. {
  369. return -ENODEV;
  370. }
  372. static int cpia_usb_streamStop(void *privdata)
  373. {
  374. return -ENODEV;
  375. }
  377. static int cpia_usb_streamRead(void *privdata, u8 *frame, int noblock)
  378. {
  379. struct usb_cpia *ucpia = (struct usb_cpia *) privdata;
  380. struct framebuf *mybuff;
  382. if (!ucpia || !ucpia->present)
  383. return -1;
  384.   
  385. if (ucpia->curbuff->status != FRAME_READY)
  386. interruptible_sleep_on(&ucpia->wq_stream);
  387. else
  388. DBG("Frame already waiting!n");
  390. mybuff = ucpia->curbuff;
  392. if (!mybuff)
  393. return -1;
  394.   
  395. if (mybuff->status != FRAME_READY || mybuff->length < 4) {
  396. DBG("Something went wrong!n");
  397. return -1;
  398. }
  400. memcpy(frame, mybuff->data, mybuff->length);
  401. mybuff->status = FRAME_EMPTY;
  402.   
  403. /*   DBG("read done, %d bytes, Header: %x/%x, Footer: %x%x%x%xn",  */
  404. /*       mybuff->length, frame[0], frame[1], */
  405. /*       frame[mybuff->length-4], frame[mybuff->length-3],  */
  406. /*       frame[mybuff->length-2], frame[mybuff->length-1]); */
  408. return mybuff->length;
  409. }
  411. static void cpia_usb_free_resources(struct usb_cpia *ucpia, int try)
  412. {
  413. if (!ucpia->streaming)
  414. return;
  416. ucpia->streaming = 0;
  418. /* Set packet size to 0 */
  419. if (try) {
  420. int ret;
  422. ret = usb_set_interface(ucpia->dev, ucpia->iface, 0);
  423. if (ret < 0) {
  424. printk(KERN_ERR "usb_set_interface error (ret = %d)n", ret);
  425. return;
  426. }
  427. }
  429. /* Unschedule all of the iso td's */
  430. if (ucpia->sbuf[1].urb) {
  431. usb_unlink_urb(ucpia->sbuf[1].urb);
  432. usb_free_urb(ucpia->sbuf[1].urb);
  433. ucpia->sbuf[1].urb = NULL;
  434. }
  436. if (ucpia->sbuf[1].data) {
  437. kfree(ucpia->sbuf[1].data);
  438. ucpia->sbuf[1].data = NULL;
  439. }
  440.  
  441. if (ucpia->sbuf[0].urb) {
  442. usb_unlink_urb(ucpia->sbuf[0].urb);
  443. usb_free_urb(ucpia->sbuf[0].urb);
  444. ucpia->sbuf[0].urb = NULL;
  445. }
  447. if (ucpia->sbuf[0].data) {
  448. kfree(ucpia->sbuf[0].data);
  449. ucpia->sbuf[0].data = NULL;
  450. }
  451. }
  453. static int cpia_usb_close(void *privdata)
  454. {
  455. struct usb_cpia *ucpia = (struct usb_cpia *) privdata;
  457. ucpia->open = 0;
  459. cpia_usb_free_resources(ucpia, 1);
  461. if (!ucpia->present)
  462. kfree(ucpia);
  464. return 0;
  465. }
  467. int cpia_usb_init(void)
  468. {
  469. /* return -ENODEV; */
  470. return 0;
  471. }
  473. /* Probing and initializing */
  475. static void *cpia_probe(struct usb_device *udev, unsigned int ifnum,
  476. const struct usb_device_id *id)
  477. {
  478. struct usb_interface_descriptor *interface;
  479. struct usb_cpia *ucpia;
  480. struct cam_data *cam;
  481. int ret;
  482.   
  483. /* A multi-config CPiA camera? */
  484. if (udev->descriptor.bNumConfigurations != 1)
  485. return NULL;
  487. interface = &udev->actconfig->interface[ifnum].altsetting[0];
  489. printk(KERN_INFO "USB CPiA camera foundn");
  491. ucpia = kmalloc(sizeof(*ucpia), GFP_KERNEL);
  492. if (!ucpia) {
  493. printk(KERN_ERR "couldn't kmalloc cpia structn");
  494. return NULL;
  495. }
  497. memset(ucpia, 0, sizeof(*ucpia));
  499. ucpia->dev = udev;
  500. ucpia->iface = interface->bInterfaceNumber;
  501. init_waitqueue_head(&ucpia->wq_stream);
  503. ucpia->buffers[0] = vmalloc(sizeof(*ucpia->buffers[0]));
  504. if (!ucpia->buffers[0]) {
  505. printk(KERN_ERR "couldn't vmalloc frame buffer 0n");
  506. goto fail_alloc_0;
  507. }
  509. ucpia->buffers[1] = vmalloc(sizeof(*ucpia->buffers[1]));
  510. if (!ucpia->buffers[1]) {
  511. printk(KERN_ERR "couldn't vmalloc frame buffer 1n");
  512. goto fail_alloc_1;
  513. }
  515. ucpia->buffers[2] = vmalloc(sizeof(*ucpia->buffers[2]));
  516. if (!ucpia->buffers[2]) {
  517. printk(KERN_ERR "couldn't vmalloc frame buffer 2n");
  518. goto fail_alloc_2;
  519. }
  521. ucpia->buffers[0]->next = ucpia->buffers[1];
  522. ucpia->buffers[1]->next = ucpia->buffers[2];
  523. ucpia->buffers[2]->next = ucpia->buffers[0];
  525. ret = usb_set_interface(udev, ucpia->iface, 0);
  526. if (ret < 0) {
  527. printk(KERN_ERR "cpia_probe: usb_set_interface error (ret = %d)n", ret);
  528. /* goto fail_all; */
  529. }
  531. /* Before register_camera, important */
  532. ucpia->present = 1;
  533.   
  534. cam = cpia_register_camera(&cpia_usb_ops, ucpia);
  535. if (!cam) {
  536. LOG("failed to cpia_register_cameran");
  537. goto fail_all;
  538. }
  540. spin_lock( &cam_list_lock_usb );
  541. cpia_add_to_list(cam_list, cam);
  542. spin_unlock( &cam_list_lock_usb );
  544. return cam;
  546. fail_all:
  547. vfree(ucpia->buffers[2]);
  548. ucpia->buffers[2] = NULL;
  549. fail_alloc_2:
  550. vfree(ucpia->buffers[1]);
  551. ucpia->buffers[1] = NULL;
  552. fail_alloc_1:
  553. vfree(ucpia->buffers[0]);
  554. ucpia->buffers[0] = NULL;
  555. fail_alloc_0:
  557. return NULL;
  558. }
  560. static void cpia_disconnect(struct usb_device *dev, void *ptr);
  562. static struct usb_device_id cpia_id_table [] = {
  563. { USB_DEVICE(0x0553, 0x0002) },
  564. { USB_DEVICE(0x0813, 0x0001) },
  565. { } /* Terminating entry */
  566. };
  568. MODULE_DEVICE_TABLE (usb, cpia_id_table);
  569. MODULE_LICENSE("GPL");
  572. static struct usb_driver cpia_driver = {
  573. name: "cpia",
  574. probe: cpia_probe,
  575. disconnect: cpia_disconnect,
  576. id_table: cpia_id_table,
  577. };
  579. /* don't use dev, it may be NULL! (see usb_cpia_cleanup) */
  580. /* _disconnect from usb_cpia_cleanup is not necessary since usb_deregister */
  581. /* will do it for us as well as passing a udev structure - jerdfelt */
  582. static void cpia_disconnect(struct usb_device *udev, void *ptr)
  583. {
  584. struct cam_data *cam = (struct cam_data *) ptr;
  585. struct usb_cpia *ucpia = (struct usb_cpia *) cam->lowlevel_data;
  586.   
  587. spin_lock( &cam_list_lock_usb );
  588. cpia_remove_from_list(cam);
  589. spin_unlock( &cam_list_lock_usb );
  591. /* Don't even try to reset the altsetting if we're disconnected */
  592. cpia_usb_free_resources(ucpia, 0);
  594. ucpia->present = 0;
  596. cpia_unregister_camera(cam);
  598. ucpia->curbuff->status = FRAME_ERROR;
  600. if (waitqueue_active(&ucpia->wq_stream))
  601. wake_up_interruptible(&ucpia->wq_stream);
  603. usb_driver_release_interface(&cpia_driver,
  604.      &udev->actconfig->interface[0]);
  606. ucpia->curbuff = ucpia->workbuff = NULL;
  608. if (ucpia->buffers[2]) {
  609. vfree(ucpia->buffers[2]);
  610. ucpia->buffers[2] = NULL;
  611. }
  613. if (ucpia->buffers[1]) {
  614. vfree(ucpia->buffers[1]);
  615. ucpia->buffers[1] = NULL;
  616. }
  618. if (ucpia->buffers[0]) {
  619. vfree(ucpia->buffers[0]);
  620. ucpia->buffers[0] = NULL;
  621. }
  623. if (!ucpia->open)
  624. kfree(ucpia);
  625. }
  627. static int __init usb_cpia_init(void)
  628. {
  629. cam_list = NULL;
  630. spin_lock_init(&cam_list_lock_usb);
  631. return usb_register(&cpia_driver);
  632. }
  634. static void __exit usb_cpia_cleanup(void)
  635. {
  636. /*
  637. struct cam_data *cam;
  639. while ((cam = cam_list) != NULL)
  640. cpia_disconnect(NULL, cam);
  641. */
  643. usb_deregister(&cpia_driver);
  644. }
  647. module_init (usb_cpia_init);
  648. module_exit (usb_cpia_cleanup);