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

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

Linux/Unix编程

开发平台：

Unix_Linux

st5481_usb.c：源码内容
  1. /*
  2.  * Driver for ST5481 USB ISDN modem
  3.  *
  4.  * Author       Frode Isaksen
  5.  * Copyright    2001 by Frode Isaksen      <fisaksen@bewan.com>
  6.  *              2001 by Kai Germaschewski  <kai.germaschewski@gmx.de>
  7.  * 
  8.  * This software may be used and distributed according to the terms
  9.  * of the GNU General Public License, incorporated herein by reference.
  10.  *
  11.  */
  13. #include <linux/init.h>
  14. #include <linux/usb.h>
  15. #include <linux/slab.h>
  16. #include "st5481.h"
  18. /* ======================================================================
  19.  * control pipe
  20.  */
  22. /*
  23.  * Send the next endpoint 0 request stored in the FIFO.
  24.  * Called either by the completion or by usb_ctrl_msg.
  25.  */
  26. static void usb_next_ctrl_msg(struct urb *urb,
  27.       struct st5481_adapter *adapter)
  28. {
  29. struct st5481_ctrl *ctrl = &adapter->ctrl;
  30. int r_index;
  32. if (test_and_set_bit(0, &ctrl->busy)) {
  33. return;
  34. }
  36. if ((r_index = fifo_remove(&ctrl->msg_fifo.f)) < 0) {
  37. test_and_clear_bit(0,&ctrl->busy);
  38. return;
  39. } 
  40. urb->setup_packet = 
  41. (unsigned char *)&ctrl->msg_fifo.data[r_index];
  43. DBG(1,"request=0x%02x,value=0x%04x,index=%x",
  44.     ((struct ctrl_msg *)urb->setup_packet)->dr.bRequest,
  45.     ((struct ctrl_msg *)urb->setup_packet)->dr.wValue,
  46.     ((struct ctrl_msg *)urb->setup_packet)->dr.wIndex);
  48. // Prepare the URB
  49. urb->dev = adapter->usb_dev;
  51. SUBMIT_URB(urb);
  52. }
  54. /*
  55.  * Asynchronous endpoint 0 request (async version of usb_control_msg).
  56.  * The request will be queued up in a FIFO if the endpoint is busy.
  57.  */
  58. void usb_ctrl_msg(struct st5481_adapter *adapter,
  59.   u8 request, u8 requesttype, u16 value, u16 index,
  60.   ctrl_complete_t complete, void *context)
  61. {
  62. struct st5481_ctrl *ctrl = &adapter->ctrl;
  63. int w_index;
  64. struct ctrl_msg *ctrl_msg;
  66. if ((w_index = fifo_add(&ctrl->msg_fifo.f)) < 0) {
  67. WARN("control msg FIFO full");
  68. return;
  69. }
  70. ctrl_msg = &ctrl->msg_fifo.data[w_index]; 
  71.    
  72. ctrl_msg->dr.bRequestType = requesttype;
  73. ctrl_msg->dr.bRequest = request;
  74. ctrl_msg->dr.wValue = cpu_to_le16p(&value);
  75. ctrl_msg->dr.wIndex = cpu_to_le16p(&index);
  76. ctrl_msg->dr.wLength = 0;
  77. ctrl_msg->complete = complete;
  78. ctrl_msg->context = context;
  80. usb_next_ctrl_msg(ctrl->urb, adapter);
  81. }
  83. /*
  84.  * Asynchronous endpoint 0 device request.
  85.  */
  86. void st5481_usb_device_ctrl_msg(struct st5481_adapter *adapter,
  87.  u8 request, u16 value,
  88.  ctrl_complete_t complete, void *context)
  89. {
  90. usb_ctrl_msg(adapter, request, 
  91.      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 
  92.      value, 0, complete, context);
  93. }
  95. /*
  96.  * Asynchronous pipe reset (async version of usb_clear_halt).
  97.  */
  98. void st5481_usb_pipe_reset(struct st5481_adapter *adapter,
  99.     u_char pipe,
  100.     ctrl_complete_t complete, void *context)
  101. {
  102. DBG(1,"pipe=%02x",pipe);
  104. usb_ctrl_msg(adapter,
  105.      USB_REQ_CLEAR_FEATURE, USB_DIR_OUT | USB_RECIP_ENDPOINT,
  106.      0, pipe, complete, context);
  107. }
  110. /*
  111.   Physical level functions
  112. */
  114. void st5481_ph_command(struct st5481_adapter *adapter, unsigned int command)
  115. {
  116. DBG(8,"command=%s", ST5481_CMD_string(command));
  118. st5481_usb_device_ctrl_msg(adapter, TXCI, command, NULL, NULL);
  119. }
  121. /*
  122.  * The request on endpoint 0 has completed.
  123.  * Call the user provided completion routine and try
  124.  * to send the next request.
  125.  */
  126. static void usb_ctrl_complete(struct urb *urb)
  127. {
  128. struct st5481_adapter *adapter = urb->context;
  129. struct st5481_ctrl *ctrl = &adapter->ctrl;
  130. struct ctrl_msg *ctrl_msg;
  132. if (urb->status < 0) {
  133. if (urb->status != USB_ST_URB_KILLED) {
  134. WARN("urb status %d",urb->status);
  135. } else {
  136. DBG(1,"urb killed");
  137. return; // Give up
  138. }
  139. }
  141. ctrl_msg = (struct ctrl_msg *)urb->setup_packet;
  143. if (ctrl_msg->dr.bRequest == USB_REQ_CLEAR_FEATURE) {
  144.         /* Special case handling for pipe reset */
  145. le16_to_cpus(&ctrl_msg->dr.wIndex);
  146. usb_endpoint_running(adapter->usb_dev,
  147.      ctrl_msg->dr.wIndex & ~USB_DIR_IN, 
  148.      (ctrl_msg->dr.wIndex & USB_DIR_IN) == 0);
  150. /* toggle is reset on clear */
  151. usb_settoggle(adapter->usb_dev, 
  152.       ctrl_msg->dr.wIndex & ~USB_DIR_IN, 
  153.       (ctrl_msg->dr.wIndex & USB_DIR_IN) == 0,
  154.       0);
  157. }
  159. if (ctrl_msg->complete)
  160. ctrl_msg->complete(ctrl_msg->context);
  162. clear_bit(0, &ctrl->busy);
  164. // Try to send next control message
  165. usb_next_ctrl_msg(urb, adapter);
  166. return;
  167. }
  169. /* ======================================================================
  170.  * interrupt pipe
  171.  */
  173. /*
  174.  * The interrupt endpoint will be called when any
  175.  * of the 6 registers changes state (depending on masks).
  176.  * Decode the register values and schedule a private event.
  177.  * Called at interrupt.
  178.  */
  179. static void usb_int_complete(struct urb *urb)
  180. {
  181. u_char *data = urb->transfer_buffer;
  182. u_char irqbyte;
  183. struct st5481_adapter *adapter = urb->context;
  184. int j;
  186. if (urb->status < 0) {
  187. if (urb->status != USB_ST_URB_KILLED) {
  188. WARN("urb status %d",urb->status);
  189. urb->actual_length = 0;
  190. } else {
  191. DBG(1,"urb killed");
  192. return; // Give up
  193. }
  194. }
  196. DBG_PACKET(1, data, INT_PKT_SIZE);
  198. if (urb->actual_length == 0) {
  199. return;
  200. }
  202. irqbyte = data[MPINT];
  203. if (irqbyte & DEN_INT)
  204. FsmEvent(&adapter->d_out.fsm, EV_DOUT_DEN, NULL);
  206. if (irqbyte & DCOLL_INT)
  207. FsmEvent(&adapter->d_out.fsm, EV_DOUT_COLL, NULL);
  209. irqbyte = data[FFINT_D];
  210. if (irqbyte & OUT_UNDERRUN)
  211. FsmEvent(&adapter->d_out.fsm, EV_DOUT_UNDERRUN, NULL);
  213. if (irqbyte & OUT_DOWN)
  214. ;// printk("OUT_DOWNn");
  216. irqbyte = data[MPINT];
  217. if (irqbyte & RXCI_INT)
  218. FsmEvent(&adapter->l1m, data[CCIST] & 0x0f, NULL);
  220. for (j = 0; j < 2; j++)
  221. adapter->bcs[j].b_out.flow_event |= data[FFINT_B1 + j];
  223. urb->actual_length = 0;
  224. }
  226. /* ======================================================================
  227.  * initialization
  228.  */
  230. int __devinit st5481_setup_usb(struct st5481_adapter *adapter)
  231. {
  232. struct usb_device *dev = adapter->usb_dev;
  233. struct st5481_ctrl *ctrl = &adapter->ctrl;
  234. struct st5481_intr *intr = &adapter->intr;
  235. struct usb_interface_descriptor *altsetting;
  236. struct usb_endpoint_descriptor *endpoint;
  237. int status;
  238. struct urb *urb;
  239. u_char *buf;
  241. DBG(1,"");
  243. if ((status = usb_set_configuration (dev,dev->config[0].bConfigurationValue)) < 0) {
  244. WARN("set_configuration failed,status=%d",status);
  245. return status;
  246. }
  249. altsetting = &(dev->config->interface[0].altsetting[3]);
  251. // Check if the config is sane
  252. if ( altsetting->bNumEndpoints != 7 ) {
  253. WARN("expecting 7 got %d endpoints!", altsetting->bNumEndpoints);
  254. return -EINVAL;
  255. }
  257. // The descriptor is wrong for some early samples of the ST5481 chip
  258. altsetting->endpoint[3].wMaxPacketSize = 32;
  259. altsetting->endpoint[4].wMaxPacketSize = 32;
  261. // Use alternative setting 3 on interface 0 to have 2B+D
  262. if ((status = usb_set_interface (dev, 0, 3)) < 0) {
  263. WARN("usb_set_interface failed,status=%d",status);
  264. return status;
  265. }
  267. // Allocate URB for control endpoint
  268. urb = usb_alloc_urb(0);
  269. if (!urb) {
  270. return -ENOMEM;
  271. }
  272. ctrl->urb = urb;
  274. // Fill the control URB
  275. FILL_CONTROL_URB (urb, dev, 
  276.   usb_sndctrlpipe(dev, 0),
  277.   NULL, NULL, 0, usb_ctrl_complete, adapter);
  280. fifo_init(&ctrl->msg_fifo.f, ARRAY_SIZE(ctrl->msg_fifo.data));
  282. // Allocate URBs and buffers for interrupt endpoint
  283. urb = usb_alloc_urb(0);
  284. if (!urb) { 
  285. return -ENOMEM;
  286. }
  287. intr->urb = urb;
  289. buf = kmalloc(INT_PKT_SIZE, GFP_KERNEL);
  290. if (!buf) {
  291. return -ENOMEM;
  292. }
  294. endpoint = &altsetting->endpoint[EP_INT-1];
  296. // Fill the interrupt URB
  297. FILL_INT_URB(urb, dev,
  298.      usb_rcvintpipe(dev, endpoint->bEndpointAddress),
  299.      buf, INT_PKT_SIZE,
  300.      usb_int_complete, adapter,
  301.      endpoint->bInterval);
  303. return 0;
  304. }
  306. /*
  307.  * Release buffers and URBs for the interrupt and control
  308.  * endpoint.
  309.  */
  310. void st5481_release_usb(struct st5481_adapter *adapter)
  311. {
  312. struct st5481_intr *intr = &adapter->intr;
  313. struct st5481_ctrl *ctrl = &adapter->ctrl;
  315. DBG(1,"");
  317. // Stop and free Control and Interrupt URBs
  318. usb_unlink_urb(ctrl->urb);
  319. if (ctrl->urb->transfer_buffer)
  320. kfree(ctrl->urb->transfer_buffer);
  321. usb_free_urb(ctrl->urb);
  323. usb_unlink_urb(intr->urb);
  324. if (intr->urb->transfer_buffer)
  325. kfree(intr->urb->transfer_buffer);
  326. usb_free_urb(intr->urb);
  327. }
  329. /*
  330.  *  Initialize the adapter.
  331.  */
  332. void __devinit st5481_start(struct st5481_adapter *adapter)
  333. {
  334. static const u8 init_cmd_table[]={
  335. SET_DEFAULT,0,
  336. STT,0,
  337. SDA_MIN,0x0d,
  338. SDA_MAX,0x29,
  339. SDELAY_VALUE,0x14,
  340. GPIO_DIR,0x01,
  341. GPIO_OUT,RED_LED,
  342. // FFCTRL_OUT_D,4,
  343. // FFCTRH_OUT_D,12,
  344. FFCTRL_OUT_B1,6,
  345. FFCTRH_OUT_B1,20,
  346. FFCTRL_OUT_B2,6,
  347. FFCTRH_OUT_B2,20,
  348. MPMSK,RXCI_INT+DEN_INT+DCOLL_INT,
  349. 0
  350. };
  351. struct st5481_intr *intr = &adapter->intr;
  352. int i = 0;
  353. u8 request,value;
  355. DBG(8,"");
  357. adapter->leds = RED_LED; 
  359. // Start receiving on the interrupt endpoint
  360. SUBMIT_URB(intr->urb); 
  362. while ((request = init_cmd_table[i++])) {
  363. value = init_cmd_table[i++];
  364. st5481_usb_device_ctrl_msg(adapter, request, value, NULL, NULL);
  365. }
  366. st5481_ph_command(adapter, ST5481_CMD_PUP);
  367. }
  369. /*
  370.  * Reset the adapter to default values.
  371.  */
  372. void __devexit st5481_stop(struct st5481_adapter *adapter)
  373. {
  374. DBG(8,"");
  376. st5481_usb_device_ctrl_msg(adapter, SET_DEFAULT, 0, NULL, NULL);
  377. }
  379. /* ======================================================================
  380.  * isochronous USB  helpers
  381.  */
  383. static void __devinit
  384. fill_isoc_urb(struct urb *urb, struct usb_device *dev,
  385.       unsigned int pipe, void *buf, int num_packets, 
  386.       int packet_size, usb_complete_t complete,
  387.       void *context) 
  388. {
  389. int k;
  391. spin_lock_init(&urb->lock);
  392. urb->dev=dev;
  393. urb->pipe=pipe;
  394. urb->transfer_buffer=buf;
  395. urb->number_of_packets = num_packets;
  396. urb->transfer_buffer_length=num_packets*packet_size;
  397. urb->actual_length = 0;
  398. urb->complete=complete;
  399. urb->context=context;
  400. urb->transfer_flags=USB_ISO_ASAP;
  401. for (k = 0; k < num_packets; k++) {
  402. urb->iso_frame_desc[k].offset = packet_size * k;
  403. urb->iso_frame_desc[k].length = packet_size;
  404. urb->iso_frame_desc[k].actual_length = 0;
  405. }
  406. }
  408. int __devinit
  409. st5481_setup_isocpipes(struct urb* urb[2], struct usb_device *dev, 
  410.    unsigned int pipe, int num_packets,
  411.    int packet_size, int buf_size,
  412.    usb_complete_t complete, void *context)
  413. {
  414. int j, retval;
  415. unsigned char *buf;
  417. for (j = 0; j < 2; j++) {
  418. retval = -ENOMEM;
  419. urb[j] = usb_alloc_urb(num_packets);
  420. if (!urb[j])
  421. goto err;
  423. // Allocate memory for 2000bytes/sec (16Kb/s)
  424. buf = kmalloc(buf_size, GFP_KERNEL);
  425. if (!buf)
  426. goto err;
  428. // Fill the isochronous URB
  429. fill_isoc_urb(urb[j], dev, pipe, buf, 
  430.       num_packets, packet_size, complete,
  431.       context);
  432. }
  433. return 0;
  435.  err:
  436. for (j = 0; j < 2; j++) {
  437. if (urb[j]) {
  438. if (urb[j]->transfer_buffer)
  439. kfree(urb[j]->transfer_buffer);
  440. usb_free_urb(urb[j]);
  441. }
  442. }
  443. return retval;
  444. }
  446. void st5481_release_isocpipes(struct urb* urb[2])
  447. {
  448. int j;
  450. for (j = 0; j < 2; j++) {
  451. usb_unlink_urb(urb[j]);
  452. if (urb[j]->transfer_buffer)
  453. kfree(urb[j]->transfer_buffer);
  454. usb_free_urb(urb[j]);
  455. }
  456. }
  458. /*
  459.  * Decode frames received on the B/D channel.
  460.  * Note that this function will be called continously
  461.  * with 64Kbit/s / 16Kbit/s of data and hence it will be 
  462.  * called 50 times per second with 20 ISOC descriptors. 
  463.  * Called at interrupt.
  464.  */
  465. static void usb_in_complete(struct urb *urb)
  466. {
  467. struct st5481_in *in = urb->context;
  468. unsigned char *ptr;
  469. struct sk_buff *skb;
  470. int len, count, status;
  472. if (urb->status < 0) {
  473. if (urb->status != USB_ST_URB_KILLED) {
  474. WARN("urb status %d",urb->status);
  475. } else {
  476. DBG(1,"urb killed");
  477. return; // Give up
  478. }
  479. }
  481. DBG_ISO_PACKET(0x80,urb);
  483. len = st5481_isoc_flatten(urb);
  484. ptr = urb->transfer_buffer;
  485. while (len > 0) {
  486. if (in->mode == L1_MODE_TRANS) {
  487. memcpy(in->rcvbuf, ptr, len);
  488. status = len;
  489. len = 0;
  490. } else {
  491. status = hdlc_decode(&in->hdlc_state, ptr, len, &count,
  492.      in->rcvbuf, in->bufsize);
  493. ptr += count;
  494. len -= count;
  495. }
  497. if (status > 0) {
  498. // Good frame received
  499. DBG(4,"count=%d",status);
  500. DBG_PACKET(0x400, in->rcvbuf, status);
  501. if (!(skb = dev_alloc_skb(status))) {
  502. WARN("receive out of memoryn");
  503. break;
  504. }
  505. memcpy(skb_put(skb, status), in->rcvbuf, status);
  506. in->hisax_if->l1l2(in->hisax_if, PH_DATA | INDICATION, skb);
  507. } else if (status == -HDLC_CRC_ERROR) {
  508. INFO("CRC error");
  509. } else if (status == -HDLC_FRAMING_ERROR) {
  510. INFO("framing error");
  511. } else if (status == -HDLC_LENGTH_ERROR) {
  512. INFO("length error");
  513. }
  514. }
  516. // Prepare URB for next transfer
  517. urb->dev = in->adapter->usb_dev;
  518. urb->actual_length = 0;
  520. SUBMIT_URB(urb);
  521. }
  523. int __devinit st5481_setup_in(struct st5481_in *in)
  524. {
  525. struct usb_device *dev = in->adapter->usb_dev;
  526. int retval;
  528. DBG(4,"");
  530. in->rcvbuf = kmalloc(in->bufsize, GFP_KERNEL);
  531. retval = -ENOMEM;
  532. if (!in->rcvbuf)
  533. goto err;
  535. retval = st5481_setup_isocpipes(in->urb, dev, 
  536. usb_rcvisocpipe(dev, in->ep),
  537. in->num_packets,  in->packet_size,
  538. in->num_packets * in->packet_size,
  539. usb_in_complete, in);
  540. if (retval)
  541. goto err_free;
  542. return 0;
  544.  err_free:
  545. kfree(in->rcvbuf);
  546.  err:
  547. return retval;
  548. }
  550. void st5481_release_in(struct st5481_in *in)
  551. {
  552. DBG(2,"");
  554. st5481_release_isocpipes(in->urb);
  555. }
  557. /*
  558.  * Make the transfer_buffer contiguous by
  559.  * copying from the iso descriptors if necessary. 
  560.  */
  561. int st5481_isoc_flatten(struct urb *urb)
  562. {
  563. struct iso_packet_descriptor *pipd;
  564. struct iso_packet_descriptor *pend;
  565. unsigned char *src,*dst;
  566. unsigned int len;
  568. if (urb->status < 0) {
  569. return urb->status;
  570. }
  571. for (pipd = &urb->iso_frame_desc[0],
  572.      pend = &urb->iso_frame_desc[urb->number_of_packets],
  573.      dst = urb->transfer_buffer; 
  574.      pipd < pend; 
  575.      pipd++) {
  577. if (pipd->status < 0) {
  578. return (pipd->status);
  579. }
  581. len = pipd->actual_length;
  582. pipd->actual_length = 0;
  583. src = urb->transfer_buffer+pipd->offset;
  585. if (src != dst) {
  586. // Need to copy since isoc buffers not full
  587. while (len--) {
  588. *dst++ = *src++;
  589. }
  590. } else {
  591. // No need to copy, just update destination buffer
  592. dst += len;
  593. }
  594. }
  595. // Return size of flattened buffer
  596. return (dst - (unsigned char *)urb->transfer_buffer);
  597. }
  599. static void st5481_start_rcv(void *context)
  600. {
  601. struct st5481_in *in = context;
  602. struct st5481_adapter *adapter = in->adapter;
  604. DBG(4,"");
  606. in->urb[0]->dev = adapter->usb_dev;
  607. SUBMIT_URB(in->urb[0]);
  609. in->urb[1]->dev = adapter->usb_dev;
  610. SUBMIT_URB(in->urb[1]);
  611. }
  613. void st5481_in_mode(struct st5481_in *in, int mode)
  614. {
  615. if (in->mode == mode)
  616. return;
  618. in->mode = mode;
  620. usb_unlink_urb(in->urb[0]);
  621. usb_unlink_urb(in->urb[1]);
  623. if (in->mode != L1_MODE_NULL) {
  624. if (in->mode != L1_MODE_TRANS)
  625. hdlc_rcv_init(&in->hdlc_state,
  626.       in->mode == L1_MODE_HDLC_56K);
  628. st5481_usb_pipe_reset(in->adapter, in->ep, NULL, NULL);
  629. st5481_usb_device_ctrl_msg(in->adapter, in->counter,
  630.    in->packet_size,
  631.    NULL, NULL);
  632. st5481_start_rcv(in);
  633. } else {
  634. st5481_usb_device_ctrl_msg(in->adapter, in->counter,
  635.    0, NULL, NULL);
  636. }
  637. }