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

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

嵌入式Linux

开发平台：

Unix_Linux

avm_pci.c：源码内容
  1. /* $Id: avm_pci.c,v 1.1.4.1 2001/11/20 14:19:35 kai Exp $
  2.  *
  3.  * low level stuff for AVM Fritz!PCI and ISA PnP isdn cards
  4.  *
  5.  * Author       Karsten Keil
  6.  * Copyright    by Karsten Keil      <keil@isdn4linux.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.  * Thanks to AVM, Berlin for information
  12.  *
  13.  */
  15. #define __NO_VERSION__
  16. #include <linux/config.h>
  17. #include <linux/init.h>
  18. #include "hisax.h"
  19. #include "isac.h"
  20. #include "isdnl1.h"
  21. #include <linux/pci.h>
  22. #include <linux/interrupt.h>
  24. extern const char *CardType[];
  25. static const char *avm_pci_rev = "$Revision: 1.1.4.1 $";
  27. #define  AVM_FRITZ_PCI 1
  28. #define  AVM_FRITZ_PNP 2
  30. #define  HDLC_FIFO 0x0
  31. #define  HDLC_STATUS 0x4
  33. #define  AVM_HDLC_1 0x00
  34. #define  AVM_HDLC_2 0x01
  35. #define  AVM_ISAC_FIFO 0x02
  36. #define  AVM_ISAC_REG_LOW 0x04
  37. #define  AVM_ISAC_REG_HIGH 0x06
  39. #define  AVM_STATUS0_IRQ_ISAC 0x01
  40. #define  AVM_STATUS0_IRQ_HDLC 0x02
  41. #define  AVM_STATUS0_IRQ_TIMER 0x04
  42. #define  AVM_STATUS0_IRQ_MASK 0x07
  44. #define  AVM_STATUS0_RESET 0x01
  45. #define  AVM_STATUS0_DIS_TIMER 0x02
  46. #define  AVM_STATUS0_RES_TIMER 0x04
  47. #define  AVM_STATUS0_ENA_IRQ 0x08
  48. #define  AVM_STATUS0_TESTBIT 0x10
  50. #define  AVM_STATUS1_INT_SEL 0x0f
  51. #define  AVM_STATUS1_ENA_IOM 0x80
  53. #define  HDLC_MODE_ITF_FLG 0x01
  54. #define  HDLC_MODE_TRANS 0x02
  55. #define  HDLC_MODE_CCR_7 0x04
  56. #define  HDLC_MODE_CCR_16 0x08
  57. #define  HDLC_MODE_TESTLOOP 0x80
  59. #define  HDLC_INT_XPR 0x80
  60. #define  HDLC_INT_XDU 0x40
  61. #define  HDLC_INT_RPR 0x20
  62. #define  HDLC_INT_MASK 0xE0
  64. #define  HDLC_STAT_RME 0x01
  65. #define  HDLC_STAT_RDO 0x10
  66. #define  HDLC_STAT_CRCVFRRAB 0x0E
  67. #define  HDLC_STAT_CRCVFR 0x06
  68. #define  HDLC_STAT_RML_MASK 0x3f00
  70. #define  HDLC_CMD_XRS 0x80
  71. #define  HDLC_CMD_XME 0x01
  72. #define  HDLC_CMD_RRS 0x20
  73. #define  HDLC_CMD_XML_MASK 0x3f00
  76. /* Interface functions */
  78. static u_char
  79. ReadISAC(struct IsdnCardState *cs, u_char offset)
  80. {
  81. register u_char idx = (offset > 0x2f) ? AVM_ISAC_REG_HIGH : AVM_ISAC_REG_LOW;
  82. register u_char val;
  83. register long flags;
  85. save_flags(flags);
  86. cli();
  87. outb(idx, cs->hw.avm.cfg_reg + 4);
  88. val = inb(cs->hw.avm.isac + (offset & 0xf));
  89. restore_flags(flags);
  90. return (val);
  91. }
  93. static void
  94. WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
  95. {
  96. register u_char idx = (offset > 0x2f) ? AVM_ISAC_REG_HIGH : AVM_ISAC_REG_LOW;
  97. register long flags;
  99. save_flags(flags);
  100. cli();
  101. outb(idx, cs->hw.avm.cfg_reg + 4);
  102. outb(value, cs->hw.avm.isac + (offset & 0xf));
  103. restore_flags(flags);
  104. }
  106. static void
  107. ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  108. {
  109. outb(AVM_ISAC_FIFO, cs->hw.avm.cfg_reg + 4);
  110. insb(cs->hw.avm.isac, data, size);
  111. }
  113. static void
  114. WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  115. {
  116. outb(AVM_ISAC_FIFO, cs->hw.avm.cfg_reg + 4);
  117. outsb(cs->hw.avm.isac, data, size);
  118. }
  120. static inline u_int
  121. ReadHDLCPCI(struct IsdnCardState *cs, int chan, u_char offset)
  122. {
  123. register u_int idx = chan ? AVM_HDLC_2 : AVM_HDLC_1;
  124. register u_int val;
  125. register long flags;
  127. save_flags(flags);
  128. cli();
  129. outl(idx, cs->hw.avm.cfg_reg + 4);
  130. val = inl(cs->hw.avm.isac + offset);
  131. restore_flags(flags);
  132. return (val);
  133. }
  135. static inline void
  136. WriteHDLCPCI(struct IsdnCardState *cs, int chan, u_char offset, u_int value)
  137. {
  138. register u_int idx = chan ? AVM_HDLC_2 : AVM_HDLC_1;
  139. register long flags;
  141. save_flags(flags);
  142. cli();
  143. outl(idx, cs->hw.avm.cfg_reg + 4);
  144. outl(value, cs->hw.avm.isac + offset);
  145. restore_flags(flags);
  146. }
  148. static inline u_char
  149. ReadHDLCPnP(struct IsdnCardState *cs, int chan, u_char offset)
  150. {
  151. register u_char idx = chan ? AVM_HDLC_2 : AVM_HDLC_1;
  152. register u_char val;
  153. register long flags;
  155. save_flags(flags);
  156. cli();
  157. outb(idx, cs->hw.avm.cfg_reg + 4);
  158. val = inb(cs->hw.avm.isac + offset);
  159. restore_flags(flags);
  160. return (val);
  161. }
  163. static inline void
  164. WriteHDLCPnP(struct IsdnCardState *cs, int chan, u_char offset, u_char value)
  165. {
  166. register u_char idx = chan ? AVM_HDLC_2 : AVM_HDLC_1;
  167. register long flags;
  169. save_flags(flags);
  170. cli();
  171. outb(idx, cs->hw.avm.cfg_reg + 4);
  172. outb(value, cs->hw.avm.isac + offset);
  173. restore_flags(flags);
  174. }
  176. static u_char
  177. ReadHDLC_s(struct IsdnCardState *cs, int chan, u_char offset)
  178. {
  179. return(0xff & ReadHDLCPCI(cs, chan, offset));
  180. }
  182. static void
  183. WriteHDLC_s(struct IsdnCardState *cs, int chan, u_char offset, u_char value)
  184. {
  185. WriteHDLCPCI(cs, chan, offset, value);
  186. }
  188. static inline
  189. struct BCState *Sel_BCS(struct IsdnCardState *cs, int channel)
  190. {
  191. if (cs->bcs[0].mode && (cs->bcs[0].channel == channel))
  192. return(&cs->bcs[0]);
  193. else if (cs->bcs[1].mode && (cs->bcs[1].channel == channel))
  194. return(&cs->bcs[1]);
  195. else
  196. return(NULL);
  197. }
  199. void inline
  200. hdlc_sched_event(struct BCState *bcs, int event)
  201. {
  202. bcs->event |= 1 << event;
  203. queue_task(&bcs->tqueue, &tq_immediate);
  204. mark_bh(IMMEDIATE_BH);
  205. }
  207. void
  208. write_ctrl(struct BCState *bcs, int which) {
  210. if (bcs->cs->debug & L1_DEB_HSCX)
  211. debugl1(bcs->cs, "hdlc %c wr%x ctrl %x",
  212. 'A' + bcs->channel, which, bcs->hw.hdlc.ctrl.ctrl);
  213. if (bcs->cs->subtyp == AVM_FRITZ_PCI) {
  214. WriteHDLCPCI(bcs->cs, bcs->channel, HDLC_STATUS, bcs->hw.hdlc.ctrl.ctrl);
  215. } else {
  216. if (which & 4)
  217. WriteHDLCPnP(bcs->cs, bcs->channel, HDLC_STATUS + 2,
  218. bcs->hw.hdlc.ctrl.sr.mode);
  219. if (which & 2)
  220. WriteHDLCPnP(bcs->cs, bcs->channel, HDLC_STATUS + 1,
  221. bcs->hw.hdlc.ctrl.sr.xml);
  222. if (which & 1)
  223. WriteHDLCPnP(bcs->cs, bcs->channel, HDLC_STATUS,
  224. bcs->hw.hdlc.ctrl.sr.cmd);
  225. }
  226. }
  228. void
  229. modehdlc(struct BCState *bcs, int mode, int bc)
  230. {
  231. struct IsdnCardState *cs = bcs->cs;
  232. int hdlc = bcs->channel;
  234. if (cs->debug & L1_DEB_HSCX)
  235. debugl1(cs, "hdlc %c mode %d --> %d ichan %d --> %d",
  236. 'A' + hdlc, bcs->mode, mode, hdlc, bc);
  237. bcs->hw.hdlc.ctrl.ctrl = 0;
  238. switch (mode) {
  239. case (-1): /* used for init */
  240. bcs->mode = 1;
  241. bcs->channel = bc;
  242. bc = 0;
  243. case (L1_MODE_NULL):
  244. if (bcs->mode == L1_MODE_NULL)
  245. return;
  246. bcs->hw.hdlc.ctrl.sr.cmd  = HDLC_CMD_XRS | HDLC_CMD_RRS;
  247. bcs->hw.hdlc.ctrl.sr.mode = HDLC_MODE_TRANS;
  248. write_ctrl(bcs, 5);
  249. bcs->mode = L1_MODE_NULL;
  250. bcs->channel = bc;
  251. break;
  252. case (L1_MODE_TRANS):
  253. bcs->mode = mode;
  254. bcs->channel = bc;
  255. bcs->hw.hdlc.ctrl.sr.cmd  = HDLC_CMD_XRS | HDLC_CMD_RRS;
  256. bcs->hw.hdlc.ctrl.sr.mode = HDLC_MODE_TRANS;
  257. write_ctrl(bcs, 5);
  258. bcs->hw.hdlc.ctrl.sr.cmd = HDLC_CMD_XRS;
  259. write_ctrl(bcs, 1);
  260. bcs->hw.hdlc.ctrl.sr.cmd = 0;
  261. hdlc_sched_event(bcs, B_XMTBUFREADY);
  262. break;
  263. case (L1_MODE_HDLC):
  264. bcs->mode = mode;
  265. bcs->channel = bc;
  266. bcs->hw.hdlc.ctrl.sr.cmd  = HDLC_CMD_XRS | HDLC_CMD_RRS;
  267. bcs->hw.hdlc.ctrl.sr.mode = HDLC_MODE_ITF_FLG;
  268. write_ctrl(bcs, 5);
  269. bcs->hw.hdlc.ctrl.sr.cmd = HDLC_CMD_XRS;
  270. write_ctrl(bcs, 1);
  271. bcs->hw.hdlc.ctrl.sr.cmd = 0;
  272. hdlc_sched_event(bcs, B_XMTBUFREADY);
  273. break;
  274. }
  275. }
  277. static inline void
  278. hdlc_empty_fifo(struct BCState *bcs, int count)
  279. {
  280. register u_int *ptr;
  281. u_char *p;
  282. u_char idx = bcs->channel ? AVM_HDLC_2 : AVM_HDLC_1;
  283. int cnt=0;
  284. struct IsdnCardState *cs = bcs->cs;
  286. if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
  287. debugl1(cs, "hdlc_empty_fifo %d", count);
  288. if (bcs->hw.hdlc.rcvidx + count > HSCX_BUFMAX) {
  289. if (cs->debug & L1_DEB_WARN)
  290. debugl1(cs, "hdlc_empty_fifo: incoming packet too large");
  291. return;
  292. }
  293. ptr = (u_int *) p = bcs->hw.hdlc.rcvbuf + bcs->hw.hdlc.rcvidx;
  294. bcs->hw.hdlc.rcvidx += count;
  295. if (cs->subtyp == AVM_FRITZ_PCI) {
  296. outl(idx, cs->hw.avm.cfg_reg + 4);
  297. while (cnt < count) {
  298. #ifdef __powerpc__
  299. #ifdef CONFIG_APUS
  300. *ptr++ = in_le32((unsigned *)(cs->hw.avm.isac +_IO_BASE));
  301. #else
  302. *ptr++ = in_be32((unsigned *)(cs->hw.avm.isac +_IO_BASE));
  303. #endif /* CONFIG_APUS */
  304. #else
  305. *ptr++ = inl(cs->hw.avm.isac);
  306. #endif /* __powerpc__ */
  307. cnt += 4;
  308. }
  309. } else {
  310. outb(idx, cs->hw.avm.cfg_reg + 4);
  311. while (cnt < count) {
  312. *p++ = inb(cs->hw.avm.isac);
  313. cnt++;
  314. }
  315. }
  316. if (cs->debug & L1_DEB_HSCX_FIFO) {
  317. char *t = bcs->blog;
  319. if (cs->subtyp == AVM_FRITZ_PNP)
  320. p = (u_char *) ptr;
  321. t += sprintf(t, "hdlc_empty_fifo %c cnt %d",
  322.      bcs->channel ? 'B' : 'A', count);
  323. QuickHex(t, p, count);
  324. debugl1(cs, bcs->blog);
  325. }
  326. }
  328. static inline void
  329. hdlc_fill_fifo(struct BCState *bcs)
  330. {
  331. struct IsdnCardState *cs = bcs->cs;
  332. int count, cnt =0;
  333. int fifo_size = 32;
  334. u_char *p;
  335. u_int *ptr;
  337. if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
  338. debugl1(cs, "hdlc_fill_fifo");
  339. if (!bcs->tx_skb)
  340. return;
  341. if (bcs->tx_skb->len <= 0)
  342. return;
  344. bcs->hw.hdlc.ctrl.sr.cmd &= ~HDLC_CMD_XME;
  345. if (bcs->tx_skb->len > fifo_size) {
  346. count = fifo_size;
  347. } else {
  348. count = bcs->tx_skb->len;
  349. if (bcs->mode != L1_MODE_TRANS)
  350. bcs->hw.hdlc.ctrl.sr.cmd |= HDLC_CMD_XME;
  351. }
  352. if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
  353. debugl1(cs, "hdlc_fill_fifo %d/%ld", count, bcs->tx_skb->len);
  354. ptr = (u_int *) p = bcs->tx_skb->data;
  355. skb_pull(bcs->tx_skb, count);
  356. bcs->tx_cnt -= count;
  357. bcs->hw.hdlc.count += count;
  358. bcs->hw.hdlc.ctrl.sr.xml = ((count == fifo_size) ? 0 : count);
  359. write_ctrl(bcs, 3);  /* sets the correct index too */
  360. if (cs->subtyp == AVM_FRITZ_PCI) {
  361. while (cnt<count) {
  362. #ifdef __powerpc__
  363. #ifdef CONFIG_APUS
  364. out_le32((unsigned *)(cs->hw.avm.isac +_IO_BASE), *ptr++);
  365. #else
  366. out_be32((unsigned *)(cs->hw.avm.isac +_IO_BASE), *ptr++);
  367. #endif /* CONFIG_APUS */
  368. #else
  369. outl(*ptr++, cs->hw.avm.isac);
  370. #endif /* __powerpc__ */
  371. cnt += 4;
  372. }
  373. } else {
  374. while (cnt<count) {
  375. outb(*p++, cs->hw.avm.isac);
  376. cnt++;
  377. }
  378. }
  379. if (cs->debug & L1_DEB_HSCX_FIFO) {
  380. char *t = bcs->blog;
  382. if (cs->subtyp == AVM_FRITZ_PNP)
  383. p = (u_char *) ptr;
  384. t += sprintf(t, "hdlc_fill_fifo %c cnt %d",
  385.      bcs->channel ? 'B' : 'A', count);
  386. QuickHex(t, p, count);
  387. debugl1(cs, bcs->blog);
  388. }
  389. }
  391. static void
  392. fill_hdlc(struct BCState *bcs)
  393. {
  394. long flags;
  395. save_flags(flags);
  396. cli();
  397. hdlc_fill_fifo(bcs);
  398. restore_flags(flags);
  399. }
  401. static inline void
  402. HDLC_irq(struct BCState *bcs, u_int stat) {
  403. int len;
  404. struct sk_buff *skb;
  406. if (bcs->cs->debug & L1_DEB_HSCX)
  407. debugl1(bcs->cs, "ch%d stat %#x", bcs->channel, stat);
  408. if (stat & HDLC_INT_RPR) {
  409. if (stat & HDLC_STAT_RDO) {
  410. if (bcs->cs->debug & L1_DEB_HSCX)
  411. debugl1(bcs->cs, "RDO");
  412. else
  413. debugl1(bcs->cs, "ch%d stat %#x", bcs->channel, stat);
  414. bcs->hw.hdlc.ctrl.sr.xml = 0;
  415. bcs->hw.hdlc.ctrl.sr.cmd |= HDLC_CMD_RRS;
  416. write_ctrl(bcs, 1);
  417. bcs->hw.hdlc.ctrl.sr.cmd &= ~HDLC_CMD_RRS;
  418. write_ctrl(bcs, 1);
  419. bcs->hw.hdlc.rcvidx = 0;
  420. } else {
  421. if (!(len = (stat & HDLC_STAT_RML_MASK)>>8))
  422. len = 32;
  423. hdlc_empty_fifo(bcs, len);
  424. if ((stat & HDLC_STAT_RME) || (bcs->mode == L1_MODE_TRANS)) {
  425. if (((stat & HDLC_STAT_CRCVFRRAB)==HDLC_STAT_CRCVFR) ||
  426. (bcs->mode == L1_MODE_TRANS)) {
  427. if (!(skb = dev_alloc_skb(bcs->hw.hdlc.rcvidx)))
  428. printk(KERN_WARNING "HDLC: receive out of memoryn");
  429. else {
  430. memcpy(skb_put(skb, bcs->hw.hdlc.rcvidx),
  431. bcs->hw.hdlc.rcvbuf, bcs->hw.hdlc.rcvidx);
  432. skb_queue_tail(&bcs->rqueue, skb);
  433. }
  434. bcs->hw.hdlc.rcvidx = 0;
  435. hdlc_sched_event(bcs, B_RCVBUFREADY);
  436. } else {
  437. if (bcs->cs->debug & L1_DEB_HSCX)
  438. debugl1(bcs->cs, "invalid frame");
  439. else
  440. debugl1(bcs->cs, "ch%d invalid frame %#x", bcs->channel, stat);
  441. bcs->hw.hdlc.rcvidx = 0;
  442. }
  443. }
  444. }
  445. }
  446. if (stat & HDLC_INT_XDU) {
  447. /* Here we lost an TX interrupt, so
  448.  * restart transmitting the whole frame.
  449.  */
  450. if (bcs->tx_skb) {
  451. skb_push(bcs->tx_skb, bcs->hw.hdlc.count);
  452. bcs->tx_cnt += bcs->hw.hdlc.count;
  453. bcs->hw.hdlc.count = 0;
  454. // hdlc_sched_event(bcs, B_XMTBUFREADY);
  455. if (bcs->cs->debug & L1_DEB_WARN)
  456. debugl1(bcs->cs, "ch%d XDU", bcs->channel);
  457. } else if (bcs->cs->debug & L1_DEB_WARN)
  458. debugl1(bcs->cs, "ch%d XDU without skb", bcs->channel);
  459. bcs->hw.hdlc.ctrl.sr.xml = 0;
  460. bcs->hw.hdlc.ctrl.sr.cmd |= HDLC_CMD_XRS;
  461. write_ctrl(bcs, 1);
  462. bcs->hw.hdlc.ctrl.sr.cmd &= ~HDLC_CMD_XRS;
  463. write_ctrl(bcs, 1);
  464. hdlc_fill_fifo(bcs);
  465. } else if (stat & HDLC_INT_XPR) {
  466. if (bcs->tx_skb) {
  467. if (bcs->tx_skb->len) {
  468. hdlc_fill_fifo(bcs);
  469. return;
  470. } else {
  471. if (bcs->st->lli.l1writewakeup &&
  472. (PACKET_NOACK != bcs->tx_skb->pkt_type))
  473. bcs->st->lli.l1writewakeup(bcs->st, bcs->hw.hdlc.count);
  474. dev_kfree_skb_irq(bcs->tx_skb);
  475. bcs->hw.hdlc.count = 0;
  476. bcs->tx_skb = NULL;
  477. }
  478. }
  479. if ((bcs->tx_skb = skb_dequeue(&bcs->squeue))) {
  480. bcs->hw.hdlc.count = 0;
  481. test_and_set_bit(BC_FLG_BUSY, &bcs->Flag);
  482. hdlc_fill_fifo(bcs);
  483. } else {
  484. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  485. hdlc_sched_event(bcs, B_XMTBUFREADY);
  486. }
  487. }
  488. }
  490. inline void
  491. HDLC_irq_main(struct IsdnCardState *cs)
  492. {
  493. u_int stat;
  494. long  flags;
  495. struct BCState *bcs;
  497. save_flags(flags);
  498. cli();
  499. if (cs->subtyp == AVM_FRITZ_PCI) {
  500. stat = ReadHDLCPCI(cs, 0, HDLC_STATUS);
  501. } else {
  502. stat = ReadHDLCPnP(cs, 0, HDLC_STATUS);
  503. if (stat & HDLC_INT_RPR)
  504. stat |= (ReadHDLCPnP(cs, 0, HDLC_STATUS+1))<<8;
  505. }
  506. if (stat & HDLC_INT_MASK) {
  507. if (!(bcs = Sel_BCS(cs, 0))) {
  508. if (cs->debug)
  509. debugl1(cs, "hdlc spurious channel 0 IRQ");
  510. } else
  511. HDLC_irq(bcs, stat);
  512. }
  513. if (cs->subtyp == AVM_FRITZ_PCI) {
  514. stat = ReadHDLCPCI(cs, 1, HDLC_STATUS);
  515. } else {
  516. stat = ReadHDLCPnP(cs, 1, HDLC_STATUS);
  517. if (stat & HDLC_INT_RPR)
  518. stat |= (ReadHDLCPnP(cs, 1, HDLC_STATUS+1))<<8;
  519. }
  520. if (stat & HDLC_INT_MASK) {
  521. if (!(bcs = Sel_BCS(cs, 1))) {
  522. if (cs->debug)
  523. debugl1(cs, "hdlc spurious channel 1 IRQ");
  524. } else
  525. HDLC_irq(bcs, stat);
  526. }
  527. restore_flags(flags);
  528. }
  530. void
  531. hdlc_l2l1(struct PStack *st, int pr, void *arg)
  532. {
  533. struct sk_buff *skb = arg;
  534. long flags;
  536. switch (pr) {
  537. case (PH_DATA | REQUEST):
  538. save_flags(flags);
  539. cli();
  540. if (st->l1.bcs->tx_skb) {
  541. skb_queue_tail(&st->l1.bcs->squeue, skb);
  542. restore_flags(flags);
  543. } else {
  544. st->l1.bcs->tx_skb = skb;
  545. test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  546. st->l1.bcs->hw.hdlc.count = 0;
  547. restore_flags(flags);
  548. st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
  549. }
  550. break;
  551. case (PH_PULL | INDICATION):
  552. if (st->l1.bcs->tx_skb) {
  553. printk(KERN_WARNING "hdlc_l2l1: this shouldn't happenn");
  554. break;
  555. }
  556. test_and_set_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  557. st->l1.bcs->tx_skb = skb;
  558. st->l1.bcs->hw.hdlc.count = 0;
  559. st->l1.bcs->cs->BC_Send_Data(st->l1.bcs);
  560. break;
  561. case (PH_PULL | REQUEST):
  562. if (!st->l1.bcs->tx_skb) {
  563. test_and_clear_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  564. st->l1.l1l2(st, PH_PULL | CONFIRM, NULL);
  565. } else
  566. test_and_set_bit(FLG_L1_PULL_REQ, &st->l1.Flags);
  567. break;
  568. case (PH_ACTIVATE | REQUEST):
  569. test_and_set_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
  570. modehdlc(st->l1.bcs, st->l1.mode, st->l1.bc);
  571. l1_msg_b(st, pr, arg);
  572. break;
  573. case (PH_DEACTIVATE | REQUEST):
  574. l1_msg_b(st, pr, arg);
  575. break;
  576. case (PH_DEACTIVATE | CONFIRM):
  577. test_and_clear_bit(BC_FLG_ACTIV, &st->l1.bcs->Flag);
  578. test_and_clear_bit(BC_FLG_BUSY, &st->l1.bcs->Flag);
  579. modehdlc(st->l1.bcs, 0, st->l1.bc);
  580. st->l1.l1l2(st, PH_DEACTIVATE | CONFIRM, NULL);
  581. break;
  582. }
  583. }
  585. void
  586. close_hdlcstate(struct BCState *bcs)
  587. {
  588. modehdlc(bcs, 0, 0);
  589. if (test_and_clear_bit(BC_FLG_INIT, &bcs->Flag)) {
  590. if (bcs->hw.hdlc.rcvbuf) {
  591. kfree(bcs->hw.hdlc.rcvbuf);
  592. bcs->hw.hdlc.rcvbuf = NULL;
  593. }
  594. if (bcs->blog) {
  595. kfree(bcs->blog);
  596. bcs->blog = NULL;
  597. }
  598. skb_queue_purge(&bcs->rqueue);
  599. skb_queue_purge(&bcs->squeue);
  600. if (bcs->tx_skb) {
  601. dev_kfree_skb_any(bcs->tx_skb);
  602. bcs->tx_skb = NULL;
  603. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  604. }
  605. }
  606. }
  608. int
  609. open_hdlcstate(struct IsdnCardState *cs, struct BCState *bcs)
  610. {
  611. if (!test_and_set_bit(BC_FLG_INIT, &bcs->Flag)) {
  612. if (!(bcs->hw.hdlc.rcvbuf = kmalloc(HSCX_BUFMAX, GFP_ATOMIC))) {
  613. printk(KERN_WARNING
  614.        "HiSax: No memory for hdlc.rcvbufn");
  615. return (1);
  616. }
  617. if (!(bcs->blog = kmalloc(MAX_BLOG_SPACE, GFP_ATOMIC))) {
  618. printk(KERN_WARNING
  619. "HiSax: No memory for bcs->blogn");
  620. test_and_clear_bit(BC_FLG_INIT, &bcs->Flag);
  621. kfree(bcs->hw.hdlc.rcvbuf);
  622. bcs->hw.hdlc.rcvbuf = NULL;
  623. return (2);
  624. }
  625. skb_queue_head_init(&bcs->rqueue);
  626. skb_queue_head_init(&bcs->squeue);
  627. }
  628. bcs->tx_skb = NULL;
  629. test_and_clear_bit(BC_FLG_BUSY, &bcs->Flag);
  630. bcs->event = 0;
  631. bcs->hw.hdlc.rcvidx = 0;
  632. bcs->tx_cnt = 0;
  633. return (0);
  634. }
  636. int
  637. setstack_hdlc(struct PStack *st, struct BCState *bcs)
  638. {
  639. bcs->channel = st->l1.bc;
  640. if (open_hdlcstate(st->l1.hardware, bcs))
  641. return (-1);
  642. st->l1.bcs = bcs;
  643. st->l2.l2l1 = hdlc_l2l1;
  644. setstack_manager(st);
  645. bcs->st = st;
  646. setstack_l1_B(st);
  647. return (0);
  648. }
  650. void __init
  651. clear_pending_hdlc_ints(struct IsdnCardState *cs)
  652. {
  653. u_int val;
  655. if (cs->subtyp == AVM_FRITZ_PCI) {
  656. val = ReadHDLCPCI(cs, 0, HDLC_STATUS);
  657. debugl1(cs, "HDLC 1 STA %x", val);
  658. val = ReadHDLCPCI(cs, 1, HDLC_STATUS);
  659. debugl1(cs, "HDLC 2 STA %x", val);
  660. } else {
  661. val = ReadHDLCPnP(cs, 0, HDLC_STATUS);
  662. debugl1(cs, "HDLC 1 STA %x", val);
  663. val = ReadHDLCPnP(cs, 0, HDLC_STATUS + 1);
  664. debugl1(cs, "HDLC 1 RML %x", val);
  665. val = ReadHDLCPnP(cs, 0, HDLC_STATUS + 2);
  666. debugl1(cs, "HDLC 1 MODE %x", val);
  667. val = ReadHDLCPnP(cs, 0, HDLC_STATUS + 3);
  668. debugl1(cs, "HDLC 1 VIN %x", val);
  669. val = ReadHDLCPnP(cs, 1, HDLC_STATUS);
  670. debugl1(cs, "HDLC 2 STA %x", val);
  671. val = ReadHDLCPnP(cs, 1, HDLC_STATUS + 1);
  672. debugl1(cs, "HDLC 2 RML %x", val);
  673. val = ReadHDLCPnP(cs, 1, HDLC_STATUS + 2);
  674. debugl1(cs, "HDLC 2 MODE %x", val);
  675. val = ReadHDLCPnP(cs, 1, HDLC_STATUS + 3);
  676. debugl1(cs, "HDLC 2 VIN %x", val);
  677. }
  678. }
  680. void __init
  681. inithdlc(struct IsdnCardState *cs)
  682. {
  683. cs->bcs[0].BC_SetStack = setstack_hdlc;
  684. cs->bcs[1].BC_SetStack = setstack_hdlc;
  685. cs->bcs[0].BC_Close = close_hdlcstate;
  686. cs->bcs[1].BC_Close = close_hdlcstate;
  687. modehdlc(cs->bcs, -1, 0);
  688. modehdlc(cs->bcs + 1, -1, 1);
  689. }
  691. static void
  692. avm_pcipnp_interrupt(int intno, void *dev_id, struct pt_regs *regs)
  693. {
  694. struct IsdnCardState *cs = dev_id;
  695. u_char val;
  696. u_char sval;
  698. if (!cs) {
  699. printk(KERN_WARNING "AVM PCI: Spurious interrupt!n");
  700. return;
  701. }
  702. sval = inb(cs->hw.avm.cfg_reg + 2);
  703. if ((sval & AVM_STATUS0_IRQ_MASK) == AVM_STATUS0_IRQ_MASK)
  704. /* possible a shared  IRQ reqest */
  705. return;
  706. if (!(sval & AVM_STATUS0_IRQ_ISAC)) {
  707. val = ReadISAC(cs, ISAC_ISTA);
  708. isac_interrupt(cs, val);
  709. }
  710. if (!(sval & AVM_STATUS0_IRQ_HDLC)) {
  711. HDLC_irq_main(cs);
  712. }
  713. WriteISAC(cs, ISAC_MASK, 0xFF);
  714. WriteISAC(cs, ISAC_MASK, 0x0);
  715. }
  717. static void
  718. reset_avmpcipnp(struct IsdnCardState *cs)
  719. {
  720. long flags;
  722. printk(KERN_INFO "AVM PCI/PnP: resetn");
  723. save_flags(flags);
  724. sti();
  725. outb(AVM_STATUS0_RESET | AVM_STATUS0_DIS_TIMER, cs->hw.avm.cfg_reg + 2);
  726. set_current_state(TASK_UNINTERRUPTIBLE);
  727. schedule_timeout((10*HZ)/1000); /* Timeout 10ms */
  728. outb(AVM_STATUS0_DIS_TIMER | AVM_STATUS0_RES_TIMER | AVM_STATUS0_ENA_IRQ, cs->hw.avm.cfg_reg + 2);
  729. outb(AVM_STATUS1_ENA_IOM | cs->irq, cs->hw.avm.cfg_reg + 3);
  730. set_current_state(TASK_UNINTERRUPTIBLE);
  731. schedule_timeout((10*HZ)/1000); /* Timeout 10ms */
  732. printk(KERN_INFO "AVM PCI/PnP: S1 %xn", inb(cs->hw.avm.cfg_reg + 3));
  733. }
  735. static int
  736. AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
  737. {
  738. switch (mt) {
  739. case CARD_RESET:
  740. reset_avmpcipnp(cs);
  741. return(0);
  742. case CARD_RELEASE:
  743. outb(0, cs->hw.avm.cfg_reg + 2);
  744. release_region(cs->hw.avm.cfg_reg, 32);
  745. return(0);
  746. case CARD_INIT:
  747. clear_pending_isac_ints(cs);
  748. initisac(cs);
  749. clear_pending_hdlc_ints(cs);
  750. inithdlc(cs);
  751. outb(AVM_STATUS0_DIS_TIMER | AVM_STATUS0_RES_TIMER,
  752. cs->hw.avm.cfg_reg + 2);
  753. WriteISAC(cs, ISAC_MASK, 0);
  754. outb(AVM_STATUS0_DIS_TIMER | AVM_STATUS0_RES_TIMER |
  755. AVM_STATUS0_ENA_IRQ, cs->hw.avm.cfg_reg + 2);
  756. /* RESET Receiver and Transmitter */
  757. WriteISAC(cs, ISAC_CMDR, 0x41);
  758. return(0);
  759. case CARD_TEST:
  760. return(0);
  761. }
  762. return(0);
  763. }
  765. static struct pci_dev *dev_avm __initdata = NULL;
  767. int __init
  768. setup_avm_pcipnp(struct IsdnCard *card)
  769. {
  770. u_int val, ver;
  771. struct IsdnCardState *cs = card->cs;
  772. char tmp[64];
  774. strcpy(tmp, avm_pci_rev);
  775. printk(KERN_INFO "HiSax: AVM PCI driver Rev. %sn", HiSax_getrev(tmp));
  776. if (cs->typ != ISDN_CTYPE_FRITZPCI)
  777. return (0);
  778. if (card->para[1]) {
  779. cs->hw.avm.cfg_reg = card->para[1];
  780. cs->irq = card->para[0];
  781. cs->subtyp = AVM_FRITZ_PNP;
  782. } else {
  783. #if CONFIG_PCI
  784. if (!pci_present()) {
  785. printk(KERN_ERR "FritzPCI: no PCI bus presentn");
  786. return(0);
  787. }
  788. if ((dev_avm = pci_find_device(PCI_VENDOR_ID_AVM,
  789. PCI_DEVICE_ID_AVM_A1,  dev_avm))) {
  790. cs->irq = dev_avm->irq;
  791. if (!cs->irq) {
  792. printk(KERN_ERR "FritzPCI: No IRQ for PCI card foundn");
  793. return(0);
  794. }
  795. if (pci_enable_device(dev_avm))
  796. return(0);
  797. cs->hw.avm.cfg_reg = pci_resource_start(dev_avm, 1);
  798. if (!cs->hw.avm.cfg_reg) {
  799. printk(KERN_ERR "FritzPCI: No IO-Adr for PCI card foundn");
  800. return(0);
  801. }
  802. cs->subtyp = AVM_FRITZ_PCI;
  803. } else {
  804. printk(KERN_WARNING "FritzPCI: No PCI card foundn");
  805. return(0);
  806. }
  807. cs->irq_flags |= SA_SHIRQ;
  808. #else
  809. printk(KERN_WARNING "FritzPCI: NO_PCI_BIOSn");
  810. return (0);
  811. #endif /* CONFIG_PCI */
  812. }
  813. cs->hw.avm.isac = cs->hw.avm.cfg_reg + 0x10;
  814. if (check_region((cs->hw.avm.cfg_reg), 32)) {
  815. printk(KERN_WARNING
  816.        "HiSax: %s config port %x-%x already in usen",
  817.        CardType[card->typ],
  818.        cs->hw.avm.cfg_reg,
  819.        cs->hw.avm.cfg_reg + 31);
  820. return (0);
  821. } else {
  822. request_region(cs->hw.avm.cfg_reg, 32,
  823. (cs->subtyp == AVM_FRITZ_PCI) ? "avm PCI" : "avm PnP");
  824. }
  825. switch (cs->subtyp) {
  826.   case AVM_FRITZ_PCI:
  827. val = inl(cs->hw.avm.cfg_reg);
  828. printk(KERN_INFO "AVM PCI: stat %#xn", val);
  829. printk(KERN_INFO "AVM PCI: Class %X Rev %dn",
  830. val & 0xff, (val>>8) & 0xff);
  831. cs->BC_Read_Reg = &ReadHDLC_s;
  832. cs->BC_Write_Reg = &WriteHDLC_s;
  833. break;
  834.   case AVM_FRITZ_PNP:
  835. val = inb(cs->hw.avm.cfg_reg);
  836. ver = inb(cs->hw.avm.cfg_reg + 1);
  837. printk(KERN_INFO "AVM PnP: Class %X Rev %dn", val, ver);
  838. reset_avmpcipnp(cs);
  839. cs->BC_Read_Reg = &ReadHDLCPnP;
  840. cs->BC_Write_Reg = &WriteHDLCPnP;
  841. break;
  842.   default:
  843.    printk(KERN_WARNING "AVM unknown subtype %dn", cs->subtyp);
  844.    return(0);
  845. }
  846. printk(KERN_INFO "HiSax: %s config irq:%d base:0x%Xn",
  847. (cs->subtyp == AVM_FRITZ_PCI) ? "AVM Fritz!PCI" : "AVM Fritz!PnP",
  848. cs->irq, cs->hw.avm.cfg_reg);
  850. cs->readisac = &ReadISAC;
  851. cs->writeisac = &WriteISAC;
  852. cs->readisacfifo = &ReadISACfifo;
  853. cs->writeisacfifo = &WriteISACfifo;
  854. cs->BC_Send_Data = &fill_hdlc;
  855. cs->cardmsg = &AVM_card_msg;
  856. cs->irq_func = &avm_pcipnp_interrupt;
  857. ISACVersion(cs, (cs->subtyp == AVM_FRITZ_PCI) ? "AVM PCI:" : "AVM PnP:");
  858. return (1);
  859. }