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

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

Linux/Unix编程

开发平台：

Unix_Linux

st5481_d.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 <linux/netdevice.h>
  17. #include "st5481.h"
  19. static void ph_connect(struct st5481_adapter *adapter);
  20. static void ph_disconnect(struct st5481_adapter *adapter);
  22. static struct Fsm l1fsm;
  24. static char *strL1State[] =
  25. {
  26. "ST_L1_F3",
  27. "ST_L1_F4",
  28. "ST_L1_F6",
  29. "ST_L1_F7",
  30. "ST_L1_F8",
  31. };
  33. static char *strL1Event[] =
  34. {
  35. "EV_IND_DP",  
  36. "EV_IND_1",   
  37. "EV_IND_2",   
  38. "EV_IND_3",   
  39. "EV_IND_RSY", 
  40. "EV_IND_5",   
  41. "EV_IND_6",   
  42. "EV_IND_7",   
  43. "EV_IND_AP",  
  44. "EV_IND_9",   
  45. "EV_IND_10",  
  46. "EV_IND_11",  
  47. "EV_IND_AI8",
  48. "EV_IND_AI10",
  49. "EV_IND_AIL",
  50. "EV_IND_DI",  
  51. "EV_PH_ACTIVATE_REQ",
  52. "EV_PH_DEACTIVATE_REQ",
  53. "EV_TIMER3",
  54. };
  56. static inline void D_L1L2(struct st5481_adapter *adapter, int pr, void *arg)
  57. {
  58. struct hisax_if *ifc = (struct hisax_if *) &adapter->hisax_d_if;
  60. ifc->l1l2(ifc, pr, arg);
  61. }
  63. static void
  64. l1_go_f3(struct FsmInst *fi, int event, void *arg)
  65. {
  66. struct st5481_adapter *adapter = fi->userdata;
  68. if (fi->state == ST_L1_F7)
  69. ph_disconnect(adapter);
  71. FsmChangeState(fi, ST_L1_F3);
  72. D_L1L2(adapter, PH_DEACTIVATE | INDICATION, NULL);
  73. }
  75. static void
  76. l1_go_f6(struct FsmInst *fi, int event, void *arg)
  77. {
  78. struct st5481_adapter *adapter = fi->userdata;
  80. if (fi->state == ST_L1_F7)
  81. ph_disconnect(adapter);
  83. FsmChangeState(fi, ST_L1_F6);
  84. }
  86. static void
  87. l1_go_f7(struct FsmInst *fi, int event, void *arg)
  88. {
  89. struct st5481_adapter *adapter = fi->userdata;
  91. FsmDelTimer(&adapter->timer, 0);
  92. ph_connect(adapter);
  93. FsmChangeState(fi, ST_L1_F7);
  94. D_L1L2(adapter, PH_ACTIVATE | INDICATION, NULL);
  95. }
  97. static void
  98. l1_go_f8(struct FsmInst *fi, int event, void *arg)
  99. {
  100. struct st5481_adapter *adapter = fi->userdata;
  102. if (fi->state == ST_L1_F7)
  103. ph_disconnect(adapter);
  105. FsmChangeState(fi, ST_L1_F8);
  106. }
  108. static void
  109. l1_timer3(struct FsmInst *fi, int event, void *arg)
  110. {
  111. struct st5481_adapter *adapter = fi->userdata;
  113. st5481_ph_command(adapter, ST5481_CMD_DR);
  114. FsmChangeState(fi, ST_L1_F3);
  115. D_L1L2(adapter, PH_DEACTIVATE | INDICATION, NULL);
  116. }
  118. static void
  119. l1_ignore(struct FsmInst *fi, int event, void *arg)
  120. {
  121. }
  123. static void
  124. l1_activate(struct FsmInst *fi, int event, void *arg)
  125. {
  126. struct st5481_adapter *adapter = fi->userdata;
  128. st5481_ph_command(adapter, ST5481_CMD_DR);
  129. st5481_ph_command(adapter, ST5481_CMD_PUP);
  130. FsmRestartTimer(&adapter->timer, TIMER3_VALUE, EV_TIMER3, NULL, 2);
  131. st5481_ph_command(adapter, ST5481_CMD_AR8);
  132. FsmChangeState(fi, ST_L1_F4);
  133. }
  135. static struct FsmNode L1FnList[] __initdata =
  136. {
  137. {ST_L1_F3, EV_IND_DP,            l1_ignore},
  138. {ST_L1_F3, EV_IND_AP,            l1_go_f6},
  139. {ST_L1_F3, EV_IND_AI8,           l1_go_f7},
  140. {ST_L1_F3, EV_IND_AI10,          l1_go_f7},
  141. {ST_L1_F3, EV_PH_ACTIVATE_REQ,   l1_activate},
  143. {ST_L1_F4, EV_TIMER3,            l1_timer3},
  144. {ST_L1_F4, EV_IND_DP,            l1_go_f3},
  145. {ST_L1_F4, EV_IND_AP,            l1_go_f6},
  146. {ST_L1_F4, EV_IND_AI8,           l1_go_f7},
  147. {ST_L1_F4, EV_IND_AI10,          l1_go_f7},
  149. {ST_L1_F6, EV_TIMER3,            l1_timer3},
  150. {ST_L1_F6, EV_IND_DP,            l1_go_f3},
  151. {ST_L1_F6, EV_IND_AP,            l1_ignore},
  152. {ST_L1_F6, EV_IND_AI8,           l1_go_f7},
  153. {ST_L1_F6, EV_IND_AI10,          l1_go_f7},
  154. {ST_L1_F7, EV_IND_RSY,           l1_go_f8},
  156. {ST_L1_F7, EV_IND_DP,            l1_go_f3},
  157. {ST_L1_F7, EV_IND_AP,            l1_go_f6},
  158. {ST_L1_F7, EV_IND_AI8,           l1_ignore},
  159. {ST_L1_F7, EV_IND_AI10,          l1_ignore},
  160. {ST_L1_F7, EV_IND_RSY,           l1_go_f8},
  162. {ST_L1_F8, EV_TIMER3,            l1_timer3},
  163. {ST_L1_F8, EV_IND_DP,            l1_go_f3},
  164. {ST_L1_F8, EV_IND_AP,            l1_go_f6},
  165. {ST_L1_F8, EV_IND_AI8,           l1_go_f8},
  166. {ST_L1_F8, EV_IND_AI10,          l1_go_f8},
  167. {ST_L1_F8, EV_IND_RSY,           l1_ignore},
  168. };
  170. static void l1m_debug(struct FsmInst *fi, char *fmt, ...)
  171. {
  172. va_list args;
  173. char buf[256];
  175. va_start(args, fmt);
  176. vsprintf(buf, fmt, args);
  177. DBG(8, "%s", buf);
  178. va_end(args);
  179. }
  181. /* ======================================================================
  182.  * D-Channel out
  183.  */
  185. /*
  186.   D OUT state machine:
  187.   ====================
  189.   Transmit short frame (< 16 bytes of encoded data):
  191.   L1 FRAME    D_OUT_STATE           USB                  D CHANNEL
  192.   --------    -----------           ---                  ---------
  193.  
  194.               FIXME
  196.  -> [xx..xx]  SHORT_INIT            -> [7Exx..xxC1C27EFF]
  197.               SHORT_WAIT_DEN        <> OUT_D_COUNTER=16 
  198.                                                  
  199.               END_OF_SHORT          <- DEN_EVENT         -> 7Exx
  200.                                                           xxxx 
  201.                                                           xxxx
  202.   xxxx 
  203.   xxxx
  204.   xxxx
  205.   C1C1 
  206.   7EFF 
  207.               WAIT_FOR_RESET_IDLE   <- D_UNDERRUN        <- (8ms)                        
  208.               IDLE                  <> Reset pipe
  210.               
  212.   Transmit long frame (>= 16 bytes of encoded data):
  214.   L1 FRAME    D_OUT_STATE           USB                  D CHANNEL
  215.   --------    -----------           ---                  ---------
  217.  -> [xx...xx] IDLE
  218.               WAIT_FOR_STOP         <> OUT_D_COUNTER=0
  219.               WAIT_FOR_RESET        <> Reset pipe
  220.       STOP
  221.       INIT_LONG_FRAME       -> [7Exx..xx]
  222.               WAIT_DEN              <> OUT_D_COUNTER=16 
  223.               OUT_NORMAL            <- DEN_EVENT       -> 7Exx
  224.               END_OF_FRAME_BUSY     -> [xxxx]             xxxx 
  225.               END_OF_FRAME_NOT_BUSY -> [xxxx]             xxxx
  226.     -> [xxxx]   xxxx 
  227.     -> [C1C2]   xxxx
  228.     -> [7EFF]   xxxx
  229.   xxxx 
  230.   xxxx 
  231.                                                           ....
  232.   xxxx
  233.   C1C2
  234.   7EFF
  235.                       <- D_UNDERRUN      <- (> 8ms)                        
  236.               WAIT_FOR_STOP         <> OUT_D_COUNTER=0
  237.               WAIT_FOR_RESET        <> Reset pipe
  238.       STOP
  240. */          
  242. static struct Fsm dout_fsm;
  244. static char *strDoutState[] =
  245. {
  246. "ST_DOUT_NONE",
  248. "ST_DOUT_SHORT_INIT",
  249. "ST_DOUT_SHORT_WAIT_DEN",
  251. "ST_DOUT_LONG_INIT",
  252. "ST_DOUT_LONG_WAIT_DEN",
  253. "ST_DOUT_NORMAL",
  255. "ST_DOUT_WAIT_FOR_UNDERRUN",
  256.         "ST_DOUT_WAIT_FOR_NOT_BUSY",
  257. "ST_DOUT_WAIT_FOR_STOP",
  258. "ST_DOUT_WAIT_FOR_RESET",
  259. };
  261. static char *strDoutEvent[] =
  262. {
  263. "EV_DOUT_START_XMIT",
  264. "EV_DOUT_COMPLETE",
  265. "EV_DOUT_DEN",
  266. "EV_DOUT_RESETED",
  267. "EV_DOUT_STOPPED",
  268. "EV_DOUT_COLL",
  269. "EV_DOUT_UNDERRUN",
  270. };
  272. static void dout_debug(struct FsmInst *fi, char *fmt, ...)
  273. {
  274. va_list args;
  275. char buf[256];
  277. va_start(args, fmt);
  278. vsprintf(buf, fmt, args);
  279. DBG(0x2, "%s", buf);
  280. va_end(args);
  281. }
  283. static void dout_stop_event(void *context)
  284. {
  285. struct st5481_adapter *adapter = context;
  287. FsmEvent(&adapter->d_out.fsm, EV_DOUT_STOPPED, NULL);
  288. }
  290. /*
  291.  * Start the transfer of a D channel frame.
  292.  */
  293. static void usb_d_out(struct st5481_adapter *adapter, int buf_nr)
  294. {
  295. struct st5481_d_out *d_out = &adapter->d_out;
  296. struct urb *urb;
  297. unsigned int num_packets, packet_offset;
  298. int len, buf_size, bytes_sent;
  299. struct sk_buff *skb;
  300. struct iso_packet_descriptor *desc;
  302. if (d_out->fsm.state != ST_DOUT_NORMAL)
  303. return;
  305. if (test_and_set_bit(buf_nr, &d_out->busy)) {
  306. DBG(2, "ep %d urb %d busy %#lx", EP_D_OUT, buf_nr, d_out->busy);
  307. return;
  308. }
  309. urb = d_out->urb[buf_nr];
  311. skb = d_out->tx_skb;
  313. buf_size = NUM_ISO_PACKETS_D * SIZE_ISO_PACKETS_D_OUT;
  315. if (skb) {
  316. len = hdlc_encode(&d_out->hdlc_state, 
  317.   skb->data, skb->len, &bytes_sent,
  318.   urb->transfer_buffer, buf_size);
  319. skb_pull(skb,bytes_sent);
  320. } else {
  321. // Send flags or idle
  322. len = hdlc_encode(&d_out->hdlc_state, 
  323.   NULL, 0, &bytes_sent,
  324.   urb->transfer_buffer, buf_size);
  325. }
  327. if (len < buf_size) {
  328. FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_UNDERRUN);
  329. }
  330. if (skb && !skb->len) {
  331. d_out->tx_skb = NULL;
  332. D_L1L2(adapter, PH_DATA | CONFIRM, NULL);
  333. dev_kfree_skb_any(skb);
  334. }
  336. // Prepare the URB
  337. urb->transfer_buffer_length = len;
  338. num_packets = 0;
  339. packet_offset = 0;
  340. while (packet_offset < len) {
  341. desc = &urb->iso_frame_desc[num_packets];
  342. desc->offset = packet_offset;
  343. desc->length = SIZE_ISO_PACKETS_D_OUT;
  344. if (len - packet_offset < desc->length)
  345. desc->length = len - packet_offset;
  346. num_packets++;
  347. packet_offset += desc->length;
  348. }
  349. urb->number_of_packets = num_packets;
  351. // Prepare the URB
  352. urb->dev = adapter->usb_dev;
  353. // Need to transmit the next buffer 2ms after the DEN_EVENT
  354. urb->transfer_flags = 0;
  355. urb->start_frame = usb_get_current_frame_number(adapter->usb_dev)+2;
  357. DBG_ISO_PACKET(0x20,urb);
  359. if (usb_submit_urb(urb) < 0) {
  360. // There is another URB queued up
  361. urb->transfer_flags = USB_ISO_ASAP;
  362. SUBMIT_URB(urb);
  363. }
  364. }
  366. static void fifo_reseted(void *context)
  367. {
  368. struct st5481_adapter *adapter = context;
  370. FsmEvent(&adapter->d_out.fsm, EV_DOUT_RESETED, NULL);
  371. }
  373. static void usb_d_out_complete(struct urb *urb)
  374. {
  375. struct st5481_adapter *adapter = urb->context;
  376. struct st5481_d_out *d_out = &adapter->d_out;
  377. int buf_nr;
  379. DBG(2, "");
  381. buf_nr = get_buf_nr(d_out->urb, urb);
  382. test_and_clear_bit(buf_nr, &d_out->busy);
  384. if (urb->status < 0) {
  385. if (urb->status != USB_ST_URB_KILLED) {
  386. WARN("urb status %d",urb->status);
  387. if (d_out->busy == 0) {
  388. st5481_usb_pipe_reset(adapter, EP_D_OUT | USB_DIR_OUT, fifo_reseted, adapter);
  389. }
  390. return;
  391. } else {
  392. DBG(1,"urb killed"); 
  393. return; // Give up
  394. }
  395. }
  397. FsmEvent(&adapter->d_out.fsm, EV_DOUT_COMPLETE, (void *) buf_nr);
  398. }
  400. /* ====================================================================== */
  402. static void dout_start_xmit(struct FsmInst *fsm, int event, void *arg)
  403. {
  404. // FIXME unify?
  405. struct st5481_adapter *adapter = fsm->userdata;
  406. struct st5481_d_out *d_out = &adapter->d_out;
  407. struct urb *urb;
  408. int len, bytes_sent;
  409. struct sk_buff *skb;
  410. int buf_nr = 0;
  412. skb = d_out->tx_skb;
  414. DBG(2,"len=%d",skb->len);
  416. hdlc_out_init(&d_out->hdlc_state, 1, 0);
  418. if (test_and_set_bit(buf_nr, &d_out->busy)) {
  419. WARN("ep %d urb %d busy %#lx", EP_D_OUT, buf_nr, d_out->busy);
  420. return;
  421. }
  422. urb = d_out->urb[buf_nr];
  424. DBG_SKB(0x10, skb);
  425. len = hdlc_encode(&d_out->hdlc_state, 
  426.   skb->data, skb->len, &bytes_sent,
  427.   urb->transfer_buffer, 16);
  428. skb_pull(skb, bytes_sent);
  430. if(len < 16)
  431. FsmChangeState(&d_out->fsm, ST_DOUT_SHORT_INIT);
  432. else
  433. FsmChangeState(&d_out->fsm, ST_DOUT_LONG_INIT);
  435. if (skb->len == 0) {
  436. d_out->tx_skb = NULL;
  437. D_L1L2(adapter, PH_DATA | CONFIRM, NULL);
  438. dev_kfree_skb_any(skb);
  439. }
  441. // Prepare the URB
  442. urb->transfer_buffer_length = len;
  444. urb->iso_frame_desc[0].offset = 0;
  445. urb->iso_frame_desc[0].length = len;
  446. urb->number_of_packets = 1;
  448. // Prepare the URB
  449. urb->dev = adapter->usb_dev;
  450. urb->transfer_flags = USB_ISO_ASAP;
  452. DBG_ISO_PACKET(0x20,urb);
  453. SUBMIT_URB(urb);
  454. }
  456. static void dout_short_fifo(struct FsmInst *fsm, int event, void *arg)
  457. {
  458. struct st5481_adapter *adapter = fsm->userdata;
  459. struct st5481_d_out *d_out = &adapter->d_out;
  461. FsmChangeState(&d_out->fsm, ST_DOUT_SHORT_WAIT_DEN);
  462. st5481_usb_device_ctrl_msg(adapter, OUT_D_COUNTER, 16, NULL, NULL);
  463. }
  465. static void dout_end_short_frame(struct FsmInst *fsm, int event, void *arg)
  466. {
  467. struct st5481_adapter *adapter = fsm->userdata;
  468. struct st5481_d_out *d_out = &adapter->d_out;
  470. FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_UNDERRUN);
  471. }
  473. static void dout_long_enable_fifo(struct FsmInst *fsm, int event, void *arg)
  474. {
  475. struct st5481_adapter *adapter = fsm->userdata;
  476. struct st5481_d_out *d_out = &adapter->d_out;
  477.     
  478. st5481_usb_device_ctrl_msg(adapter, OUT_D_COUNTER, 16, NULL, NULL);
  479. FsmChangeState(&d_out->fsm, ST_DOUT_LONG_WAIT_DEN);
  480. }
  482. static void dout_long_den(struct FsmInst *fsm, int event, void *arg)
  483. {
  484. struct st5481_adapter *adapter = fsm->userdata;
  485. struct st5481_d_out *d_out = &adapter->d_out;
  487. FsmChangeState(&d_out->fsm, ST_DOUT_NORMAL);
  488. usb_d_out(adapter, 0);
  489. usb_d_out(adapter, 1);
  490. }
  492. static void dout_reset(struct FsmInst *fsm, int event, void *arg)
  493. {
  494. struct st5481_adapter *adapter = fsm->userdata;
  495. struct st5481_d_out *d_out = &adapter->d_out;
  497. FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_RESET);
  498. st5481_usb_pipe_reset(adapter, EP_D_OUT | USB_DIR_OUT, fifo_reseted, adapter);
  499. }
  501. static void dout_stop(struct FsmInst *fsm, int event, void *arg)
  502. {
  503. struct st5481_adapter *adapter = fsm->userdata;
  504. struct st5481_d_out *d_out = &adapter->d_out;
  506. FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_STOP);
  507. st5481_usb_device_ctrl_msg(adapter, OUT_D_COUNTER, 0, dout_stop_event, adapter);
  508. }
  510. static void dout_underrun(struct FsmInst *fsm, int event, void *arg)
  511. {
  512. struct st5481_adapter *adapter = fsm->userdata;
  513. struct st5481_d_out *d_out = &adapter->d_out;
  515. if (test_bit(0, &d_out->busy) || test_bit(1, &d_out->busy)) {
  516. FsmChangeState(&d_out->fsm, ST_DOUT_WAIT_FOR_NOT_BUSY);
  517. }  else {
  518. dout_stop(fsm, event, arg);
  519. }
  520. }
  522. static void dout_check_busy(struct FsmInst *fsm, int event, void *arg)
  523. {
  524. struct st5481_adapter *adapter = fsm->userdata;
  525. struct st5481_d_out *d_out = &adapter->d_out;
  527. if (!test_bit(0, &d_out->busy) && !test_bit(1, &d_out->busy))
  528. dout_stop(fsm, event, arg);
  529. }
  531. static void dout_reseted(struct FsmInst *fsm, int event, void *arg)
  532. {
  533. struct st5481_adapter *adapter = fsm->userdata;
  534. struct st5481_d_out *d_out = &adapter->d_out;
  536. FsmChangeState(&d_out->fsm, ST_DOUT_NONE);
  537. // FIXME locking
  538. if (d_out->tx_skb)
  539. FsmEvent(&d_out->fsm, EV_DOUT_START_XMIT, NULL);
  540. }
  542. static void dout_complete(struct FsmInst *fsm, int event, void *arg)
  543. {
  544. struct st5481_adapter *adapter = fsm->userdata;
  545. int buf_nr = (int) arg;
  547. usb_d_out(adapter, buf_nr);
  548. }
  550. static void dout_ignore(struct FsmInst *fsm, int event, void *arg)
  551. {
  552. }
  554. static struct FsmNode DoutFnList[] __initdata =
  555. {
  556. {ST_DOUT_NONE,                   EV_DOUT_START_XMIT,   dout_start_xmit},
  558. {ST_DOUT_SHORT_INIT,             EV_DOUT_COMPLETE,     dout_short_fifo},
  560. {ST_DOUT_SHORT_WAIT_DEN,         EV_DOUT_DEN,          dout_end_short_frame},
  561. {ST_DOUT_SHORT_WAIT_DEN,         EV_DOUT_UNDERRUN,     dout_underrun},
  563. {ST_DOUT_LONG_INIT,              EV_DOUT_COMPLETE,     dout_long_enable_fifo},
  565. {ST_DOUT_LONG_WAIT_DEN,          EV_DOUT_DEN,          dout_long_den},
  566. {ST_DOUT_LONG_WAIT_DEN,          EV_DOUT_UNDERRUN,     dout_underrun},
  568. {ST_DOUT_NORMAL,                 EV_DOUT_UNDERRUN,     dout_underrun},
  569. {ST_DOUT_NORMAL,                 EV_DOUT_COMPLETE,     dout_complete},
  571. {ST_DOUT_WAIT_FOR_UNDERRUN,      EV_DOUT_UNDERRUN,     dout_underrun},
  572. {ST_DOUT_WAIT_FOR_UNDERRUN,      EV_DOUT_COMPLETE,     dout_ignore},
  574. {ST_DOUT_WAIT_FOR_NOT_BUSY,      EV_DOUT_COMPLETE,     dout_check_busy},
  576. {ST_DOUT_WAIT_FOR_STOP,          EV_DOUT_STOPPED,      dout_reset},
  578. {ST_DOUT_WAIT_FOR_RESET,         EV_DOUT_RESETED,      dout_reseted},
  579. };
  581. void st5481_d_l2l1(struct hisax_if *hisax_d_if, int pr, void *arg)
  582. {
  583. struct st5481_adapter *adapter = hisax_d_if->priv;
  584. struct sk_buff *skb = arg;
  586. switch (pr) {
  587. case PH_ACTIVATE | REQUEST:
  588. FsmEvent(&adapter->l1m, EV_PH_ACTIVATE_REQ, NULL);
  589. break;
  590. case PH_DEACTIVATE | REQUEST:
  591. FsmEvent(&adapter->l1m, EV_PH_DEACTIVATE_REQ, NULL);
  592. break;
  593. case PH_DATA | REQUEST:
  594. DBG(2, "PH_DATA REQUEST len %d", skb->len);
  595. if (adapter->d_out.tx_skb)
  596. BUG();
  598. adapter->d_out.tx_skb = skb;
  599. FsmEvent(&adapter->d_out.fsm, EV_DOUT_START_XMIT, NULL);
  600. break;
  601. default:
  602. WARN("pr %#xn", pr);
  603. break;
  604. }
  605. }
  607. /* ======================================================================
  608.  */
  610. /*
  611.  * Start receiving on the D channel since entered state F7.
  612.  */
  613. static void ph_connect(struct st5481_adapter *adapter)
  614. {
  615. struct st5481_d_out *d_out = &adapter->d_out;
  616. struct st5481_in *d_in = &adapter->d_in;
  618. DBG(8,"");
  620. FsmChangeState(&d_out->fsm, ST_DOUT_NONE);
  622. // st5481_usb_device_ctrl_msg(adapter, FFMSK_D, OUT_UNDERRUN, NULL, NULL);
  623. st5481_usb_device_ctrl_msg(adapter, FFMSK_D, 0xfc, NULL, NULL);
  624. st5481_in_mode(d_in, L1_MODE_HDLC);
  626. #if LOOPBACK
  627. // Turn loopback on (data sent on B and D looped back)
  628. st5481_usb_device_ctrl_msg(cs, LBB, 0x04, NULL, NULL);
  629. #endif
  631. st5481_usb_pipe_reset(adapter, EP_D_OUT | USB_DIR_OUT, NULL, NULL);
  633. // Turn on the green LED to tell that we are in state F7
  634. adapter->leds |= GREEN_LED;
  635. st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, adapter->leds, NULL, NULL);
  636. }
  638. /*
  639.  * Stop receiving on the D channel since not in state F7.
  640.  */
  641. static void ph_disconnect(struct st5481_adapter *adapter)
  642. {
  643. DBG(8,"");
  645. st5481_in_mode(&adapter->d_in, L1_MODE_NULL);
  647. // Turn off the green LED to tell that we left state F7
  648. adapter->leds &= ~GREEN_LED;
  649. st5481_usb_device_ctrl_msg(adapter, GPIO_OUT, adapter->leds, NULL, NULL);
  650. }
  652. static int __devinit st5481_setup_d_out(struct st5481_adapter *adapter)
  653. {
  654. struct usb_device *dev = adapter->usb_dev;
  655. struct usb_interface_descriptor *altsetting;
  656. struct usb_endpoint_descriptor *endpoint;
  657. struct st5481_d_out *d_out = &adapter->d_out;
  659. DBG(2,"");
  661. altsetting = &(dev->config->interface[0].altsetting[3]);
  663. // Allocate URBs and buffers for the D channel out
  664. endpoint = &altsetting->endpoint[EP_D_OUT-1];
  666. DBG(2,"endpoint address=%02x,packet size=%d",
  667.     endpoint->bEndpointAddress,endpoint->wMaxPacketSize);
  669. return st5481_setup_isocpipes(d_out->urb, dev, 
  670.       usb_sndisocpipe(dev, endpoint->bEndpointAddress),
  671.       NUM_ISO_PACKETS_D, SIZE_ISO_PACKETS_D_OUT,
  672.       NUM_ISO_PACKETS_D * SIZE_ISO_PACKETS_D_OUT,
  673.       usb_d_out_complete, adapter);
  674. }
  676. static void st5481_release_d_out(struct st5481_adapter *adapter)
  677. {
  678. struct st5481_d_out *d_out = &adapter->d_out;
  680. DBG(2,"");
  682. st5481_release_isocpipes(d_out->urb);
  683. }
  685. int __devinit st5481_setup_d(struct st5481_adapter *adapter)
  686. {
  687. int retval;
  689. DBG(2,"");
  691. retval = st5481_setup_d_out(adapter);
  692. if (retval)
  693. goto err;
  694. adapter->d_in.bufsize = MAX_DFRAME_LEN_L1;
  695. adapter->d_in.num_packets = NUM_ISO_PACKETS_D;
  696. adapter->d_in.packet_size = SIZE_ISO_PACKETS_D_IN;
  697. adapter->d_in.ep = EP_D_IN | USB_DIR_IN;
  698. adapter->d_in.counter = IN_D_COUNTER;
  699. adapter->d_in.adapter = adapter;
  700. adapter->d_in.hisax_if = &adapter->hisax_d_if.ifc;
  701. retval = st5481_setup_in(&adapter->d_in);
  702. if (retval)
  703. goto err_d_out;
  705. adapter->l1m.fsm = &l1fsm;
  706. adapter->l1m.state = ST_L1_F3;
  707. adapter->l1m.debug = 1;
  708. adapter->l1m.userdata = adapter;
  709. adapter->l1m.printdebug = l1m_debug;
  710. FsmInitTimer(&adapter->l1m, &adapter->timer);
  712. adapter->d_out.fsm.fsm = &dout_fsm;
  713. adapter->d_out.fsm.state = ST_DOUT_NONE;
  714. adapter->d_out.fsm.debug = 1;
  715. adapter->d_out.fsm.userdata = adapter;
  716. adapter->d_out.fsm.printdebug = dout_debug;
  718. return 0;
  720.  err_d_out:
  721. st5481_release_d_out(adapter);
  722.  err:
  723. return retval;
  724. }
  726. void st5481_release_d(struct st5481_adapter *adapter)
  727. {
  728. DBG(2,"");
  730. st5481_release_in(&adapter->d_in);
  731. st5481_release_d_out(adapter);
  732. }
  734. /* ======================================================================
  735.  * init / exit
  736.  */
  738. int __init st5481_d_init(void)
  739. {
  740. int retval;
  742. l1fsm.state_count = L1_STATE_COUNT;
  743. l1fsm.event_count = L1_EVENT_COUNT;
  744. l1fsm.strEvent = strL1Event;
  745. l1fsm.strState = strL1State;
  746. retval = FsmNew(&l1fsm, L1FnList, ARRAY_SIZE(L1FnList));
  747. if (retval)
  748. goto err;
  750. dout_fsm.state_count = DOUT_STATE_COUNT;
  751. dout_fsm.event_count = DOUT_EVENT_COUNT;
  752. dout_fsm.strEvent = strDoutEvent;
  753. dout_fsm.strState = strDoutState;
  754. retval = FsmNew(&dout_fsm, DoutFnList, ARRAY_SIZE(DoutFnList));
  755. if (retval)
  756. goto err_l1;
  758. return 0;
  760.  err_l1:
  761. FsmFree(&l1fsm);
  762.  err:
  763. return retval;
  764. }
  766. // can't be __exit
  767. void st5481_d_exit(void)
  768. {
  769. FsmFree(&l1fsm);
  770. FsmFree(&dout_fsm);
  771. }