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

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

嵌入式Linux

开发平台：

Unix_Linux

avm_a1.c：源码内容
  1. /* $Id: avm_a1.c,v 1.1.4.1 2001/11/20 14:19:35 kai Exp $
  2.  *
  3.  * low level stuff for AVM A1 (Fritz) 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.  */
  13. #define __NO_VERSION__
  14. #include <linux/init.h>
  15. #include "hisax.h"
  16. #include "isac.h"
  17. #include "hscx.h"
  18. #include "isdnl1.h"
  20. extern const char *CardType[];
  21. static const char *avm_revision = "$Revision: 1.1.4.1 $";
  23. #define  AVM_A1_STAT_ISAC 0x01
  24. #define  AVM_A1_STAT_HSCX 0x02
  25. #define  AVM_A1_STAT_TIMER 0x04
  27. #define byteout(addr,val) outb(val,addr)
  28. #define bytein(addr) inb(addr)
  30. static inline u_char
  31. readreg(unsigned int adr, u_char off)
  32. {
  33. return (bytein(adr + off));
  34. }
  36. static inline void
  37. writereg(unsigned int adr, u_char off, u_char data)
  38. {
  39. byteout(adr + off, data);
  40. }
  43. static inline void
  44. read_fifo(unsigned int adr, u_char * data, int size)
  45. {
  46. insb(adr, data, size);
  47. }
  49. static void
  50. write_fifo(unsigned int adr, u_char * data, int size)
  51. {
  52. outsb(adr, data, size);
  53. }
  55. /* Interface functions */
  57. static u_char
  58. ReadISAC(struct IsdnCardState *cs, u_char offset)
  59. {
  60. return (readreg(cs->hw.avm.isac, offset));
  61. }
  63. static void
  64. WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
  65. {
  66. writereg(cs->hw.avm.isac, offset, value);
  67. }
  69. static void
  70. ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  71. {
  72. read_fifo(cs->hw.avm.isacfifo, data, size);
  73. }
  75. static void
  76. WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
  77. {
  78. write_fifo(cs->hw.avm.isacfifo, data, size);
  79. }
  81. static u_char
  82. ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
  83. {
  84. return (readreg(cs->hw.avm.hscx[hscx], offset));
  85. }
  87. static void
  88. WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
  89. {
  90. writereg(cs->hw.avm.hscx[hscx], offset, value);
  91. }
  93. /*
  94.  * fast interrupt HSCX stuff goes here
  95.  */
  97. #define READHSCX(cs, nr, reg) readreg(cs->hw.avm.hscx[nr], reg)
  98. #define WRITEHSCX(cs, nr, reg, data) writereg(cs->hw.avm.hscx[nr], reg, data)
  99. #define READHSCXFIFO(cs, nr, ptr, cnt) read_fifo(cs->hw.avm.hscxfifo[nr], ptr, cnt)
  100. #define WRITEHSCXFIFO(cs, nr, ptr, cnt) write_fifo(cs->hw.avm.hscxfifo[nr], ptr, cnt)
  102. #include "hscx_irq.c"
  104. static void
  105. avm_a1_interrupt(int intno, void *dev_id, struct pt_regs *regs)
  106. {
  107. struct IsdnCardState *cs = dev_id;
  108. u_char val, sval;
  110. if (!cs) {
  111. printk(KERN_WARNING "AVM A1: Spurious interrupt!n");
  112. return;
  113. }
  114. while (((sval = bytein(cs->hw.avm.cfg_reg)) & 0xf) != 0x7) {
  115. if (!(sval & AVM_A1_STAT_TIMER)) {
  116. byteout(cs->hw.avm.cfg_reg, 0x1E);
  117. sval = bytein(cs->hw.avm.cfg_reg);
  118. } else if (cs->debug & L1_DEB_INTSTAT)
  119. debugl1(cs, "avm IntStatus %x", sval);
  120. if (!(sval & AVM_A1_STAT_HSCX)) {
  121. val = readreg(cs->hw.avm.hscx[1], HSCX_ISTA);
  122. if (val)
  123. hscx_int_main(cs, val);
  124. }
  125. if (!(sval & AVM_A1_STAT_ISAC)) {
  126. val = readreg(cs->hw.avm.isac, ISAC_ISTA);
  127. if (val)
  128. isac_interrupt(cs, val);
  129. }
  130. }
  131. writereg(cs->hw.avm.hscx[0], HSCX_MASK, 0xFF);
  132. writereg(cs->hw.avm.hscx[1], HSCX_MASK, 0xFF);
  133. writereg(cs->hw.avm.isac, ISAC_MASK, 0xFF);
  134. writereg(cs->hw.avm.isac, ISAC_MASK, 0x0);
  135. writereg(cs->hw.avm.hscx[0], HSCX_MASK, 0x0);
  136. writereg(cs->hw.avm.hscx[1], HSCX_MASK, 0x0);
  137. }
  139. inline static void
  140. release_ioregs(struct IsdnCardState *cs, int mask)
  141. {
  142. release_region(cs->hw.avm.cfg_reg, 8);
  143. if (mask & 1)
  144. release_region(cs->hw.avm.isac + 32, 32);
  145. if (mask & 2)
  146. release_region(cs->hw.avm.isacfifo, 1);
  147. if (mask & 4)
  148. release_region(cs->hw.avm.hscx[0] + 32, 32);
  149. if (mask & 8)
  150. release_region(cs->hw.avm.hscxfifo[0], 1);
  151. if (mask & 0x10)
  152. release_region(cs->hw.avm.hscx[1] + 32, 32);
  153. if (mask & 0x20)
  154. release_region(cs->hw.avm.hscxfifo[1], 1);
  155. }
  157. static int
  158. AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
  159. {
  160. switch (mt) {
  161. case CARD_RESET:
  162. return(0);
  163. case CARD_RELEASE:
  164. release_ioregs(cs, 0x3f);
  165. return(0);
  166. case CARD_INIT:
  167. inithscxisac(cs, 1);
  168. byteout(cs->hw.avm.cfg_reg, 0x16);
  169. byteout(cs->hw.avm.cfg_reg, 0x1E);
  170. inithscxisac(cs, 2);
  171. return(0);
  172. case CARD_TEST:
  173. return(0);
  174. }
  175. return(0);
  176. }
  178. int __init
  179. setup_avm_a1(struct IsdnCard *card)
  180. {
  181. u_char val;
  182. struct IsdnCardState *cs = card->cs;
  183. long flags;
  184. char tmp[64];
  186. strcpy(tmp, avm_revision);
  187. printk(KERN_INFO "HiSax: AVM driver Rev. %sn", HiSax_getrev(tmp));
  188. if (cs->typ != ISDN_CTYPE_A1)
  189. return (0);
  191. cs->hw.avm.cfg_reg = card->para[1] + 0x1800;
  192. cs->hw.avm.isac = card->para[1] + 0x1400 - 0x20;
  193. cs->hw.avm.hscx[0] = card->para[1] + 0x400 - 0x20;
  194. cs->hw.avm.hscx[1] = card->para[1] + 0xc00 - 0x20;
  195. cs->hw.avm.isacfifo = card->para[1] + 0x1000;
  196. cs->hw.avm.hscxfifo[0] = card->para[1];
  197. cs->hw.avm.hscxfifo[1] = card->para[1] + 0x800;
  198. cs->irq = card->para[0];
  199. if (check_region((cs->hw.avm.cfg_reg), 8)) {
  200. printk(KERN_WARNING
  201.        "HiSax: %s config port %x-%x already in usen",
  202.        CardType[card->typ],
  203.        cs->hw.avm.cfg_reg,
  204.        cs->hw.avm.cfg_reg + 8);
  205. return (0);
  206. } else {
  207. request_region(cs->hw.avm.cfg_reg, 8, "avm cfg");
  208. }
  209. if (check_region((cs->hw.avm.isac + 32), 32)) {
  210. printk(KERN_WARNING
  211.        "HiSax: %s isac ports %x-%x already in usen",
  212.        CardType[cs->typ],
  213.        cs->hw.avm.isac + 32,
  214.        cs->hw.avm.isac + 64);
  215. release_ioregs(cs, 0);
  216. return (0);
  217. } else {
  218. request_region(cs->hw.avm.isac + 32, 32, "HiSax isac");
  219. }
  220. if (check_region((cs->hw.avm.isacfifo), 1)) {
  221. printk(KERN_WARNING
  222.        "HiSax: %s isac fifo port %x already in usen",
  223.        CardType[cs->typ],
  224.        cs->hw.avm.isacfifo);
  225. release_ioregs(cs, 1);
  226. return (0);
  227. } else {
  228. request_region(cs->hw.avm.isacfifo, 1, "HiSax isac fifo");
  229. }
  230. if (check_region((cs->hw.avm.hscx[0]) + 32, 32)) {
  231. printk(KERN_WARNING
  232.        "HiSax: %s hscx A ports %x-%x already in usen",
  233.        CardType[cs->typ],
  234.        cs->hw.avm.hscx[0] + 32,
  235.        cs->hw.avm.hscx[0] + 64);
  236. release_ioregs(cs, 3);
  237. return (0);
  238. } else {
  239. request_region(cs->hw.avm.hscx[0] + 32, 32, "HiSax hscx A");
  240. }
  241. if (check_region(cs->hw.avm.hscxfifo[0], 1)) {
  242. printk(KERN_WARNING
  243.        "HiSax: %s hscx A fifo port %x already in usen",
  244.        CardType[cs->typ],
  245.        cs->hw.avm.hscxfifo[0]);
  246. release_ioregs(cs, 7);
  247. return (0);
  248. } else {
  249. request_region(cs->hw.avm.hscxfifo[0], 1, "HiSax hscx A fifo");
  250. }
  251. if (check_region(cs->hw.avm.hscx[1] + 32, 32)) {
  252. printk(KERN_WARNING
  253.        "HiSax: %s hscx B ports %x-%x already in usen",
  254.        CardType[cs->typ],
  255.        cs->hw.avm.hscx[1] + 32,
  256.        cs->hw.avm.hscx[1] + 64);
  257. release_ioregs(cs, 0xf);
  258. return (0);
  259. } else {
  260. request_region(cs->hw.avm.hscx[1] + 32, 32, "HiSax hscx B");
  261. }
  262. if (check_region(cs->hw.avm.hscxfifo[1], 1)) {
  263. printk(KERN_WARNING
  264.        "HiSax: %s hscx B fifo port %x already in usen",
  265.        CardType[cs->typ],
  266.        cs->hw.avm.hscxfifo[1]);
  267. release_ioregs(cs, 0x1f);
  268. return (0);
  269. } else {
  270. request_region(cs->hw.avm.hscxfifo[1], 1, "HiSax hscx B fifo");
  271. }
  272. save_flags(flags);
  273. byteout(cs->hw.avm.cfg_reg, 0x0);
  274. sti();
  275. HZDELAY(HZ / 5 + 1);
  276. byteout(cs->hw.avm.cfg_reg, 0x1);
  277. HZDELAY(HZ / 5 + 1);
  278. byteout(cs->hw.avm.cfg_reg, 0x0);
  279. HZDELAY(HZ / 5 + 1);
  280. val = cs->irq;
  281. if (val == 9)
  282. val = 2;
  283. byteout(cs->hw.avm.cfg_reg + 1, val);
  284. HZDELAY(HZ / 5 + 1);
  285. byteout(cs->hw.avm.cfg_reg, 0x0);
  286. HZDELAY(HZ / 5 + 1);
  287. restore_flags(flags);
  289. val = bytein(cs->hw.avm.cfg_reg);
  290. printk(KERN_INFO "AVM A1: Byte at %x is %xn",
  291.        cs->hw.avm.cfg_reg, val);
  292. val = bytein(cs->hw.avm.cfg_reg + 3);
  293. printk(KERN_INFO "AVM A1: Byte at %x is %xn",
  294.        cs->hw.avm.cfg_reg + 3, val);
  295. val = bytein(cs->hw.avm.cfg_reg + 2);
  296. printk(KERN_INFO "AVM A1: Byte at %x is %xn",
  297.        cs->hw.avm.cfg_reg + 2, val);
  298. val = bytein(cs->hw.avm.cfg_reg);
  299. printk(KERN_INFO "AVM A1: Byte at %x is %xn",
  300.        cs->hw.avm.cfg_reg, val);
  302. printk(KERN_INFO
  303.        "HiSax: %s config irq:%d cfg:0x%Xn",
  304.        CardType[cs->typ], cs->irq,
  305.        cs->hw.avm.cfg_reg);
  306. printk(KERN_INFO
  307.        "HiSax: isac:0x%X/0x%Xn",
  308.        cs->hw.avm.isac + 32, cs->hw.avm.isacfifo);
  309. printk(KERN_INFO
  310.        "HiSax: hscx A:0x%X/0x%X  hscx B:0x%X/0x%Xn",
  311.        cs->hw.avm.hscx[0] + 32, cs->hw.avm.hscxfifo[0],
  312.        cs->hw.avm.hscx[1] + 32, cs->hw.avm.hscxfifo[1]);
  314. cs->readisac = &ReadISAC;
  315. cs->writeisac = &WriteISAC;
  316. cs->readisacfifo = &ReadISACfifo;
  317. cs->writeisacfifo = &WriteISACfifo;
  318. cs->BC_Read_Reg = &ReadHSCX;
  319. cs->BC_Write_Reg = &WriteHSCX;
  320. cs->BC_Send_Data = &hscx_fill_fifo;
  321. cs->cardmsg = &AVM_card_msg;
  322. cs->irq_func = &avm_a1_interrupt;
  323. ISACVersion(cs, "AVM A1:");
  324. if (HscxVersion(cs, "AVM A1:")) {
  325. printk(KERN_WARNING
  326.        "AVM A1: wrong HSCX versions check IO addressn");
  327. release_ioregs(cs, 0x3f);
  328. return (0);
  329. }
  330. return (1);
  331. }