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

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

Linux/Unix编程

开发平台：

Unix_Linux

hfc_pci.c：源码内容
  1. /* $Id: hfc_pci.c,v 1.1.4.1 2001/11/20 14:19:35 kai Exp $
  2.  *
  3.  * low level driver for CCD磗 hfc-pci based cards
  4.  *
  5.  * Author       Werner Cornelius
  6.  *              based on existing driver for CCD hfc ISA cards
  7.  * Copyright    by Werner Cornelius  <werner@isdn4linux.de>
  8.  *              by Karsten Keil      <keil@isdn4linux.de>
  9.  * 
  10.  * This software may be used and distributed according to the terms
  11.  * of the GNU General Public License, incorporated herein by reference.
  12.  *
  13.  * For changes and modifications please read
  14.  * ../../../Documentation/isdn/HiSax.cert
  15.  *
  16.  */
  18. #include <linux/init.h>
  19. #include <linux/config.h>
  20. #define __NO_VERSION__
  21. #include "hisax.h"
  22. #include "hfc_pci.h"
  23. #include "isdnl1.h"
  24. #include <linux/pci.h>
  25. #include <linux/interrupt.h>
  27. extern const char *CardType[];
  29. static const char *hfcpci_revision = "$Revision: 1.1.4.1 $";
  31. /* table entry in the PCI devices list */
  32. typedef struct {
  33. int vendor_id;
  34. int device_id;
  35. char *vendor_name;
  36. char *card_name;
  37. } PCI_ENTRY;
  39. #define NT_T1_COUNT 20 /* number of 3.125ms interrupts for G2 timeout */
  40. #define CLKDEL_TE 0x0e /* CLKDEL in TE mode */
  41. #define CLKDEL_NT 0x6c /* CLKDEL in NT mode */
  43. static const PCI_ENTRY id_list[] =
  44. {
  45. {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_2BD0, "CCD/Billion/Asuscom", "2BD0"},
  46. {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B000, "Billion", "B000"},
  47. {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B006, "Billion", "B006"},
  48. {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B007, "Billion", "B007"},
  49. {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B008, "Billion", "B008"},
  50. {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B009, "Billion", "B009"},
  51. {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B00A, "Billion", "B00A"},
  52. {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B00B, "Billion", "B00B"},
  53. {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B00C, "Billion", "B00C"},
  54. {PCI_VENDOR_ID_CCD, PCI_DEVICE_ID_CCD_B100, "Seyeon", "B100"},
  55. {PCI_VENDOR_ID_ABOCOM, PCI_DEVICE_ID_ABOCOM_2BD1, "Abocom/Magitek", "2BD1"},
  56. {PCI_VENDOR_ID_ASUSTEK, PCI_DEVICE_ID_ASUSTEK_0675, "Asuscom/Askey", "675"},
  57. {PCI_VENDOR_ID_BERKOM, PCI_DEVICE_ID_BERKOM_T_CONCEPT, "German telekom", "T-Concept"},
  58. {PCI_VENDOR_ID_BERKOM, PCI_DEVICE_ID_BERKOM_A1T, "German telekom", "A1T"},
  59. {PCI_VENDOR_ID_ANIGMA, PCI_DEVICE_ID_ANIGMA_MC145575, "Motorola MC145575", "MC145575"},
  60. {PCI_VENDOR_ID_ZOLTRIX, PCI_DEVICE_ID_ZOLTRIX_2BD0, "Zoltrix", "2BD0"},
  61. {PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_DF_M_IOM2_E,"Digi International", "Digi DataFire Micro V IOM2 (Europe)"},
  62. {PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_DF_M_E,"Digi International", "Digi DataFire Micro V (Europe)"},
  63. {PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_DF_M_IOM2_A,"Digi International", "Digi DataFire Micro V IOM2 (North America)"},
  64. {PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_DF_M_A,"Digi International", "Digi DataFire Micro V (North America)"},
  65. {0, 0, NULL, NULL},
  66. };
  69. #if CONFIG_PCI
  71. /******************************************/
  72. /* free hardware resources used by driver */
  73. /******************************************/
  74. void
  75. release_io_hfcpci(struct IsdnCardState *cs)
  76. {
  77. unsigned long flags;
  79. printk(KERN_INFO "HiSax: release hfcpci at %pn",
  80. cs->hw.hfcpci.pci_io);
  81. save_flags(flags);
  82. cli();
  83. cs->hw.hfcpci.int_m2 = 0; /* interrupt output off ! */
  84. Write_hfc(cs, HFCPCI_INT_M2, cs->hw.hfcpci.int_m2);
  85. restore_flags(flags);
  86. Write_hfc(cs, HFCPCI_CIRM, HFCPCI_RESET); /* Reset On */
  87. sti();
  88. set_current_state(TASK_UNINTERRUPTIBLE);
  89. schedule_timeout((30 * HZ) / 1000); /* Timeout 30ms */
  90. Write_hfc(cs, HFCPCI_CIRM, 0); /* Reset Off */
  91. pcibios_write_config_word(cs->hw.hfcpci.pci_bus, cs->hw.hfcpci.pci_device_fn, PCI_COMMAND, 0); /* disable memory mapped ports + busmaster */
  92. del_timer(&cs->hw.hfcpci.timer);
  93. kfree(cs->hw.hfcpci.share_start);
  94. cs->hw.hfcpci.share_start = NULL;
  95. iounmap((void *)cs->hw.hfcpci.pci_io);
  96. }
  98. /********************************************************************************/
  99. /* function called to reset the HFC PCI chip. A complete software reset of chip */
  100. /* and fifos is done.                                                           */
  101. /********************************************************************************/
  102. static void
  103. reset_hfcpci(struct IsdnCardState *cs)
  104. {
  105. long flags;
  107. save_flags(flags);
  108. cli();
  109. pcibios_write_config_word(cs->hw.hfcpci.pci_bus, cs->hw.hfcpci.pci_device_fn, PCI_COMMAND, PCI_ENA_MEMIO); /* enable memory mapped ports, disable busmaster */
  110. cs->hw.hfcpci.int_m2 = 0; /* interrupt output off ! */
  111. Write_hfc(cs, HFCPCI_INT_M2, cs->hw.hfcpci.int_m2);
  113. printk(KERN_INFO "HFC_PCI: resetting cardn");
  114. pcibios_write_config_word(cs->hw.hfcpci.pci_bus, cs->hw.hfcpci.pci_device_fn, PCI_COMMAND, PCI_ENA_MEMIO + PCI_ENA_MASTER); /* enable memory ports + busmaster */
  115. Write_hfc(cs, HFCPCI_CIRM, HFCPCI_RESET); /* Reset On */
  116. sti();
  117. set_current_state(TASK_UNINTERRUPTIBLE);
  118. schedule_timeout((30 * HZ) / 1000); /* Timeout 30ms */
  119. Write_hfc(cs, HFCPCI_CIRM, 0); /* Reset Off */
  120. set_current_state(TASK_UNINTERRUPTIBLE);
  121. schedule_timeout((20 * HZ) / 1000); /* Timeout 20ms */
  122. if (Read_hfc(cs, HFCPCI_STATUS) & 2)
  123. printk(KERN_WARNING "HFC-PCI init bit busyn");
  125. cs->hw.hfcpci.fifo_en = 0x30; /* only D fifos enabled */
  126. Write_hfc(cs, HFCPCI_FIFO_EN, cs->hw.hfcpci.fifo_en);
  128. cs->hw.hfcpci.trm = 0 + HFCPCI_BTRANS_THRESMASK; /* no echo connect , threshold */
  129. Write_hfc(cs, HFCPCI_TRM, cs->hw.hfcpci.trm);
  131. Write_hfc(cs, HFCPCI_CLKDEL, CLKDEL_TE); /* ST-Bit delay for TE-Mode */
  132. cs->hw.hfcpci.sctrl_e = HFCPCI_AUTO_AWAKE;
  133. Write_hfc(cs, HFCPCI_SCTRL_E, cs->hw.hfcpci.sctrl_e); /* S/T Auto awake */
  134. cs->hw.hfcpci.bswapped = 0; /* no exchange */
  135. cs->hw.hfcpci.nt_mode = 0; /* we are in TE mode */
  136. cs->hw.hfcpci.ctmt = HFCPCI_TIM3_125 | HFCPCI_AUTO_TIMER;
  137. Write_hfc(cs, HFCPCI_CTMT, cs->hw.hfcpci.ctmt);
  139. cs->hw.hfcpci.int_m1 = HFCPCI_INTS_DTRANS | HFCPCI_INTS_DREC |
  140.     HFCPCI_INTS_L1STATE | HFCPCI_INTS_TIMER;
  141. Write_hfc(cs, HFCPCI_INT_M1, cs->hw.hfcpci.int_m1);
  143. /* Clear already pending ints */
  144. if (Read_hfc(cs, HFCPCI_INT_S1));
  146. Write_hfc(cs, HFCPCI_STATES, HFCPCI_LOAD_STATE | 2); /* HFC ST 2 */
  147. udelay(10);
  148. Write_hfc(cs, HFCPCI_STATES, 2); /* HFC ST 2 */
  149. cs->hw.hfcpci.mst_m = HFCPCI_MASTER; /* HFC Master Mode */
  151. Write_hfc(cs, HFCPCI_MST_MODE, cs->hw.hfcpci.mst_m);
  152. cs->hw.hfcpci.sctrl = 0x40; /* set tx_lo mode, error in datasheet ! */
  153. Write_hfc(cs, HFCPCI_SCTRL, cs->hw.hfcpci.sctrl);
  154. cs->hw.hfcpci.sctrl_r = 0;
  155. Write_hfc(cs, HFCPCI_SCTRL_R, cs->hw.hfcpci.sctrl_r);
  157. /* Init GCI/IOM2 in master mode */
  158. /* Slots 0 and 1 are set for B-chan 1 and 2 */
  159. /* D- and monitor/CI channel are not enabled */
  160. /* STIO1 is used as output for data, B1+B2 from ST->IOM+HFC */
  161. /* STIO2 is used as data input, B1+B2 from IOM->ST */
  162. /* ST B-channel send disabled -> continous 1s */
  163. /* The IOM slots are always enabled */
  164. cs->hw.hfcpci.conn = 0x36; /* set data flow directions */
  165. Write_hfc(cs, HFCPCI_CONNECT, cs->hw.hfcpci.conn);
  166. Write_hfc(cs, HFCPCI_B1_SSL, 0x80); /* B1-Slot 0 STIO1 out enabled */
  167. Write_hfc(cs, HFCPCI_B2_SSL, 0x81); /* B2-Slot 1 STIO1 out enabled */
  168. Write_hfc(cs, HFCPCI_B1_RSL, 0x80); /* B1-Slot 0 STIO2 in enabled */
  169. Write_hfc(cs, HFCPCI_B2_RSL, 0x81); /* B2-Slot 1 STIO2 in enabled */
  171. /* Finally enable IRQ output */
  172. cs->hw.hfcpci.int_m2 = HFCPCI_IRQ_ENABLE;
  173. Write_hfc(cs, HFCPCI_INT_M2, cs->hw.hfcpci.int_m2);
  174. if (Read_hfc(cs, HFCPCI_INT_S2));
  175. restore_flags(flags);
  176. }
  178. /***************************************************/
  179. /* Timer function called when kernel timer expires */
  180. /***************************************************/
  181. static void
  182. hfcpci_Timer(struct IsdnCardState *cs)
  183. {
  184. cs->hw.hfcpci.timer.expires = jiffies + 75;
  185. /* WD RESET */
  186. /*      WriteReg(cs, HFCD_DATA, HFCD_CTMT, cs->hw.hfcpci.ctmt | 0x80);
  187.    add_timer(&cs->hw.hfcpci.timer);
  188.  */
  189. }
  192. /*********************************/
  193. /* schedule a new D-channel task */
  194. /*********************************/
  195. static void
  196. sched_event_D_pci(struct IsdnCardState *cs, int event)
  197. {
  198. test_and_set_bit(event, &cs->event);
  199. queue_task(&cs->tqueue, &tq_immediate);
  200. mark_bh(IMMEDIATE_BH);
  201. }
  203. /*********************************/
  204. /* schedule a new b_channel task */
  205. /*********************************/
  206. static void
  207. hfcpci_sched_event(struct BCState *bcs, int event)
  208. {
  209. bcs->event |= 1 << event;
  210. queue_task(&bcs->tqueue, &tq_immediate);
  211. mark_bh(IMMEDIATE_BH);
  212. }
  214. /************************************************/
  215. /* select a b-channel entry matching and active */
  216. /************************************************/
  217. static
  218. struct BCState *
  219. Sel_BCS(struct IsdnCardState *cs, int channel)
  220. {
  221. if (cs->bcs[0].mode && (cs->bcs[0].channel == channel))
  222. return (&cs->bcs[0]);
  223. else if (cs->bcs[1].mode && (cs->bcs[1].channel == channel))
  224. return (&cs->bcs[1]);
  225. else
  226. return (NULL);
  227. }
  229. /***************************************/
  230. /* clear the desired B-channel rx fifo */
  231. /***************************************/
  232. static void hfcpci_clear_fifo_rx(struct IsdnCardState *cs, int fifo)
  233. {       u_char fifo_state;
  234.         bzfifo_type *bzr;
  236. if (fifo) {
  237.         bzr = &((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.rxbz_b2;
  238. fifo_state = cs->hw.hfcpci.fifo_en & HFCPCI_FIFOEN_B2RX;
  239. } else {
  240.         bzr = &((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.rxbz_b1;
  241. fifo_state = cs->hw.hfcpci.fifo_en & HFCPCI_FIFOEN_B1RX;
  242. }
  243. if (fifo_state)
  244.         cs->hw.hfcpci.fifo_en ^= fifo_state;
  245. Write_hfc(cs, HFCPCI_FIFO_EN, cs->hw.hfcpci.fifo_en);
  246. cs->hw.hfcpci.last_bfifo_cnt[fifo] = 0;
  247. bzr->za[MAX_B_FRAMES].z1 = B_FIFO_SIZE + B_SUB_VAL - 1;
  248. bzr->za[MAX_B_FRAMES].z2 = bzr->za[MAX_B_FRAMES].z1;
  249. bzr->f1 = MAX_B_FRAMES;
  250. bzr->f2 = bzr->f1; /* init F pointers to remain constant */
  251. if (fifo_state)
  252.         cs->hw.hfcpci.fifo_en |= fifo_state;
  253. Write_hfc(cs, HFCPCI_FIFO_EN, cs->hw.hfcpci.fifo_en);
  254. }   
  256. /***************************************/
  257. /* clear the desired B-channel tx fifo */
  258. /***************************************/
  259. static void hfcpci_clear_fifo_tx(struct IsdnCardState *cs, int fifo)
  260. {       u_char fifo_state;
  261.         bzfifo_type *bzt;
  263. if (fifo) {
  264.         bzt = &((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.txbz_b2;
  265. fifo_state = cs->hw.hfcpci.fifo_en & HFCPCI_FIFOEN_B2TX;
  266. } else {
  267.         bzt = &((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.txbz_b1;
  268. fifo_state = cs->hw.hfcpci.fifo_en & HFCPCI_FIFOEN_B1TX;
  269. }
  270. if (fifo_state)
  271.         cs->hw.hfcpci.fifo_en ^= fifo_state;
  272. Write_hfc(cs, HFCPCI_FIFO_EN, cs->hw.hfcpci.fifo_en);
  273. bzt->za[MAX_B_FRAMES].z1 = B_FIFO_SIZE + B_SUB_VAL - 1;
  274. bzt->za[MAX_B_FRAMES].z2 = bzt->za[MAX_B_FRAMES].z1;
  275. bzt->f1 = MAX_B_FRAMES;
  276. bzt->f2 = bzt->f1; /* init F pointers to remain constant */
  277. if (fifo_state)
  278.         cs->hw.hfcpci.fifo_en |= fifo_state;
  279. Write_hfc(cs, HFCPCI_FIFO_EN, cs->hw.hfcpci.fifo_en);
  280. }   
  282. /*********************************************/
  283. /* read a complete B-frame out of the buffer */
  284. /*********************************************/
  285. static struct sk_buff
  286. *
  287. hfcpci_empty_fifo(struct BCState *bcs, bzfifo_type * bz, u_char * bdata, int count)
  288. {
  289. u_char *ptr, *ptr1, new_f2;
  290. struct sk_buff *skb;
  291. struct IsdnCardState *cs = bcs->cs;
  292. unsigned long flags;
  293. int total, maxlen, new_z2;
  294. z_type *zp;
  296. save_flags(flags);
  297. sti();
  298. if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
  299. debugl1(cs, "hfcpci_empty_fifo");
  300. zp = &bz->za[bz->f2]; /* point to Z-Regs */
  301. new_z2 = zp->z2 + count; /* new position in fifo */
  302. if (new_z2 >= (B_FIFO_SIZE + B_SUB_VAL))
  303. new_z2 -= B_FIFO_SIZE; /* buffer wrap */
  304. new_f2 = (bz->f2 + 1) & MAX_B_FRAMES;
  305. if ((count > HSCX_BUFMAX + 3) || (count < 4) ||
  306.     (*(bdata + (zp->z1 - B_SUB_VAL)))) {
  307. if (cs->debug & L1_DEB_WARN)
  308. debugl1(cs, "hfcpci_empty_fifo: incoming packet invalid length %d or crc", count);
  309. #ifdef ERROR_STATISTIC
  310. bcs->err_inv++;
  311. #endif
  312. bz->za[new_f2].z2 = new_z2;
  313. bz->f2 = new_f2; /* next buffer */
  314. skb = NULL;
  315. } else if (!(skb = dev_alloc_skb(count - 3)))
  316. printk(KERN_WARNING "HFCPCI: receive out of memoryn");
  317. else {
  318. total = count;
  319. count -= 3;
  320. ptr = skb_put(skb, count);
  322. if (zp->z2 + count <= B_FIFO_SIZE + B_SUB_VAL)
  323. maxlen = count; /* complete transfer */
  324. else
  325. maxlen = B_FIFO_SIZE + B_SUB_VAL - zp->z2; /* maximum */
  327. ptr1 = bdata + (zp->z2 - B_SUB_VAL); /* start of data */
  328. memcpy(ptr, ptr1, maxlen); /* copy data */
  329. count -= maxlen;
  331. if (count) { /* rest remaining */
  332. ptr += maxlen;
  333. ptr1 = bdata; /* start of buffer */
  334. memcpy(ptr, ptr1, count); /* rest */
  335. }
  336. bz->za[new_f2].z2 = new_z2;
  337. bz->f2 = new_f2; /* next buffer */
  339. }
  340. restore_flags(flags);
  341. return (skb);
  342. }
  344. /*******************************/
  345. /* D-channel receive procedure */
  346. /*******************************/
  347. static
  348. int
  349. receive_dmsg(struct IsdnCardState *cs)
  350. {
  351. struct sk_buff *skb;
  352. int maxlen;
  353. int rcnt, total;
  354. int count = 5;
  355. u_char *ptr, *ptr1;
  356. dfifo_type *df;
  357. z_type *zp;
  359. df = &((fifo_area *) (cs->hw.hfcpci.fifos))->d_chan.d_rx;
  360. if (test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  361. debugl1(cs, "rec_dmsg blocked");
  362. return (1);
  363. }
  364. while (((df->f1 & D_FREG_MASK) != (df->f2 & D_FREG_MASK)) && count--) {
  365. zp = &df->za[df->f2 & D_FREG_MASK];
  366. rcnt = zp->z1 - zp->z2;
  367. if (rcnt < 0)
  368. rcnt += D_FIFO_SIZE;
  369. rcnt++;
  370. if (cs->debug & L1_DEB_ISAC)
  371. debugl1(cs, "hfcpci recd f1(%d) f2(%d) z1(%x) z2(%x) cnt(%d)",
  372. df->f1, df->f2, zp->z1, zp->z2, rcnt);
  374. if ((rcnt > MAX_DFRAME_LEN + 3) || (rcnt < 4) ||
  375.     (df->data[zp->z1])) {
  376. if (cs->debug & L1_DEB_WARN)
  377. debugl1(cs, "empty_fifo hfcpci paket inv. len %d or crc %d", rcnt, df->data[zp->z1]);
  378. #ifdef ERROR_STATISTIC
  379. cs->err_rx++;
  380. #endif
  381. df->f2 = ((df->f2 + 1) & MAX_D_FRAMES) | (MAX_D_FRAMES + 1); /* next buffer */
  382. df->za[df->f2 & D_FREG_MASK].z2 = (zp->z2 + rcnt) & (D_FIFO_SIZE - 1);
  383. } else if ((skb = dev_alloc_skb(rcnt - 3))) {
  384. total = rcnt;
  385. rcnt -= 3;
  386. ptr = skb_put(skb, rcnt);
  388. if (zp->z2 + rcnt <= D_FIFO_SIZE)
  389. maxlen = rcnt; /* complete transfer */
  390. else
  391. maxlen = D_FIFO_SIZE - zp->z2; /* maximum */
  393. ptr1 = df->data + zp->z2; /* start of data */
  394. memcpy(ptr, ptr1, maxlen); /* copy data */
  395. rcnt -= maxlen;
  397. if (rcnt) { /* rest remaining */
  398. ptr += maxlen;
  399. ptr1 = df->data; /* start of buffer */
  400. memcpy(ptr, ptr1, rcnt); /* rest */
  401. }
  402. df->f2 = ((df->f2 + 1) & MAX_D_FRAMES) | (MAX_D_FRAMES + 1); /* next buffer */
  403. df->za[df->f2 & D_FREG_MASK].z2 = (zp->z2 + total) & (D_FIFO_SIZE - 1);
  405. skb_queue_tail(&cs->rq, skb);
  406. sched_event_D_pci(cs, D_RCVBUFREADY);
  407. } else
  408. printk(KERN_WARNING "HFC-PCI: D receive out of memoryn");
  409. }
  410. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  411. return (1);
  412. }
  414. /*******************************************************************************/
  415. /* check for transparent receive data and read max one threshold size if avail */
  416. /*******************************************************************************/
  417. int
  418. hfcpci_empty_fifo_trans(struct BCState *bcs, bzfifo_type * bz, u_char * bdata)
  419. {
  420. unsigned short *z1r, *z2r;
  421. int new_z2, fcnt, maxlen;
  422. struct sk_buff *skb;
  423. u_char *ptr, *ptr1;
  425. z1r = &bz->za[MAX_B_FRAMES].z1; /* pointer to z reg */
  426. z2r = z1r + 1;
  428. if (!(fcnt = *z1r - *z2r))
  429. return (0); /* no data avail */
  431. if (fcnt <= 0)
  432. fcnt += B_FIFO_SIZE; /* bytes actually buffered */
  433. if (fcnt > HFCPCI_BTRANS_THRESHOLD)
  434. fcnt = HFCPCI_BTRANS_THRESHOLD; /* limit size */
  436. new_z2 = *z2r + fcnt; /* new position in fifo */
  437. if (new_z2 >= (B_FIFO_SIZE + B_SUB_VAL))
  438. new_z2 -= B_FIFO_SIZE; /* buffer wrap */
  440. if (!(skb = dev_alloc_skb(fcnt)))
  441. printk(KERN_WARNING "HFCPCI: receive out of memoryn");
  442. else {
  443. ptr = skb_put(skb, fcnt);
  444. if (*z2r + fcnt <= B_FIFO_SIZE + B_SUB_VAL)
  445. maxlen = fcnt; /* complete transfer */
  446. else
  447. maxlen = B_FIFO_SIZE + B_SUB_VAL - *z2r; /* maximum */
  449. ptr1 = bdata + (*z2r - B_SUB_VAL); /* start of data */
  450. memcpy(ptr, ptr1, maxlen); /* copy data */
  451. fcnt -= maxlen;
  453. if (fcnt) { /* rest remaining */
  454. ptr += maxlen;
  455. ptr1 = bdata; /* start of buffer */
  456. memcpy(ptr, ptr1, fcnt); /* rest */
  457. }
  458. cli();
  459. skb_queue_tail(&bcs->rqueue, skb);
  460. sti();
  461. hfcpci_sched_event(bcs, B_RCVBUFREADY);
  462. }
  464. *z2r = new_z2; /* new position */
  465. return (1);
  466. } /* hfcpci_empty_fifo_trans */
  468. /**********************************/
  469. /* B-channel main receive routine */
  470. /**********************************/
  471. void
  472. main_rec_hfcpci(struct BCState *bcs)
  473. {
  474. long flags;
  475. struct IsdnCardState *cs = bcs->cs;
  476. int rcnt, real_fifo;
  477. int receive, count = 5;
  478. struct sk_buff *skb;
  479. bzfifo_type *bz;
  480. u_char *bdata;
  481. z_type *zp;
  484. save_flags(flags);
  485. if ((bcs->channel) && (!cs->hw.hfcpci.bswapped)) {
  486. bz = &((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.rxbz_b2;
  487. bdata = ((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.rxdat_b2;
  488. real_fifo = 1;
  489. } else {
  490. bz = &((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.rxbz_b1;
  491. bdata = ((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.rxdat_b1;
  492. real_fifo = 0;
  493. }
  494.       Begin:
  495. count--;
  496. cli();
  497. if (test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  498. debugl1(cs, "rec_data %d blocked", bcs->channel);
  499. restore_flags(flags);
  500. return;
  501. }
  502. sti();
  503. if (bz->f1 != bz->f2) {
  504. if (cs->debug & L1_DEB_HSCX)
  505. debugl1(cs, "hfcpci rec %d f1(%d) f2(%d)",
  506. bcs->channel, bz->f1, bz->f2);
  507. zp = &bz->za[bz->f2];
  509. rcnt = zp->z1 - zp->z2;
  510. if (rcnt < 0)
  511. rcnt += B_FIFO_SIZE;
  512. rcnt++;
  513. if (cs->debug & L1_DEB_HSCX)
  514. debugl1(cs, "hfcpci rec %d z1(%x) z2(%x) cnt(%d)",
  515. bcs->channel, zp->z1, zp->z2, rcnt);
  516. if ((skb = hfcpci_empty_fifo(bcs, bz, bdata, rcnt))) {
  517. cli();
  518. skb_queue_tail(&bcs->rqueue, skb);
  519. sti();
  520. hfcpci_sched_event(bcs, B_RCVBUFREADY);
  521. }
  522. rcnt = bz->f1 - bz->f2;
  523. if (rcnt < 0)
  524. rcnt += MAX_B_FRAMES + 1;
  525. if (cs->hw.hfcpci.last_bfifo_cnt[real_fifo] > rcnt + 1) {
  526.         rcnt = 0;
  527. hfcpci_clear_fifo_rx(cs, real_fifo);
  528. }
  529. cs->hw.hfcpci.last_bfifo_cnt[real_fifo] = rcnt;
  530. if (rcnt > 1)
  531. receive = 1;
  532. else
  533. receive = 0;
  534. } else if (bcs->mode == L1_MODE_TRANS)
  535. receive = hfcpci_empty_fifo_trans(bcs, bz, bdata);
  536. else
  537. receive = 0;
  538. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  539. if (count && receive)
  540. goto Begin;
  541. restore_flags(flags);
  542. return;
  543. }
  545. /**************************/
  546. /* D-channel send routine */
  547. /**************************/
  548. static void
  549. hfcpci_fill_dfifo(struct IsdnCardState *cs)
  550. {
  551. long flags;
  552. int fcnt;
  553. int count, new_z1, maxlen;
  554. dfifo_type *df;
  555. u_char *src, *dst, new_f1;
  557. if (!cs->tx_skb)
  558. return;
  559. if (cs->tx_skb->len <= 0)
  560. return;
  562. df = &((fifo_area *) (cs->hw.hfcpci.fifos))->d_chan.d_tx;
  564. if (cs->debug & L1_DEB_ISAC)
  565. debugl1(cs, "hfcpci_fill_Dfifo f1(%d) f2(%d) z1(f1)(%x)",
  566. df->f1, df->f2,
  567. df->za[df->f1 & D_FREG_MASK].z1);
  568. fcnt = df->f1 - df->f2; /* frame count actually buffered */
  569. if (fcnt < 0)
  570. fcnt += (MAX_D_FRAMES + 1); /* if wrap around */
  571. if (fcnt > (MAX_D_FRAMES - 1)) {
  572. if (cs->debug & L1_DEB_ISAC)
  573. debugl1(cs, "hfcpci_fill_Dfifo more as 14 frames");
  574. #ifdef ERROR_STATISTIC
  575. cs->err_tx++;
  576. #endif
  577. return;
  578. }
  579. /* now determine free bytes in FIFO buffer */
  580. count = df->za[df->f1 & D_FREG_MASK].z2 - df->za[df->f1 & D_FREG_MASK].z1;
  581. if (count <= 0)
  582. count += D_FIFO_SIZE; /* count now contains available bytes */
  584. if (cs->debug & L1_DEB_ISAC)
  585. debugl1(cs, "hfcpci_fill_Dfifo count(%ld/%d)",
  586. cs->tx_skb->len, count);
  587. if (count < cs->tx_skb->len) {
  588. if (cs->debug & L1_DEB_ISAC)
  589. debugl1(cs, "hfcpci_fill_Dfifo no fifo mem");
  590. return;
  591. }
  592. count = cs->tx_skb->len; /* get frame len */
  593. new_z1 = (df->za[df->f1 & D_FREG_MASK].z1 + count) & (D_FIFO_SIZE - 1);
  594. new_f1 = ((df->f1 + 1) & D_FREG_MASK) | (D_FREG_MASK + 1);
  595. src = cs->tx_skb->data; /* source pointer */
  596. dst = df->data + df->za[df->f1 & D_FREG_MASK].z1;
  597. maxlen = D_FIFO_SIZE - df->za[df->f1 & D_FREG_MASK].z1; /* end fifo */
  598. if (maxlen > count)
  599. maxlen = count; /* limit size */
  600. memcpy(dst, src, maxlen); /* first copy */
  602. count -= maxlen; /* remaining bytes */
  603. if (count) {
  604. dst = df->data; /* start of buffer */
  605. src += maxlen; /* new position */
  606. memcpy(dst, src, count);
  607. }
  608. save_flags(flags);
  609. cli();
  610. df->za[new_f1 & D_FREG_MASK].z1 = new_z1; /* for next buffer */
  611. df->za[df->f1 & D_FREG_MASK].z1 = new_z1; /* new pos actual buffer */
  612. df->f1 = new_f1; /* next frame */
  613. restore_flags(flags);
  615. dev_kfree_skb_any(cs->tx_skb);
  616. cs->tx_skb = NULL;
  617. return;
  618. }
  620. /**************************/
  621. /* B-channel send routine */
  622. /**************************/
  623. static void
  624. hfcpci_fill_fifo(struct BCState *bcs)
  625. {
  626. struct IsdnCardState *cs = bcs->cs;
  627. unsigned long flags;
  628. int maxlen, fcnt;
  629. int count, new_z1;
  630. bzfifo_type *bz;
  631. u_char *bdata;
  632. u_char new_f1, *src, *dst;
  633. unsigned short *z1t, *z2t;
  635. if (!bcs->tx_skb)
  636. return;
  637. if (bcs->tx_skb->len <= 0)
  638. return;
  640. save_flags(flags);
  641. sti();
  643. if ((bcs->channel) && (!cs->hw.hfcpci.bswapped)) {
  644. bz = &((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.txbz_b2;
  645. bdata = ((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.txdat_b2;
  646. } else {
  647. bz = &((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.txbz_b1;
  648. bdata = ((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.txdat_b1;
  649. }
  651. if (bcs->mode == L1_MODE_TRANS) {
  652. z1t = &bz->za[MAX_B_FRAMES].z1;
  653. z2t = z1t + 1;
  654. if (cs->debug & L1_DEB_HSCX)
  655. debugl1(cs, "hfcpci_fill_fifo_trans %d z1(%x) z2(%x)",
  656. bcs->channel, *z1t, *z2t);
  657. fcnt = *z2t - *z1t;
  658. if (fcnt <= 0)
  659. fcnt += B_FIFO_SIZE; /* fcnt contains available bytes in fifo */
  660. fcnt = B_FIFO_SIZE - fcnt; /* remaining bytes to send */
  662. while ((fcnt < 2 * HFCPCI_BTRANS_THRESHOLD) && (bcs->tx_skb)) {
  663. if (bcs->tx_skb->len < B_FIFO_SIZE - fcnt) {
  664. /* data is suitable for fifo */
  665. count = bcs->tx_skb->len;
  667. new_z1 = *z1t + count; /* new buffer Position */
  668. if (new_z1 >= (B_FIFO_SIZE + B_SUB_VAL))
  669. new_z1 -= B_FIFO_SIZE; /* buffer wrap */
  670. src = bcs->tx_skb->data; /* source pointer */
  671. dst = bdata + (*z1t - B_SUB_VAL);
  672. maxlen = (B_FIFO_SIZE + B_SUB_VAL) - *z1t; /* end of fifo */
  673. if (maxlen > count)
  674. maxlen = count; /* limit size */
  675. memcpy(dst, src, maxlen); /* first copy */
  677. count -= maxlen; /* remaining bytes */
  678. if (count) {
  679. dst = bdata; /* start of buffer */
  680. src += maxlen; /* new position */
  681. memcpy(dst, src, count);
  682. }
  683. bcs->tx_cnt -= bcs->tx_skb->len;
  684. fcnt += bcs->tx_skb->len;
  685. *z1t = new_z1; /* now send data */
  686. } else if (cs->debug & L1_DEB_HSCX)
  687. debugl1(cs, "hfcpci_fill_fifo_trans %d frame length %d discarded",
  688. bcs->channel, bcs->tx_skb->len);
  690. dev_kfree_skb_any(bcs->tx_skb);
  691. cli();
  692. bcs->tx_skb = skb_dequeue(&bcs->squeue); /* fetch next data */
  693. sti();
  694. }
  695. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  696. restore_flags(flags);
  697. return;
  698. }
  699. if (cs->debug & L1_DEB_HSCX)
  700. debugl1(cs, "hfcpci_fill_fifo_hdlc %d f1(%d) f2(%d) z1(f1)(%x)",
  701. bcs->channel, bz->f1, bz->f2,
  702. bz->za[bz->f1].z1);
  704. fcnt = bz->f1 - bz->f2; /* frame count actually buffered */
  705. if (fcnt < 0)
  706. fcnt += (MAX_B_FRAMES + 1); /* if wrap around */
  707. if (fcnt > (MAX_B_FRAMES - 1)) {
  708. if (cs->debug & L1_DEB_HSCX)
  709. debugl1(cs, "hfcpci_fill_Bfifo more as 14 frames");
  710. restore_flags(flags);
  711. return;
  712. }
  713. /* now determine free bytes in FIFO buffer */
  714. count = bz->za[bz->f1].z2 - bz->za[bz->f1].z1;
  715. if (count <= 0)
  716. count += B_FIFO_SIZE; /* count now contains available bytes */
  718. if (cs->debug & L1_DEB_HSCX)
  719. debugl1(cs, "hfcpci_fill_fifo %d count(%ld/%d),%lx",
  720. bcs->channel, bcs->tx_skb->len,
  721. count, current->state);
  723. if (count < bcs->tx_skb->len) {
  724. if (cs->debug & L1_DEB_HSCX)
  725. debugl1(cs, "hfcpci_fill_fifo no fifo mem");
  726. restore_flags(flags);
  727. return;
  728. }
  729. count = bcs->tx_skb->len; /* get frame len */
  730. new_z1 = bz->za[bz->f1].z1 + count; /* new buffer Position */
  731. if (new_z1 >= (B_FIFO_SIZE + B_SUB_VAL))
  732. new_z1 -= B_FIFO_SIZE; /* buffer wrap */
  734. new_f1 = ((bz->f1 + 1) & MAX_B_FRAMES);
  735. src = bcs->tx_skb->data; /* source pointer */
  736. dst = bdata + (bz->za[bz->f1].z1 - B_SUB_VAL);
  737. maxlen = (B_FIFO_SIZE + B_SUB_VAL) - bz->za[bz->f1].z1; /* end fifo */
  738. if (maxlen > count)
  739. maxlen = count; /* limit size */
  740. memcpy(dst, src, maxlen); /* first copy */
  742. count -= maxlen; /* remaining bytes */
  743. if (count) {
  744. dst = bdata; /* start of buffer */
  745. src += maxlen; /* new position */
  746. memcpy(dst, src, count);
  747. }
  748. bcs->tx_cnt -= bcs->tx_skb->len;
  749. if (bcs->st->lli.l1writewakeup &&
  750.     (PACKET_NOACK != bcs->tx_skb->pkt_type))
  751. bcs->st->lli.l1writewakeup(bcs->st, bcs->tx_skb->len);
  753. cli();
  754. bz->za[new_f1].z1 = new_z1; /* for next buffer */
  755. bz->f1 = new_f1; /* next frame */
  756. restore_flags(flags);
  758. dev_kfree_skb_any(bcs->tx_skb);
  759. bcs->tx_skb = NULL;
  760. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  761. return;
  762. }
  764. /**********************************************/
  765. /* D-channel l1 state call for leased NT-mode */
  766. /**********************************************/
  767. static void
  768. dch_nt_l2l1(struct PStack *st, int pr, void *arg)
  769. {
  770. struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;
  772. switch (pr) {
  773. case (PH_DATA | REQUEST):
  774. case (PH_PULL | REQUEST):
  775. case (PH_PULL | INDICATION):
  776. st->l1.l1hw(st, pr, arg);
  777. break;
  778. case (PH_ACTIVATE | REQUEST):
  779. st->l1.l1l2(st, PH_ACTIVATE | CONFIRM, NULL);
  780. break;
  781. case (PH_TESTLOOP | REQUEST):
  782. if (1 & (long) arg)
  783. debugl1(cs, "PH_TEST_LOOP B1");
  784. if (2 & (long) arg)
  785. debugl1(cs, "PH_TEST_LOOP B2");
  786. if (!(3 & (long) arg))
  787. debugl1(cs, "PH_TEST_LOOP DISABLED");
  788. st->l1.l1hw(st, HW_TESTLOOP | REQUEST, arg);
  789. break;
  790. default:
  791. if (cs->debug)
  792. debugl1(cs, "dch_nt_l2l1 msg %04X unhandled", pr);
  793. break;
  794. }
  795. }
  799. /***********************/
  800. /* set/reset echo mode */
  801. /***********************/
  802. static int
  803. hfcpci_auxcmd(struct IsdnCardState *cs, isdn_ctrl * ic)
  804. {
  805. unsigned long flags;
  806. int i = *(unsigned int *) ic->parm.num;
  808. if ((ic->arg == 98) &&
  809.     (!(cs->hw.hfcpci.int_m1 & (HFCPCI_INTS_B2TRANS + HFCPCI_INTS_B2REC + HFCPCI_INTS_B1TRANS + HFCPCI_INTS_B1REC)))) {
  810. save_flags(flags);
  811. cli();
  812. Write_hfc(cs, HFCPCI_CLKDEL, CLKDEL_NT); /* ST-Bit delay for NT-Mode */
  813. Write_hfc(cs, HFCPCI_STATES, HFCPCI_LOAD_STATE | 0); /* HFC ST G0 */
  814. udelay(10);
  815. cs->hw.hfcpci.sctrl |= SCTRL_MODE_NT;
  816. Write_hfc(cs, HFCPCI_SCTRL, cs->hw.hfcpci.sctrl); /* set NT-mode */
  817. udelay(10);
  818. Write_hfc(cs, HFCPCI_STATES, HFCPCI_LOAD_STATE | 1); /* HFC ST G1 */
  819. udelay(10);
  820. Write_hfc(cs, HFCPCI_STATES, 1 | HFCPCI_ACTIVATE | HFCPCI_DO_ACTION);
  821. cs->dc.hfcpci.ph_state = 1;
  822. cs->hw.hfcpci.nt_mode = 1;
  823. cs->hw.hfcpci.nt_timer = 0;
  824. cs->stlist->l2.l2l1 = dch_nt_l2l1;
  825. restore_flags(flags);
  826. debugl1(cs, "NT mode activated");
  827. return (0);
  828. }
  829. if ((cs->chanlimit > 1) || (cs->hw.hfcpci.bswapped) ||
  830.     (cs->hw.hfcpci.nt_mode) || (ic->arg != 12))
  831. return (-EINVAL);
  833. save_flags(flags);
  834. cli();
  835. if (i) {
  836. cs->logecho = 1;
  837. cs->hw.hfcpci.trm |= 0x20; /* enable echo chan */
  838. cs->hw.hfcpci.int_m1 |= HFCPCI_INTS_B2REC;
  839. cs->hw.hfcpci.fifo_en |= HFCPCI_FIFOEN_B2RX;
  840. } else {
  841. cs->logecho = 0;
  842. cs->hw.hfcpci.trm &= ~0x20; /* disable echo chan */
  843. cs->hw.hfcpci.int_m1 &= ~HFCPCI_INTS_B2REC;
  844. cs->hw.hfcpci.fifo_en &= ~HFCPCI_FIFOEN_B2RX;
  845. }
  846. cs->hw.hfcpci.sctrl_r &= ~SCTRL_B2_ENA;
  847. cs->hw.hfcpci.sctrl &= ~SCTRL_B2_ENA;
  848. cs->hw.hfcpci.conn |= 0x10; /* B2-IOM -> B2-ST */
  849. cs->hw.hfcpci.ctmt &= ~2;
  850. Write_hfc(cs, HFCPCI_CTMT, cs->hw.hfcpci.ctmt);
  851. Write_hfc(cs, HFCPCI_SCTRL_R, cs->hw.hfcpci.sctrl_r);
  852. Write_hfc(cs, HFCPCI_SCTRL, cs->hw.hfcpci.sctrl);
  853. Write_hfc(cs, HFCPCI_CONNECT, cs->hw.hfcpci.conn);
  854. Write_hfc(cs, HFCPCI_TRM, cs->hw.hfcpci.trm);
  855. Write_hfc(cs, HFCPCI_FIFO_EN, cs->hw.hfcpci.fifo_en);
  856. Write_hfc(cs, HFCPCI_INT_M1, cs->hw.hfcpci.int_m1);
  857. restore_flags(flags);
  858. return (0);
  859. } /* hfcpci_auxcmd */
  861. /*****************************/
  862. /* E-channel receive routine */
  863. /*****************************/
  864. static void
  865. receive_emsg(struct IsdnCardState *cs)
  866. {
  867. long flags;
  868. int rcnt;
  869. int receive, count = 5;
  870. bzfifo_type *bz;
  871. u_char *bdata;
  872. z_type *zp;
  873. u_char *ptr, *ptr1, new_f2;
  874. int total, maxlen, new_z2;
  875. u_char e_buffer[256];
  877. save_flags(flags);
  878. bz = &((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.rxbz_b2;
  879. bdata = ((fifo_area *) (cs->hw.hfcpci.fifos))->b_chans.rxdat_b2;
  880.       Begin:
  881. count--;
  882. cli();
  883. if (test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  884. debugl1(cs, "echo_rec_data blocked");
  885. restore_flags(flags);
  886. return;
  887. }
  888. sti();
  889. if (bz->f1 != bz->f2) {
  890. if (cs->debug & L1_DEB_ISAC)
  891. debugl1(cs, "hfcpci e_rec f1(%d) f2(%d)",
  892. bz->f1, bz->f2);
  893. zp = &bz->za[bz->f2];
  895. rcnt = zp->z1 - zp->z2;
  896. if (rcnt < 0)
  897. rcnt += B_FIFO_SIZE;
  898. rcnt++;
  899. if (cs->debug & L1_DEB_ISAC)
  900. debugl1(cs, "hfcpci e_rec z1(%x) z2(%x) cnt(%d)",
  901. zp->z1, zp->z2, rcnt);
  902. new_z2 = zp->z2 + rcnt; /* new position in fifo */
  903. if (new_z2 >= (B_FIFO_SIZE + B_SUB_VAL))
  904. new_z2 -= B_FIFO_SIZE; /* buffer wrap */
  905. new_f2 = (bz->f2 + 1) & MAX_B_FRAMES;
  906. if ((rcnt > 256 + 3) || (count < 4) ||
  907.     (*(bdata + (zp->z1 - B_SUB_VAL)))) {
  908. if (cs->debug & L1_DEB_WARN)
  909. debugl1(cs, "hfcpci_empty_echan: incoming packet invalid length %d or crc", rcnt);
  910. bz->za[new_f2].z2 = new_z2;
  911. bz->f2 = new_f2; /* next buffer */
  912. } else {
  913. total = rcnt;
  914. rcnt -= 3;
  915. ptr = e_buffer;
  917. if (zp->z2 <= B_FIFO_SIZE + B_SUB_VAL)
  918. maxlen = rcnt; /* complete transfer */
  919. else
  920. maxlen = B_FIFO_SIZE + B_SUB_VAL - zp->z2; /* maximum */
  922. ptr1 = bdata + (zp->z2 - B_SUB_VAL); /* start of data */
  923. memcpy(ptr, ptr1, maxlen); /* copy data */
  924. rcnt -= maxlen;
  926. if (rcnt) { /* rest remaining */
  927. ptr += maxlen;
  928. ptr1 = bdata; /* start of buffer */
  929. memcpy(ptr, ptr1, rcnt); /* rest */
  930. }
  931. bz->za[new_f2].z2 = new_z2;
  932. bz->f2 = new_f2; /* next buffer */
  933. if (cs->debug & DEB_DLOG_HEX) {
  934. ptr = cs->dlog;
  935. if ((total - 3) < MAX_DLOG_SPACE / 3 - 10) {
  936. *ptr++ = 'E';
  937. *ptr++ = 'C';
  938. *ptr++ = 'H';
  939. *ptr++ = 'O';
  940. *ptr++ = ':';
  941. ptr += QuickHex(ptr, e_buffer, total - 3);
  942. ptr--;
  943. *ptr++ = 'n';
  944. *ptr = 0;
  945. HiSax_putstatus(cs, NULL, cs->dlog);
  946. } else
  947. HiSax_putstatus(cs, "LogEcho: ", "warning Frame too big (%d)", total - 3);
  948. }
  949. }
  951. rcnt = bz->f1 - bz->f2;
  952. if (rcnt < 0)
  953. rcnt += MAX_B_FRAMES + 1;
  954. if (rcnt > 1)
  955. receive = 1;
  956. else
  957. receive = 0;
  958. } else
  959. receive = 0;
  960. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  961. if (count && receive)
  962. goto Begin;
  963. restore_flags(flags);
  964. return;
  965. } /* receive_emsg */
  967. /*********************/
  968. /* Interrupt handler */
  969. /*********************/
  970. static void
  971. hfcpci_interrupt(int intno, void *dev_id, struct pt_regs *regs)
  972. {
  973. struct IsdnCardState *cs = dev_id;
  974. u_char exval;
  975. struct BCState *bcs;
  976. int count = 15;
  977. long flags;
  978. u_char val, stat;
  980. if (!cs) {
  981. printk(KERN_WARNING "HFC-PCI: Spurious interrupt!n");
  982. return;
  983. }
  984. if (!(cs->hw.hfcpci.int_m2 & 0x08))
  985. return; /* not initialised */
  987. if (HFCPCI_ANYINT & (stat = Read_hfc(cs, HFCPCI_STATUS))) {
  988. val = Read_hfc(cs, HFCPCI_INT_S1);
  989. if (cs->debug & L1_DEB_ISAC)
  990. debugl1(cs, "HFC-PCI: stat(%02x) s1(%02x)", stat, val);
  991. } else
  992. return;
  994. if (cs->debug & L1_DEB_ISAC)
  995. debugl1(cs, "HFC-PCI irq %x %s", val,
  996. test_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags) ?
  997. "locked" : "unlocked");
  998. val &= cs->hw.hfcpci.int_m1;
  999. if (val & 0x40) { /* state machine irq */
  1000. exval = Read_hfc(cs, HFCPCI_STATES) & 0xf;
  1001. if (cs->debug & L1_DEB_ISAC)
  1002. debugl1(cs, "ph_state chg %d->%d", cs->dc.hfcpci.ph_state,
  1003. exval);
  1004. cs->dc.hfcpci.ph_state = exval;
  1005. sched_event_D_pci(cs, D_L1STATECHANGE);
  1006. val &= ~0x40;
  1007. }
  1008. if (val & 0x80) { /* timer irq */
  1009. if (cs->hw.hfcpci.nt_mode) {
  1010. if ((--cs->hw.hfcpci.nt_timer) < 0)
  1011. sched_event_D_pci(cs, D_L1STATECHANGE);
  1012. }
  1013. val &= ~0x80;
  1014. Write_hfc(cs, HFCPCI_CTMT, cs->hw.hfcpci.ctmt | HFCPCI_CLTIMER);
  1015. }
  1016. while (val) {
  1017. save_flags(flags);
  1018. cli();
  1019. if (test_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  1020. cs->hw.hfcpci.int_s1 |= val;
  1021. restore_flags(flags);
  1022. return;
  1023. }
  1024. if (cs->hw.hfcpci.int_s1 & 0x18) {
  1025. exval = val;
  1026. val = cs->hw.hfcpci.int_s1;
  1027. cs->hw.hfcpci.int_s1 = exval;
  1028. }
  1029. if (val & 0x08) {
  1030. if (!(bcs = Sel_BCS(cs, cs->hw.hfcpci.bswapped ? 1 : 0))) {
  1031. if (cs->debug)
  1032. debugl1(cs, "hfcpci spurious 0x08 IRQ");
  1033. } else
  1034. main_rec_hfcpci(bcs);
  1035. }
  1036. if (val & 0x10) {
  1037. if (cs->logecho)
  1038. receive_emsg(cs);
  1039. else if (!(bcs = Sel_BCS(cs, 1))) {
  1040. if (cs->debug)
  1041. debugl1(cs, "hfcpci spurious 0x10 IRQ");
  1042. } else
  1043. main_rec_hfcpci(bcs);
  1044. }
  1045. if (val & 0x01) {
  1046. if (!(bcs = Sel_BCS(cs, cs->hw.hfcpci.bswapped ? 1 : 0))) {
  1047. if (cs->debug)
  1048. debugl1(cs, "hfcpci spurious 0x01 IRQ");
  1049. } else {
  1050. if (bcs->tx_skb) {
  1051. if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  1052. hfcpci_fill_fifo(bcs);
  1053. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  1054. } else
  1055. debugl1(cs, "fill_data %d blocked", bcs->channel);
  1056. } else {
  1057. if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
  1058. if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  1059. hfcpci_fill_fifo(bcs);
  1060. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  1061. } else
  1062. debugl1(cs, "fill_data %d blocked", bcs->channel);
  1063. } else {
  1064. hfcpci_sched_event(bcs, B_XMTBUFREADY);
  1065. }
  1066. }
  1067. }
  1068. }
  1069. if (val & 0x02) {
  1070. if (!(bcs = Sel_BCS(cs, 1))) {
  1071. if (cs->debug)
  1072. debugl1(cs, "hfcpci spurious 0x02 IRQ");
  1073. } else {
  1074. if (bcs->tx_skb) {
  1075. if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  1076. hfcpci_fill_fifo(bcs);
  1077. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  1078. } else
  1079. debugl1(cs, "fill_data %d blocked", bcs->channel);
  1080. } else {
  1081. if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
  1082. if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  1083. hfcpci_fill_fifo(bcs);
  1084. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  1085. } else
  1086. debugl1(cs, "fill_data %d blocked", bcs->channel);
  1087. } else {
  1088. hfcpci_sched_event(bcs, B_XMTBUFREADY);
  1089. }
  1090. }
  1091. }
  1092. }
  1093. if (val & 0x20) { /* receive dframe */
  1094. receive_dmsg(cs);
  1095. }
  1096. if (val & 0x04) { /* dframe transmitted */
  1097. if (test_and_clear_bit(FLG_DBUSY_TIMER, &cs->HW_Flags))
  1098. del_timer(&cs->dbusytimer);
  1099. if (test_and_clear_bit(FLG_L1_DBUSY, &cs->HW_Flags))
  1100. sched_event_D_pci(cs, D_CLEARBUSY);
  1101. if (cs->tx_skb) {
  1102. if (cs->tx_skb->len) {
  1103. if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  1104. hfcpci_fill_dfifo(cs);
  1105. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  1106. } else {
  1107. debugl1(cs, "hfcpci_fill_dfifo irq blocked");
  1108. }
  1109. goto afterXPR;
  1110. } else {
  1111. dev_kfree_skb_irq(cs->tx_skb);
  1112. cs->tx_cnt = 0;
  1113. cs->tx_skb = NULL;
  1114. }
  1115. }
  1116. if ((cs->tx_skb = skb_dequeue(&cs->sq))) {
  1117. cs->tx_cnt = 0;
  1118. if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  1119. hfcpci_fill_dfifo(cs);
  1120. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  1121. } else {
  1122. debugl1(cs, "hfcpci_fill_dfifo irq blocked");
  1123. }
  1124. } else
  1125. sched_event_D_pci(cs, D_XMTBUFREADY);
  1126. }
  1127.       afterXPR:
  1128. if (cs->hw.hfcpci.int_s1 && count--) {
  1129. val = cs->hw.hfcpci.int_s1;
  1130. cs->hw.hfcpci.int_s1 = 0;
  1131. if (cs->debug & L1_DEB_ISAC)
  1132. debugl1(cs, "HFC-PCI irq %x loop %d", val, 15 - count);
  1133. } else
  1134. val = 0;
  1135. restore_flags(flags);
  1136. }
  1137. }
  1139. /********************************************************************/
  1140. /* timer callback for D-chan busy resolution. Currently no function */
  1141. /********************************************************************/
  1142. static void
  1143. hfcpci_dbusy_timer(struct IsdnCardState *cs)
  1144. {
  1145. }
  1147. /*************************************/
  1148. /* Layer 1 D-channel hardware access */
  1149. /*************************************/
  1150. static void
  1151. HFCPCI_l1hw(struct PStack *st, int pr, void *arg)
  1152. {
  1153. struct IsdnCardState *cs = (struct IsdnCardState *) st->l1.hardware;
  1154. struct sk_buff *skb = arg;
  1155. unsigned long flags;
  1157. switch (pr) {
  1158. case (PH_DATA | REQUEST):
  1159. if (cs->debug & DEB_DLOG_HEX)
  1160. LogFrame(cs, skb->data, skb->len);
  1161. if (cs->debug & DEB_DLOG_VERBOSE)
  1162. dlogframe(cs, skb, 0);
  1163. if (cs->tx_skb) {
  1164. skb_queue_tail(&cs->sq, skb);
  1165. #ifdef L2FRAME_DEBUG /* psa */
  1166. if (cs->debug & L1_DEB_LAPD)
  1167. Logl2Frame(cs, skb, "PH_DATA Queued", 0);
  1168. #endif
  1169. } else {
  1170. cs->tx_skb = skb;
  1171. cs->tx_cnt = 0;
  1172. #ifdef L2FRAME_DEBUG /* psa */
  1173. if (cs->debug & L1_DEB_LAPD)
  1174. Logl2Frame(cs, skb, "PH_DATA", 0);
  1175. #endif
  1176. if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  1177. hfcpci_fill_dfifo(cs);
  1178. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  1179. } else
  1180. debugl1(cs, "hfcpci_fill_dfifo blocked");
  1182. }
  1183. break;
  1184. case (PH_PULL | INDICATION):
  1185. if (cs->tx_skb) {
  1186. if (cs->debug & L1_DEB_WARN)
  1187. debugl1(cs, " l2l1 tx_skb exist this shouldn't happen");
  1188. skb_queue_tail(&cs->sq, skb);
  1189. break;
  1190. }
  1191. if (cs->debug & DEB_DLOG_HEX)
  1192. LogFrame(cs, skb->data, skb->len);
  1193. if (cs->debug & DEB_DLOG_VERBOSE)
  1194. dlogframe(cs, skb, 0);
  1195. cs->tx_skb = skb;
  1196. cs->tx_cnt = 0;
  1197. #ifdef L2FRAME_DEBUG /* psa */
  1198. if (cs->debug & L1_DEB_LAPD)
  1199. Logl2Frame(cs, skb, "PH_DATA_PULLED", 0);
  1200. #endif
  1201. if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  1202. hfcpci_fill_dfifo(cs);
  1203. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  1204. } else
  1205. debugl1(cs, "hfcpci_fill_dfifo blocked");
  1206. break;
  1207. case (PH_PULL | REQUEST):
  1208. #ifdef L2FRAME_DEBUG /* psa */
  1209. if (cs->debug & L1_DEB_LAPD)
  1210. debugl1(cs, "-> PH_REQUEST_PULL");
  1211. #endif
  1212. if (!cs->tx_skb) {
  1213. test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  1214. st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
  1215. } else
  1216. test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  1217. break;
  1218. case (HW_RESET | REQUEST):
  1219. Write_hfc(cs, HFCPCI_STATES, HFCPCI_LOAD_STATE | 3); /* HFC ST 3 */
  1220. udelay(6);
  1221. Write_hfc(cs, HFCPCI_STATES, 3); /* HFC ST 2 */
  1222. cs->hw.hfcpci.mst_m |= HFCPCI_MASTER;
  1223. Write_hfc(cs, HFCPCI_MST_MODE, cs->hw.hfcpci.mst_m);
  1224. Write_hfc(cs, HFCPCI_STATES, HFCPCI_ACTIVATE | HFCPCI_DO_ACTION);
  1225. l1_msg(cs, HW_POWERUP | CONFIRM, NULL);
  1226. break;
  1227. case (HW_ENABLE | REQUEST):
  1228. Write_hfc(cs, HFCPCI_STATES, HFCPCI_DO_ACTION);
  1229. break;
  1230. case (HW_DEACTIVATE | REQUEST):
  1231. cs->hw.hfcpci.mst_m &= ~HFCPCI_MASTER;
  1232. Write_hfc(cs, HFCPCI_MST_MODE, cs->hw.hfcpci.mst_m);
  1233. break;
  1234. case (HW_INFO3 | REQUEST):
  1235. cs->hw.hfcpci.mst_m |= HFCPCI_MASTER;
  1236. Write_hfc(cs, HFCPCI_MST_MODE, cs->hw.hfcpci.mst_m);
  1237. break;
  1238. case (HW_TESTLOOP | REQUEST):
  1239. switch ((int) arg) {
  1240. case (1):
  1241. Write_hfc(cs, HFCPCI_B1_SSL, 0x80); /* tx slot */
  1242. Write_hfc(cs, HFCPCI_B1_RSL, 0x80); /* rx slot */
  1243. save_flags(flags);
  1244. cli();
  1245. cs->hw.hfcpci.conn = (cs->hw.hfcpci.conn & ~7) | 1;
  1246. Write_hfc(cs, HFCPCI_CONNECT, cs->hw.hfcpci.conn);
  1247. restore_flags(flags);
  1248. break;
  1250. case (2):
  1251. Write_hfc(cs, HFCPCI_B2_SSL, 0x81); /* tx slot */
  1252. Write_hfc(cs, HFCPCI_B2_RSL, 0x81); /* rx slot */
  1253. save_flags(flags);
  1254. cli();
  1255. cs->hw.hfcpci.conn = (cs->hw.hfcpci.conn & ~0x38) | 0x08;
  1256. Write_hfc(cs, HFCPCI_CONNECT, cs->hw.hfcpci.conn);
  1257. restore_flags(flags);
  1258. break;
  1260. default:
  1261. if (cs->debug & L1_DEB_WARN)
  1262. debugl1(cs, "hfcpci_l1hw loop invalid %4x", (int) arg);
  1263. return;
  1264. }
  1265. save_flags(flags);
  1266. cli();
  1267. cs->hw.hfcpci.trm |= 0x80; /* enable IOM-loop */
  1268. Write_hfc(cs, HFCPCI_TRM, cs->hw.hfcpci.trm);
  1269. restore_flags(flags);
  1270. break;
  1271. default:
  1272. if (cs->debug & L1_DEB_WARN)
  1273. debugl1(cs, "hfcpci_l1hw unknown pr %4x", pr);
  1274. break;
  1275. }
  1276. }
  1278. /***********************************************/
  1279. /* called during init setting l1 stack pointer */
  1280. /***********************************************/
  1281. void
  1282. setstack_hfcpci(struct PStack *st, struct IsdnCardState *cs)
  1283. {
  1284. st->l1.l1hw = HFCPCI_l1hw;
  1285. }
  1287. /**************************************/
  1288. /* send B-channel data if not blocked */
  1289. /**************************************/
  1290. static void
  1291. hfcpci_send_data(struct BCState *bcs)
  1292. {
  1293. struct IsdnCardState *cs = bcs->cs;
  1295. if (!test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
  1296. hfcpci_fill_fifo(bcs);
  1297. test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
  1298. } else
  1299. debugl1(cs, "send_data %d blocked", bcs->channel);
  1300. }
  1302. /***************************************************************/
  1303. /* activate/deactivate hardware for selected channels and mode */
  1304. /***************************************************************/
  1305. void
  1306. mode_hfcpci(struct BCState *bcs, int mode, int bc)
  1307. {
  1308. struct IsdnCardState *cs = bcs->cs;
  1309. unsigned long flags;
  1310. int fifo2;
  1312. if (cs->debug & L1_DEB_HSCX)
  1313. debugl1(cs, "HFCPCI bchannel mode %d bchan %d/%d",
  1314. mode, bc, bcs->channel);
  1315. bcs->mode = mode;
  1316. bcs->channel = bc;
  1317. fifo2 = bc;
  1318. save_flags(flags);
  1319. cli();
  1320. if (cs->chanlimit > 1) {
  1321. cs->hw.hfcpci.bswapped = 0; /* B1 and B2 normal mode */
  1322. cs->hw.hfcpci.sctrl_e &= ~0x80;
  1323. } else {
  1324. if (bc) {
  1325. if (mode != L1_MODE_NULL) {
  1326. cs->hw.hfcpci.bswapped = 1; /* B1 and B2 exchanged */
  1327. cs->hw.hfcpci.sctrl_e |= 0x80;
  1328. } else {
  1329. cs->hw.hfcpci.bswapped = 0; /* B1 and B2 normal mode */
  1330. cs->hw.hfcpci.sctrl_e &= ~0x80;
  1331. }
  1332. fifo2 = 0;
  1333. } else {
  1334. cs->hw.hfcpci.bswapped = 0; /* B1 and B2 normal mode */
  1335. cs->hw.hfcpci.sctrl_e &= ~0x80;
  1336. }
  1337. }
  1338. switch (mode) {
  1339. case (L1_MODE_NULL):
  1340. if (bc) {
  1341. cs->hw.hfcpci.sctrl &= ~SCTRL_B2_ENA;
  1342. cs->hw.hfcpci.sctrl_r &= ~SCTRL_B2_ENA;
  1343. } else {
  1344. cs->hw.hfcpci.sctrl &= ~SCTRL_B1_ENA;
  1345. cs->hw.hfcpci.sctrl_r &= ~SCTRL_B1_ENA;
  1346. }
  1347. if (fifo2) {
  1348. cs->hw.hfcpci.fifo_en &= ~HFCPCI_FIFOEN_B2;
  1349. cs->hw.hfcpci.int_m1 &= ~(HFCPCI_INTS_B2TRANS + HFCPCI_INTS_B2REC);
  1350. } else {
  1351. cs->hw.hfcpci.fifo_en &= ~HFCPCI_FIFOEN_B1;
  1352. cs->hw.hfcpci.int_m1 &= ~(HFCPCI_INTS_B1TRANS + HFCPCI_INTS_B1REC);
  1353. }
  1354. break;
  1355. case (L1_MODE_TRANS):
  1356.         hfcpci_clear_fifo_rx(cs, fifo2);
  1357.         hfcpci_clear_fifo_tx(cs, fifo2);
  1358. if (bc) {
  1359. cs->hw.hfcpci.sctrl |= SCTRL_B2_ENA;
  1360. cs->hw.hfcpci.sctrl_r |= SCTRL_B2_ENA;
  1361. } else {
  1362. cs->hw.hfcpci.sctrl |= SCTRL_B1_ENA;
  1363. cs->hw.hfcpci.sctrl_r |= SCTRL_B1_ENA;
  1364. }
  1365. if (fifo2) {
  1366. cs->hw.hfcpci.fifo_en |= HFCPCI_FIFOEN_B2;
  1367. cs->hw.hfcpci.int_m1 |= (HFCPCI_INTS_B2TRANS + HFCPCI_INTS_B2REC);
  1368. cs->hw.hfcpci.ctmt |= 2;
  1369. cs->hw.hfcpci.conn &= ~0x18;
  1370. } else {
  1371. cs->hw.hfcpci.fifo_en |= HFCPCI_FIFOEN_B1;
  1372. cs->hw.hfcpci.int_m1 |= (HFCPCI_INTS_B1TRANS + HFCPCI_INTS_B1REC);
  1373. cs->hw.hfcpci.ctmt |= 1;
  1374. cs->hw.hfcpci.conn &= ~0x03;
  1375. }
  1376. break;
  1377. case (L1_MODE_HDLC):
  1378.         hfcpci_clear_fifo_rx(cs, fifo2);
  1379.         hfcpci_clear_fifo_tx(cs, fifo2);
  1380. if (bc) {
  1381. cs->hw.hfcpci.sctrl |= SCTRL_B2_ENA;
  1382. cs->hw.hfcpci.sctrl_r |= SCTRL_B2_ENA;
  1383. } else {
  1384. cs->hw.hfcpci.sctrl |= SCTRL_B1_ENA;
  1385. cs->hw.hfcpci.sctrl_r |= SCTRL_B1_ENA;
  1386. }
  1387. if (fifo2) {
  1388.         cs->hw.hfcpci.last_bfifo_cnt[1] = 0;  
  1389. cs->hw.hfcpci.fifo_en |= HFCPCI_FIFOEN_B2;
  1390. cs->hw.hfcpci.int_m1 |= (HFCPCI_INTS_B2TRANS + HFCPCI_INTS_B2REC);
  1391. cs->hw.hfcpci.ctmt &= ~2;
  1392. cs->hw.hfcpci.conn &= ~0x18;
  1393. } else {
  1394.         cs->hw.hfcpci.last_bfifo_cnt[0] = 0;  
  1395. cs->hw.hfcpci.fifo_en |= HFCPCI_FIFOEN_B1;
  1396. cs->hw.hfcpci.int_m1 |= (HFCPCI_INTS_B1TRANS + HFCPCI_INTS_B1REC);
  1397. cs->hw.hfcpci.ctmt &= ~1;
  1398. cs->hw.hfcpci.conn &= ~0x03;
  1399. }
  1400. break;
  1401. case (L1_MODE_EXTRN):
  1402. if (bc) {
  1403. cs->hw.hfcpci.conn |= 0x10;
  1404. cs->hw.hfcpci.sctrl |= SCTRL_B2_ENA;
  1405. cs->hw.hfcpci.sctrl_r |= SCTRL_B2_ENA;
  1406. cs->hw.hfcpci.fifo_en &= ~HFCPCI_FIFOEN_B2;
  1407. cs->hw.hfcpci.int_m1 &= ~(HFCPCI_INTS_B2TRANS + HFCPCI_INTS_B2REC);
  1408. } else {
  1409. cs->hw.hfcpci.conn |= 0x02;
  1410. cs->hw.hfcpci.sctrl |= SCTRL_B1_ENA;
  1411. cs->hw.hfcpci.sctrl_r |= SCTRL_B1_ENA;
  1412. cs->hw.hfcpci.fifo_en &= ~HFCPCI_FIFOEN_B1;
  1413. cs->hw.hfcpci.int_m1 &= ~(HFCPCI_INTS_B1TRANS + HFCPCI_INTS_B1REC);
  1414. }
  1415. break;
  1416. }
  1417. Write_hfc(cs, HFCPCI_SCTRL_E, cs->hw.hfcpci.sctrl_e);
  1418. Write_hfc(cs, HFCPCI_INT_M1, cs->hw.hfcpci.int_m1);
  1419. Write_hfc(cs, HFCPCI_FIFO_EN, cs->hw.hfcpci.fifo_en);
  1420. Write_hfc(cs, HFCPCI_SCTRL, cs->hw.hfcpci.sctrl);
  1421. Write_hfc(cs, HFCPCI_SCTRL_R, cs->hw.hfcpci.sctrl_r);
  1422. Write_hfc(cs, HFCPCI_CTMT, cs->hw.hfcpci.ctmt);
  1423. Write_hfc(cs, HFCPCI_CONNECT, cs->hw.hfcpci.conn);
  1424. restore_flags(flags);
  1425. }
  1427. /******************************/
  1428. /* Layer2 -> Layer 1 Transfer */
  1429. /******************************/
  1430. static void
  1431. hfcpci_l2l1(struct PStack *st, int pr, void *arg)
  1432. {
  1433. struct sk_buff *skb = arg;
  1434. long flags;
  1436. switch (pr) {
  1437. case (PH_DATA | REQUEST):
  1438. save_flags(flags);
  1439. cli();
  1440. if (st->l1.bcs->tx_skb) {
  1441. skb_queue_tail(&st->l1.bcs->squeue, skb);
  1442. restore_flags(flags);
  1443. } else {
  1444. st->l1.bcs->tx_skb = skb;
  1445. /*                              test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  1446.  */ st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
  1447. restore_flags(flags);
  1448. }
  1449. break;
  1450. case (PH_PULL | INDICATION):
  1451. if (st->l1.bcs->tx_skb) {
  1452. printk(KERN_WARNING "hfc_l2l1: this shouldn't happenn");
  1453. break;
  1454. }
  1455. save_flags(flags);
  1456. cli();
  1457. /*                      test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  1458.  */ st->l1.bcs->tx_skb = skb;
  1459. st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
  1460. restore_flags(flags);
  1461. break;
  1462. case (PH_PULL | REQUEST):
  1463. if (!st->l1.bcs->tx_skb) {
  1464. test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  1465. st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
  1466. } else
  1467. test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  1468. break;
  1469. case (PH_ACTIVATE | REQUEST):
  1470. test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
  1471. mode_hfcpci(st->l1.bcs, st->l1.mode, st->l1.bc);
  1472. l1_msg_b(st, pr, arg);
  1473. break;
  1474. case (PH_DEACTIVATE | REQUEST):
  1475. l1_msg_b(st, pr, arg);
  1476. break;
  1477. case (PH_DEACTIVATE | CONFIRM):
  1478. test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
  1479. test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  1480. mode_hfcpci(st->l1.bcs, 0, st->l1.bc);
  1481. st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
  1482. break;
  1483. }
  1484. }
  1486. /******************************************/
  1487. /* deactivate B-channel access and queues */
  1488. /******************************************/
  1489. static void
  1490. close_hfcpci(struct BCState *bcs)
  1491. {
  1492. mode_hfcpci(bcs, 0, bcs->channel);
  1493. if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
  1494. skb_queue_purge(&bcs->rqueue);
  1495. skb_queue_purge(&bcs->squeue);
  1496. if (bcs->tx_skb) {
  1497. dev_kfree_skb_any(bcs->tx_skb);
  1498. bcs->tx_skb = NULL;
  1499. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  1500. }
  1501. }
  1502. }
  1504. /*************************************/
  1505. /* init B-channel queues and control */
  1506. /*************************************/
  1507. static int
  1508. open_hfcpcistate(struct IsdnCardState *cs, struct BCState *bcs)
  1509. {
  1510. if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
  1511. skb_queue_head_init(&bcs->rqueue);
  1512. skb_queue_head_init(&bcs->squeue);
  1513. }
  1514. bcs->tx_skb = NULL;
  1515. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  1516. bcs->event = 0;
  1517. bcs->tx_cnt = 0;
  1518. return (0);
  1519. }
  1521. /*********************************/
  1522. /* inits the stack for B-channel */
  1523. /*********************************/
  1524. static int
  1525. setstack_2b(struct PStack *st, struct BCState *bcs)
  1526. {
  1527. bcs->channel = st->l1.bc;
  1528. if (open_hfcpcistate(st->l1.hardware, bcs))
  1529. return (-1);
  1530. st->l1.bcs = bcs;
  1531. st->l2.l2l1 = hfcpci_l2l1;
  1532. setstack_manager(st);
  1533. bcs->st = st;
  1534. setstack_l1_B(st);
  1535. return (0);
  1536. }
  1538. /***************************/
  1539. /* handle L1 state changes */
  1540. /***************************/
  1541. static void
  1542. hfcpci_bh(struct IsdnCardState *cs)
  1543. {
  1544. unsigned long flags;
  1545. /*      struct PStack *stptr;
  1546.  */
  1547. if (!cs)
  1548. return;
  1549. if (test_and_clear_bit(D_L1STATECHANGE, &cs->event)) {
  1550. if (!cs->hw.hfcpci.nt_mode)
  1551. switch (cs->dc.hfcpci.ph_state) {
  1552. case (0):
  1553. l1_msg(cs, HW_RESET | INDICATION, NULL);
  1554. break;
  1555. case (3):
  1556. l1_msg(cs, HW_DEACTIVATE | INDICATION, NULL);
  1557. break;
  1558. case (8):
  1559. l1_msg(cs, HW_RSYNC | INDICATION, NULL);
  1560. break;
  1561. case (6):
  1562. l1_msg(cs, HW_INFO2 | INDICATION, NULL);
  1563. break;
  1564. case (7):
  1565. l1_msg(cs, HW_INFO4_P8 | INDICATION, NULL);
  1566. break;
  1567. default:
  1568. break;
  1569. } else {
  1570. switch (cs->dc.hfcpci.ph_state) {
  1571. case (2):
  1572. save_flags(flags);
  1573. cli();
  1574. if (cs->hw.hfcpci.nt_timer < 0) {
  1575. cs->hw.hfcpci.nt_timer = 0;
  1576. cs->hw.hfcpci.int_m1 &= ~HFCPCI_INTS_TIMER;
  1577. Write_hfc(cs, HFCPCI_INT_M1, cs->hw.hfcpci.int_m1);
  1578. /* Clear already pending ints */
  1579. if (Read_hfc(cs, HFCPCI_INT_S1));
  1581. Write_hfc(cs, HFCPCI_STATES, 4 | HFCPCI_LOAD_STATE);
  1582. udelay(10);
  1583. Write_hfc(cs, HFCPCI_STATES, 4);
  1584. cs->dc.hfcpci.ph_state = 4;
  1585. } else {
  1586. cs->hw.hfcpci.int_m1 |= HFCPCI_INTS_TIMER;
  1587. Write_hfc(cs, HFCPCI_INT_M1, cs->hw.hfcpci.int_m1);
  1588. cs->hw.hfcpci.ctmt &= ~HFCPCI_AUTO_TIMER;
  1589. cs->hw.hfcpci.ctmt |= HFCPCI_TIM3_125;
  1590. Write_hfc(cs, HFCPCI_CTMT, cs->hw.hfcpci.ctmt | HFCPCI_CLTIMER);
  1591. Write_hfc(cs, HFCPCI_CTMT, cs->hw.hfcpci.ctmt | HFCPCI_CLTIMER);
  1592. cs->hw.hfcpci.nt_timer = NT_T1_COUNT;
  1593. Write_hfc(cs, HFCPCI_STATES, 2 | HFCPCI_NT_G2_G3); /* allow G2 -> G3 transition */
  1594. }
  1595. restore_flags(flags);
  1596. break;
  1597. case (1):
  1598. case (3):
  1599. case (4):
  1600. save_flags(flags);
  1601. cli();
  1602. cs->hw.hfcpci.nt_timer = 0;
  1603. cs->hw.hfcpci.int_m1 &= ~HFCPCI_INTS_TIMER;
  1604. Write_hfc(cs, HFCPCI_INT_M1, cs->hw.hfcpci.int_m1);
  1605. restore_flags(flags);
  1606. break;
  1607. default:
  1608. break;
  1609. }
  1610. }
  1611. }
  1612. if (test_and_clear_bit(D_RCVBUFREADY, &cs->event))
  1613. DChannel_proc_rcv(cs);
  1614. if (test_and_clear_bit(D_XMTBUFREADY, &cs->event))
  1615. DChannel_proc_xmt(cs);
  1616. }
  1619. /********************************/
  1620. /* called for card init message */
  1621. /********************************/
  1622. void __init
  1623. inithfcpci(struct IsdnCardState *cs)
  1624. {
  1625. cs->setstack_d = setstack_hfcpci;
  1626. cs->dbusytimer.function = (void *) hfcpci_dbusy_timer;
  1627. cs->dbusytimer.data = (long) cs;
  1628. init_timer(&cs->dbusytimer);
  1629. cs->tqueue.routine = (void *) (void *) hfcpci_bh;
  1630. cs->BC_Send_Data = &hfcpci_send_data;
  1631. cs->bcs[0].BC_SetStack = setstack_2b;
  1632. cs->bcs[1].BC_SetStack = setstack_2b;
  1633. cs->bcs[0].BC_Close = close_hfcpci;
  1634. cs->bcs[1].BC_Close = close_hfcpci;
  1635. mode_hfcpci(cs->bcs, 0, 0);
  1636. mode_hfcpci(cs->bcs + 1, 0, 1);
  1637. }
  1641. /*******************************************/
  1642. /* handle card messages from control layer */
  1643. /*******************************************/
  1644. static int
  1645. hfcpci_card_msg(struct IsdnCardState *cs, int mt, void *arg)
  1646. {
  1647. long flags;
  1649. if (cs->debug & L1_DEB_ISAC)
  1650. debugl1(cs, "HFCPCI: card_msg %x", mt);
  1651. switch (mt) {
  1652. case CARD_RESET:
  1653. reset_hfcpci(cs);
  1654. return (0);
  1655. case CARD_RELEASE:
  1656. release_io_hfcpci(cs);
  1657. return (0);
  1658. case CARD_INIT:
  1659. inithfcpci(cs);
  1660. save_flags(flags);
  1661. sti();
  1662. set_current_state(TASK_UNINTERRUPTIBLE);
  1663. schedule_timeout((80 * HZ) / 1000); /* Timeout 80ms */
  1664. /* now switch timer interrupt off */
  1665. cs->hw.hfcpci.int_m1 &= ~HFCPCI_INTS_TIMER;
  1666. Write_hfc(cs, HFCPCI_INT_M1, cs->hw.hfcpci.int_m1);
  1667. /* reinit mode reg */
  1668. Write_hfc(cs, HFCPCI_MST_MODE, cs->hw.hfcpci.mst_m);
  1669. restore_flags(flags);
  1670. return (0);
  1671. case CARD_TEST:
  1672. return (0);
  1673. }
  1674. return (0);
  1675. }
  1678. /* this variable is used as card index when more than one cards are present */
  1679. static struct pci_dev *dev_hfcpci __initdata = NULL;
  1681. #endif /* CONFIG_PCI */
  1683. int __init
  1684. setup_hfcpci(struct IsdnCard *card)
  1685. {
  1686. struct IsdnCardState *cs = card->cs;
  1687. char tmp[64];
  1688. int i;
  1689. struct pci_dev *tmp_hfcpci = NULL;
  1691. #ifdef __BIG_ENDIAN
  1692. #error "not running on big endian machines now"
  1693. #endif
  1694. strcpy(tmp, hfcpci_revision);
  1695. printk(KERN_INFO "HiSax: HFC-PCI driver Rev. %sn", HiSax_getrev(tmp));
  1696. #if CONFIG_PCI
  1697. cs->hw.hfcpci.int_s1 = 0;
  1698. cs->dc.hfcpci.ph_state = 0;
  1699. cs->hw.hfcpci.fifo = 255;
  1700. if (cs->typ == ISDN_CTYPE_HFC_PCI) {
  1701. i = 0;
  1702. while (id_list[i].vendor_id) {
  1703. tmp_hfcpci = pci_find_device(id_list[i].vendor_id,
  1704.      id_list[i].device_id,
  1705.      dev_hfcpci);
  1706. i++;
  1707. if (tmp_hfcpci) {
  1708. if (pci_enable_device(tmp_hfcpci))
  1709. continue;
  1710. pci_set_master(tmp_hfcpci);
  1711. if ((card->para[0]) && (card->para[0] != (tmp_hfcpci->resource[ 0].start & PCI_BASE_ADDRESS_IO_MASK)))
  1712. continue;
  1713. else
  1714. break;
  1715. }
  1716. }
  1718. if (tmp_hfcpci) {
  1719. i--;
  1720. dev_hfcpci = tmp_hfcpci; /* old device */
  1721. cs->hw.hfcpci.pci_bus = dev_hfcpci->bus->number;
  1722. cs->hw.hfcpci.pci_device_fn = dev_hfcpci->devfn;
  1723. cs->irq = dev_hfcpci->irq;
  1724. if (!cs->irq) {
  1725. printk(KERN_WARNING "HFC-PCI: No IRQ for PCI card foundn");
  1726. return (0);
  1727. }
  1728. cs->hw.hfcpci.pci_io = (char *) dev_hfcpci->resource[ 1].start;
  1729. printk(KERN_INFO "HiSax: HFC-PCI card manufacturer: %s card name: %sn", id_list[i].vendor_name, id_list[i].card_name);
  1730. } else {
  1731. printk(KERN_WARNING "HFC-PCI: No PCI card foundn");
  1732. return (0);
  1733. }
  1734. if (!cs->hw.hfcpci.pci_io) {
  1735. printk(KERN_WARNING "HFC-PCI: No IO-Mem for PCI card foundn");
  1736. return (0);
  1737. }
  1738. /* Allocate memory for FIFOS */
  1739. /* Because the HFC-PCI needs a 32K physical alignment, we */
  1740. /* need to allocate the double mem and align the address */
  1741. if (!((void *) cs->hw.hfcpci.share_start = kmalloc(65536, GFP_KERNEL))) {
  1742. printk(KERN_WARNING "HFC-PCI: Error allocating memory for FIFO!n");
  1743. return 0;
  1744. }
  1745. (ulong) cs->hw.hfcpci.fifos =
  1746.     (((ulong) cs->hw.hfcpci.share_start) & ~0x7FFF) + 0x8000;
  1747. pcibios_write_config_dword(cs->hw.hfcpci.pci_bus,
  1748.        cs->hw.hfcpci.pci_device_fn, 0x80,
  1749.        (u_int) virt_to_bus(cs->hw.hfcpci.fifos));
  1750. cs->hw.hfcpci.pci_io = ioremap((ulong) cs->hw.hfcpci.pci_io, 256);
  1751. printk(KERN_INFO
  1752.        "HFC-PCI: defined at mem %#x fifo %#x(%#x) IRQ %d HZ %dn",
  1753.        (u_int) cs->hw.hfcpci.pci_io,
  1754.        (u_int) cs->hw.hfcpci.fifos,
  1755.        (u_int) virt_to_bus(cs->hw.hfcpci.fifos),
  1756.        cs->irq, HZ);
  1757. pcibios_write_config_word(cs->hw.hfcpci.pci_bus, cs->hw.hfcpci.pci_device_fn, PCI_COMMAND, PCI_ENA_MEMIO); /* enable memory mapped ports, disable busmaster */
  1758. cs->hw.hfcpci.int_m2 = 0; /* disable alle interrupts */
  1759. cs->hw.hfcpci.int_m1 = 0;
  1760. Write_hfc(cs, HFCPCI_INT_M1, cs->hw.hfcpci.int_m1);
  1761. Write_hfc(cs, HFCPCI_INT_M2, cs->hw.hfcpci.int_m2);
  1762. /* At this point the needed PCI config is done */
  1763. /* fifos are still not enabled */
  1764. } else
  1765. return (0); /* no valid card type */
  1768. cs->readisac = NULL;
  1769. cs->writeisac = NULL;
  1770. cs->readisacfifo = NULL;
  1771. cs->writeisacfifo = NULL;
  1772. cs->BC_Read_Reg = NULL;
  1773. cs->BC_Write_Reg = NULL;
  1774. cs->irq_func = &hfcpci_interrupt;
  1775. cs->irq_flags |= SA_SHIRQ;
  1777. cs->hw.hfcpci.timer.function = (void *) hfcpci_Timer;
  1778. cs->hw.hfcpci.timer.data = (long) cs;
  1779. init_timer(&cs->hw.hfcpci.timer);
  1781. reset_hfcpci(cs);
  1782. cs->cardmsg = &hfcpci_card_msg;
  1783. cs->auxcmd = &hfcpci_auxcmd;
  1784. return (1);
  1785. #else
  1786. printk(KERN_WARNING "HFC-PCI: NO_PCI_BIOSn");
  1787. return (0);
  1788. #endif /* CONFIG_PCI */
  1789. }