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

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

Linux/Unix编程

开发平台：

Unix_Linux

tcic.c：源码内容
  1. /*======================================================================
  3.     Device driver for Databook TCIC-2 PCMCIA controller
  5.     tcic.c 1.111 2000/02/15 04:13:12
  7.     The contents of this file are subject to the Mozilla Public
  8.     License Version 1.1 (the "License"); you may not use this file
  9.     except in compliance with the License. You may obtain a copy of
  10.     the License at http://www.mozilla.org/MPL/
  12.     Software distributed under the License is distributed on an "AS
  13.     IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  14.     implied. See the License for the specific language governing
  15.     rights and limitations under the License.
  17.     The initial developer of the original code is David A. Hinds
  18.     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  19.     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  21.     Alternatively, the contents of this file may be used under the
  22.     terms of the GNU General Public License version 2 (the "GPL"), in which
  23.     case the provisions of the GPL are applicable instead of the
  24.     above.  If you wish to allow the use of your version of this file
  25.     only under the terms of the GPL and not to allow others to use
  26.     your version of this file under the MPL, indicate your decision
  27.     by deleting the provisions above and replace them with the notice
  28.     and other provisions required by the GPL.  If you do not delete
  29.     the provisions above, a recipient may use your version of this
  30.     file under either the MPL or the GPL.
  31.     
  32. ======================================================================*/
  34. #include <linux/module.h>
  35. #include <linux/init.h>
  36. #include <linux/types.h>
  37. #include <linux/fcntl.h>
  38. #include <linux/string.h>
  40. #include <asm/io.h>
  41. #include <asm/bitops.h>
  42. #include <asm/segment.h>
  43. #include <asm/system.h>
  45. #include <linux/kernel.h>
  46. #include <linux/errno.h>
  47. #include <linux/sched.h>
  48. #include <linux/slab.h>
  49. #include <linux/timer.h>
  50. #include <linux/ioport.h>
  51. #include <linux/delay.h>
  52. #include <linux/proc_fs.h>
  54. #include <pcmcia/version.h>
  55. #include <pcmcia/cs_types.h>
  56. #include <pcmcia/cs.h>
  57. #include <pcmcia/ss.h>
  58. #include "tcic.h"
  60. #ifdef PCMCIA_DEBUG
  61. static int pc_debug = PCMCIA_DEBUG;
  62. MODULE_PARM(pc_debug, "i");
  63. static const char *version =
  64. "tcic.c 1.111 2000/02/15 04:13:12 (David Hinds)";
  65. #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  66. #else
  67. #define DEBUG(n, args...)
  68. #endif
  70. MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  71. MODULE_DESCRIPTION("Databook TCIC-2 PCMCIA socket driver");
  72. MODULE_LICENSE("Dual MPL/GPL");
  74. /*====================================================================*/
  76. /* Parameters that can be set with 'insmod' */
  78. /* The base port address of the TCIC-2 chip */
  79. static int tcic_base = TCIC_BASE;
  81. /* Specify a socket number to ignore */
  82. static int ignore = -1;
  84. /* Probe for safe interrupts? */
  85. static int do_scan = 1;
  87. /* Bit map of interrupts to choose from */
  88. static u_int irq_mask = 0xffff;
  89. static int irq_list[16] = { -1 };
  91. /* The card status change interrupt -- 0 means autoselect */
  92. static int cs_irq = 0;
  94. /* Poll status interval -- 0 means default to interrupt */
  95. static int poll_interval = 0;
  97. /* Delay for card status double-checking */
  98. static int poll_quick = HZ/20;
  100. /* CCLK external clock time, in nanoseconds.  70 ns = 14.31818 MHz */
  101. static int cycle_time = 70;
  103. MODULE_PARM(tcic_base, "i");
  104. MODULE_PARM(ignore, "i");
  105. MODULE_PARM(do_scan, "i");
  106. MODULE_PARM(irq_mask, "i");
  107. MODULE_PARM(irq_list, "1-16i");
  108. MODULE_PARM(cs_irq, "i");
  109. MODULE_PARM(poll_interval, "i");
  110. MODULE_PARM(poll_quick, "i");
  111. MODULE_PARM(cycle_time, "i");
  113. /*====================================================================*/
  115. static void tcic_interrupt(int irq, void *dev, struct pt_regs *regs);
  116. static void tcic_timer(u_long data);
  117. static struct pccard_operations tcic_operations;
  119. typedef struct socket_info_t {
  120.     u_short psock;
  121.     void (*handler)(void *info, u_int events);
  122.     void *info;
  123.     u_char last_sstat;
  124.     u_char id;
  125. } socket_info_t;
  127. static struct timer_list poll_timer;
  128. static int tcic_timer_pending = 0;
  130. static int sockets;
  131. static socket_info_t socket_table[2];
  133. static socket_cap_t tcic_cap = {
  134.     /* only 16-bit cards, memory windows must be size-aligned */
  135.     SS_CAP_PCCARD | SS_CAP_MEM_ALIGN,
  136.     0x4cf8, /* irq 14, 11, 10, 7, 6, 5, 4, 3 */
  137.     0x1000, /* 4K minimum window size */
  138.     0, 0 /* No PCI or CardBus support */
  139. };
  141. /*====================================================================*/
  143. /* Trick when selecting interrupts: the TCIC sktirq pin is supposed
  144.    to map to irq 11, but is coded as 0 or 1 in the irq registers. */
  145. #define TCIC_IRQ(x) ((x) ? (((x) == 11) ? 1 : (x)) : 15)
  147. #ifdef PCMCIA_DEBUG_X
  148. static u_char tcic_getb(u_char reg)
  149. {
  150.     u_char val = inb(tcic_base+reg);
  151.     printk(KERN_DEBUG "tcic_getb(%#x) = %#xn", tcic_base+reg, val);
  152.     return val;
  153. }
  155. static u_short tcic_getw(u_char reg)
  156. {
  157.     u_short val = inw(tcic_base+reg);
  158.     printk(KERN_DEBUG "tcic_getw(%#x) = %#xn", tcic_base+reg, val);
  159.     return val;
  160. }
  162. static void tcic_setb(u_char reg, u_char data)
  163. {
  164.     printk(KERN_DEBUG "tcic_setb(%#x, %#x)n", tcic_base+reg, data);
  165.     outb(data, tcic_base+reg);
  166. }
  168. static void tcic_setw(u_char reg, u_short data)
  169. {
  170.     printk(KERN_DEBUG "tcic_setw(%#x, %#x)n", tcic_base+reg, data);
  171.     outw(data, tcic_base+reg);
  172. }
  173. #else
  174. #define tcic_getb(reg) inb(tcic_base+reg)
  175. #define tcic_getw(reg) inw(tcic_base+reg)
  176. #define tcic_setb(reg, data) outb(data, tcic_base+reg)
  177. #define tcic_setw(reg, data) outw(data, tcic_base+reg)
  178. #endif
  180. static void tcic_setl(u_char reg, u_int data)
  181. {
  182. #ifdef PCMCIA_DEBUG_X
  183.     printk(KERN_DEBUG "tcic_setl(%#x, %#lx)n", tcic_base+reg, data);
  184. #endif
  185.     outw(data & 0xffff, tcic_base+reg);
  186.     outw(data >> 16, tcic_base+reg+2);
  187. }
  189. static u_char tcic_aux_getb(u_short reg)
  190. {
  191.     u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
  192.     tcic_setb(TCIC_MODE, mode);
  193.     return tcic_getb(TCIC_AUX);
  194. }
  196. static void tcic_aux_setb(u_short reg, u_char data)
  197. {
  198.     u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
  199.     tcic_setb(TCIC_MODE, mode);
  200.     tcic_setb(TCIC_AUX, data);
  201. }
  203. static u_short tcic_aux_getw(u_short reg)
  204. {
  205.     u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
  206.     tcic_setb(TCIC_MODE, mode);
  207.     return tcic_getw(TCIC_AUX);
  208. }
  210. static void tcic_aux_setw(u_short reg, u_short data)
  211. {
  212.     u_char mode = (tcic_getb(TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
  213.     tcic_setb(TCIC_MODE, mode);
  214.     tcic_setw(TCIC_AUX, data);
  215. }
  217. /*====================================================================*/
  219. /* Time conversion functions */
  221. static int to_cycles(int ns)
  222. {
  223.     if (ns < 14)
  224. return 0;
  225.     else
  226. return 2*(ns-14)/cycle_time;
  227. }
  229. static int to_ns(int cycles)
  230. {
  231.     return (cycles*cycle_time)/2 + 14;
  232. }
  234. /*====================================================================*/
  236. static volatile u_int irq_hits;
  238. static void __init irq_count(int irq, void *dev, struct pt_regs *regs)
  239. {
  240.     irq_hits++;
  241. }
  243. static u_int __init try_irq(int irq)
  244. {
  245.     u_short cfg;
  247.     irq_hits = 0;
  248.     if (request_irq(irq, irq_count, 0, "irq scan", irq_count) != 0)
  249. return -1;
  250.     mdelay(10);
  251.     if (irq_hits) {
  252. free_irq(irq, irq_count);
  253. return -1;
  254.     }
  256.     /* Generate one interrupt */
  257.     cfg = TCIC_SYSCFG_AUTOBUSY | 0x0a00;
  258.     tcic_aux_setw(TCIC_AUX_SYSCFG, cfg | TCIC_IRQ(irq));
  259.     tcic_setb(TCIC_IENA, TCIC_IENA_ERR | TCIC_IENA_CFG_HIGH);
  260.     tcic_setb(TCIC_ICSR, TCIC_ICSR_ERR | TCIC_ICSR_JAM);
  262.     udelay(1000);
  263.     free_irq(irq, irq_count);
  265.     /* Turn off interrupts */
  266.     tcic_setb(TCIC_IENA, TCIC_IENA_CFG_OFF);
  267.     while (tcic_getb(TCIC_ICSR))
  268. tcic_setb(TCIC_ICSR, TCIC_ICSR_JAM);
  269.     tcic_aux_setw(TCIC_AUX_SYSCFG, cfg);
  270.     
  271.     return (irq_hits != 1);
  272. }
  274. static u_int __init irq_scan(u_int mask0)
  275. {
  276.     u_int mask1;
  277.     int i;
  279. #ifdef __alpha__
  280. #define PIC 0x4d0
  281.     /* Don't probe level-triggered interrupts -- reserved for PCI */
  282.     int level_mask = inb_p(PIC) | (inb_p(PIC+1) << 8);
  283.     if (level_mask)
  284. mask0 &= ~level_mask;
  285. #endif
  287.     mask1 = 0;
  288.     if (do_scan) {
  289. for (i = 0; i < 16; i++)
  290.     if ((mask0 & (1 << i)) && (try_irq(i) == 0))
  291. mask1 |= (1 << i);
  292. for (i = 0; i < 16; i++)
  293.     if ((mask1 & (1 << i)) && (try_irq(i) != 0)) {
  294. mask1 ^= (1 << i);
  295.     }
  296.     }
  297.     
  298.     if (mask1) {
  299. printk("scanned");
  300.     } else {
  301. /* Fallback: just find interrupts that aren't in use */
  302. for (i = 0; i < 16; i++)
  303.     if ((mask0 & (1 << i)) &&
  304. (request_irq(i, irq_count, 0, "x", irq_count) == 0)) {
  305. mask1 |= (1 << i);
  306. free_irq(i, irq_count);
  307.     }
  308. printk("default");
  309.     }
  310.     
  311.     printk(") = ");
  312.     for (i = 0; i < 16; i++)
  313. if (mask1 & (1<<i))
  314.     printk("%s%d", ((mask1 & ((1<<i)-1)) ? "," : ""), i);
  315.     printk(" ");
  316.     
  317.     return mask1;
  318. }
  320. /*======================================================================
  322.     See if a card is present, powered up, in IO mode, and already
  323.     bound to a (non-PCMCIA) Linux driver.
  325.     We make an exception for cards that look like serial devices.
  326.     
  327. ======================================================================*/
  329. static int __init is_active(int s)
  330. {
  331.     u_short scf1, ioctl, base, num;
  332.     u_char pwr, sstat;
  333.     u_int addr;
  334.     
  335.     tcic_setl(TCIC_ADDR, (s << TCIC_ADDR_SS_SHFT)
  336.       | TCIC_ADDR_INDREG | TCIC_SCF1(s));
  337.     scf1 = tcic_getw(TCIC_DATA);
  338.     pwr = tcic_getb(TCIC_PWR);
  339.     sstat = tcic_getb(TCIC_SSTAT);
  340.     addr = TCIC_IWIN(s, 0);
  341.     tcic_setw(TCIC_ADDR, addr + TCIC_IBASE_X);
  342.     base = tcic_getw(TCIC_DATA);
  343.     tcic_setw(TCIC_ADDR, addr + TCIC_ICTL_X);
  344.     ioctl = tcic_getw(TCIC_DATA);
  346.     if (ioctl & TCIC_ICTL_TINY)
  347. num = 1;
  348.     else {
  349. num = (base ^ (base-1));
  350. base = base & (base-1);
  351.     }
  353.     if ((sstat & TCIC_SSTAT_CD) && (pwr & TCIC_PWR_VCC(s)) &&
  354. (scf1 & TCIC_SCF1_IOSTS) && (ioctl & TCIC_ICTL_ENA) &&
  355. (check_region(base, num) != 0) && ((base & 0xfeef) != 0x02e8))
  356. return 1;
  357.     else
  358. return 0;
  359. }
  361. /*======================================================================
  363.     This returns the revision code for the specified socket.
  364.     
  365. ======================================================================*/
  367. static int __init get_tcic_id(void)
  368. {
  369.     u_short id;
  370.     
  371.     tcic_aux_setw(TCIC_AUX_TEST, TCIC_TEST_DIAG);
  372.     id = tcic_aux_getw(TCIC_AUX_ILOCK);
  373.     id = (id & TCIC_ILOCKTEST_ID_MASK) >> TCIC_ILOCKTEST_ID_SH;
  374.     tcic_aux_setw(TCIC_AUX_TEST, 0);
  375.     return id;
  376. }
  378. /*====================================================================*/
  380. static int __init init_tcic(void)
  381. {
  382.     int i, sock;
  383.     u_int mask, scan;
  384.     servinfo_t serv;
  386.     DEBUG(0, "%sn", version);
  387.     pcmcia_get_card_services_info(&serv);
  388.     if (serv.Revision != CS_RELEASE_CODE) {
  389. printk(KERN_NOTICE "tcic: Card Services release "
  390.        "does not match!n");
  391. return -1;
  392.     }
  393.     
  394.     printk(KERN_INFO "Databook TCIC-2 PCMCIA probe: ");
  395.     sock = 0;
  397.     if (check_region(tcic_base, 16) == 0) {
  398. tcic_setw(TCIC_ADDR, 0);
  399. if (tcic_getw(TCIC_ADDR) == 0) {
  400.     tcic_setw(TCIC_ADDR, 0xc3a5);
  401.     if (tcic_getw(TCIC_ADDR) == 0xc3a5) sock = 2;
  402. }
  403. if (sock == 0) {
  404.     /* See if resetting the controller does any good */
  405.     tcic_setb(TCIC_SCTRL, TCIC_SCTRL_RESET);
  406.     tcic_setb(TCIC_SCTRL, 0);
  407.     tcic_setw(TCIC_ADDR, 0);
  408.     if (tcic_getw(TCIC_ADDR) == 0) {
  409. tcic_setw(TCIC_ADDR, 0xc3a5);
  410. if (tcic_getw(TCIC_ADDR) == 0xc3a5) sock = 2;
  411.     }
  412. }
  413.     } else
  414. printk("could not allocate ports, ");
  416.     if (sock == 0) {
  417. printk("not found.n");
  418. return -ENODEV;
  419.     }
  421.     request_region(tcic_base, 16, "tcic-2");
  423.     sockets = 0;
  424.     for (i = 0; i < sock; i++) {
  425. if ((i == ignore) || is_active(i)) continue;
  426. socket_table[sockets].psock = i;
  427. socket_table[sockets].handler = NULL;
  428. socket_table[sockets].info = NULL;
  429. socket_table[sockets].id = get_tcic_id();
  430. sockets++;
  431.     }
  433.     switch (socket_table[0].id) {
  434.     case TCIC_ID_DB86082:
  435. printk("DB86082"); break;
  436.     case TCIC_ID_DB86082A:
  437. printk("DB86082A"); break;
  438.     case TCIC_ID_DB86084:
  439. printk("DB86084"); break;
  440.     case TCIC_ID_DB86084A:
  441. printk("DB86084A"); break;
  442.     case TCIC_ID_DB86072:
  443. printk("DB86072"); break;
  444.     case TCIC_ID_DB86184:
  445. printk("DB86184"); break;
  446.     case TCIC_ID_DB86082B:
  447. printk("DB86082B"); break;
  448.     default:
  449. printk("Unknown ID 0x%02x", socket_table[0].id);
  450.     }
  451.     
  452.     /* Set up polling */
  453.     poll_timer.function = &tcic_timer;
  454.     poll_timer.data = 0;
  455.     init_timer(&poll_timer);
  457.     /* Build interrupt mask */
  458.     printk(", %d socketsn" KERN_INFO "  irq list (", sockets);
  459.     if (irq_list[0] == -1)
  460. mask = irq_mask;
  461.     else
  462. for (i = mask = 0; i < 16; i++)
  463.     mask |= (1<<irq_list[i]);
  464.     mask &= tcic_cap.irq_mask;
  466.     /* Scan interrupts */
  467.     mask = irq_scan(mask);
  468.     tcic_cap.irq_mask = mask;
  469.     
  470.     /* Check for only two interrupts available */
  471.     scan = (mask & (mask-1));
  472.     if (((scan & (scan-1)) == 0) && (poll_interval == 0))
  473. poll_interval = HZ;
  474.     
  475.     if (poll_interval == 0) {
  476. /* Avoid irq 12 unless it is explicitly requested */
  477. u_int cs_mask = mask & ((cs_irq) ? (1<<cs_irq) : ~(1<<12));
  478. for (i = 15; i > 0; i--)
  479.     if ((cs_mask & (1 << i)) &&
  480. (request_irq(i, tcic_interrupt, 0, "tcic",
  481.      tcic_interrupt) == 0))
  482. break;
  483. cs_irq = i;
  484. if (cs_irq == 0) poll_interval = HZ;
  485.     }
  486.     
  487.     if (tcic_cap.irq_mask & (1 << 11))
  488. printk("sktirq is irq 11, ");
  489.     if (cs_irq != 0)
  490. printk("status change on irq %dn", cs_irq);
  491.     else
  492. printk("polled status, interval = %d msn",
  493.        poll_interval * 1000 / HZ);
  494.     
  495.     for (i = 0; i < sockets; i++) {
  496. tcic_setw(TCIC_ADDR+2, socket_table[i].psock << TCIC_SS_SHFT);
  497. socket_table[i].last_sstat = tcic_getb(TCIC_SSTAT);
  498.     }
  499.     
  500.     /* jump start interrupt handler, if needed */
  501.     tcic_interrupt(0, NULL, NULL);
  503.     if (register_ss_entry(sockets, &tcic_operations) != 0) {
  504. printk(KERN_NOTICE "tcic: register_ss_entry() failedn");
  505. release_region(tcic_base, 16);
  506. if (cs_irq != 0)
  507.     free_irq(cs_irq, tcic_interrupt);
  508. return -ENODEV;
  509.     }
  511.     return 0;
  512.     
  513. } /* init_tcic */
  515. /*====================================================================*/
  517. static void __exit exit_tcic(void)
  518. {
  519.     u_long flags;
  520.     unregister_ss_entry(&tcic_operations);
  521.     save_flags(flags);
  522.     cli();
  523.     if (cs_irq != 0) {
  524. tcic_aux_setw(TCIC_AUX_SYSCFG, TCIC_SYSCFG_AUTOBUSY|0x0a00);
  525. free_irq(cs_irq, tcic_interrupt);
  526.     }
  527.     if (tcic_timer_pending)
  528. del_timer(&poll_timer);
  529.     restore_flags(flags);
  530.     release_region(tcic_base, 16);
  531. } /* exit_tcic */
  533. /*====================================================================*/
  535. static u_int pending_events[2];
  536. static spinlock_t pending_event_lock = SPIN_LOCK_UNLOCKED;
  538. static void tcic_bh(void *dummy)
  539. {
  540. u_int events;
  541. int i;
  543. for (i=0; i < sockets; i++) {
  544. spin_lock_irq(&pending_event_lock);
  545. events = pending_events[i];
  546. pending_events[i] = 0;
  547. spin_unlock_irq(&pending_event_lock);
  548. if (socket_table[i].handler)
  549. socket_table[i].handler(socket_table[i].info, events);
  550. }
  551. }
  553. static struct tq_struct tcic_task = {
  554. routine: tcic_bh
  555. };
  557. static void tcic_interrupt(int irq, void *dev, struct pt_regs *regs)
  558. {
  559.     int i, quick = 0;
  560.     u_char latch, sstat;
  561.     u_short psock;
  562.     u_int events;
  563.     static volatile int active = 0;
  565.     if (active) {
  566. printk(KERN_NOTICE "tcic: reentered interrupt handler!n");
  567. return;
  568.     } else
  569. active = 1;
  571.     DEBUG(2, "tcic: tcic_interrupt()n");
  572.     
  573.     for (i = 0; i < sockets; i++) {
  574. psock = socket_table[i].psock;
  575. tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT)
  576.   | TCIC_ADDR_INDREG | TCIC_SCF1(psock));
  577. sstat = tcic_getb(TCIC_SSTAT);
  578. latch = sstat ^ socket_table[psock].last_sstat;
  579. socket_table[i].last_sstat = sstat;
  580. if (tcic_getb(TCIC_ICSR) & TCIC_ICSR_CDCHG) {
  581.     tcic_setb(TCIC_ICSR, TCIC_ICSR_CLEAR);
  582.     quick = 1;
  583. }
  584. if ((latch == 0) || (socket_table[psock].handler == NULL))
  585.     continue;
  586. events = (latch & TCIC_SSTAT_CD) ? SS_DETECT : 0;
  587. events |= (latch & TCIC_SSTAT_WP) ? SS_WRPROT : 0;
  588. if (tcic_getw(TCIC_DATA) & TCIC_SCF1_IOSTS) {
  589.     events |= (latch & TCIC_SSTAT_LBAT1) ? SS_STSCHG : 0;
  590. } else {
  591.     events |= (latch & TCIC_SSTAT_RDY) ? SS_READY : 0;
  592.     events |= (latch & TCIC_SSTAT_LBAT1) ? SS_BATDEAD : 0;
  593.     events |= (latch & TCIC_SSTAT_LBAT2) ? SS_BATWARN : 0;
  594. }
  595. if (events) {
  596. spin_lock(&pending_event_lock);
  597. pending_events[i] |= events;
  598. spin_unlock(&pending_event_lock);
  599. schedule_task(&tcic_task);
  600. }
  601.     }
  603.     /* Schedule next poll, if needed */
  604.     if (((cs_irq == 0) || quick) && (!tcic_timer_pending)) {
  605. poll_timer.expires = jiffies + (quick ? poll_quick : poll_interval);
  606. add_timer(&poll_timer);
  607. tcic_timer_pending = 1;
  608.     }
  609.     active = 0;
  610.     
  611.     DEBUG(2, "tcic: interrupt donen");
  612.     
  613. } /* tcic_interrupt */
  615. static void tcic_timer(u_long data)
  616. {
  617.     DEBUG(2, "tcic: tcic_timer()n");
  618.     tcic_timer_pending = 0;
  619.     tcic_interrupt(0, NULL, NULL);
  620. } /* tcic_timer */
  622. /*====================================================================*/
  624. static int tcic_register_callback(unsigned int lsock, void (*handler)(void *, unsigned int), void * info)
  625. {
  626.     socket_table[lsock].handler = handler;
  627.     socket_table[lsock].info = info;
  628.     if (handler == NULL) {
  629. MOD_DEC_USE_COUNT;
  630.     } else {
  631. MOD_INC_USE_COUNT;
  632.     }
  633.     return 0;
  634. } /* tcic_register_callback */
  636. /*====================================================================*/
  638. static int tcic_get_status(unsigned int lsock, u_int *value)
  639. {
  640.     u_short psock = socket_table[lsock].psock;
  641.     u_char reg;
  643.     tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT)
  644.       | TCIC_ADDR_INDREG | TCIC_SCF1(psock));
  645.     reg = tcic_getb(TCIC_SSTAT);
  646.     *value  = (reg & TCIC_SSTAT_CD) ? SS_DETECT : 0;
  647.     *value |= (reg & TCIC_SSTAT_WP) ? SS_WRPROT : 0;
  648.     if (tcic_getw(TCIC_DATA) & TCIC_SCF1_IOSTS) {
  649. *value |= (reg & TCIC_SSTAT_LBAT1) ? SS_STSCHG : 0;
  650.     } else {
  651. *value |= (reg & TCIC_SSTAT_RDY) ? SS_READY : 0;
  652. *value |= (reg & TCIC_SSTAT_LBAT1) ? SS_BATDEAD : 0;
  653. *value |= (reg & TCIC_SSTAT_LBAT2) ? SS_BATWARN : 0;
  654.     }
  655.     reg = tcic_getb(TCIC_PWR);
  656.     if (reg & (TCIC_PWR_VCC(psock)|TCIC_PWR_VPP(psock)))
  657. *value |= SS_POWERON;
  658.     DEBUG(1, "tcic: GetStatus(%d) = %#2.2xn", lsock, *value);
  659.     return 0;
  660. } /* tcic_get_status */
  661.   
  662. /*====================================================================*/
  664. static int tcic_inquire_socket(unsigned int lsock, socket_cap_t *cap)
  665. {
  666.     *cap = tcic_cap;
  667.     return 0;
  668. } /* tcic_inquire_socket */
  670. /*====================================================================*/
  672. static int tcic_get_socket(unsigned int lsock, socket_state_t *state)
  673. {
  674.     u_short psock = socket_table[lsock].psock;
  675.     u_char reg;
  676.     u_short scf1, scf2;
  677.     
  678.     tcic_setl(TCIC_ADDR, (psock << TCIC_ADDR_SS_SHFT)
  679.       | TCIC_ADDR_INDREG | TCIC_SCF1(psock));
  680.     scf1 = tcic_getw(TCIC_DATA);
  681.     state->flags = (scf1 & TCIC_SCF1_IOSTS) ? SS_IOCARD : 0;
  682.     state->flags |= (scf1 & TCIC_SCF1_DMA_MASK) ? SS_DMA_MODE : 0;
  683.     state->flags |= (scf1 & TCIC_SCF1_SPKR) ? SS_SPKR_ENA : 0;
  684.     if (tcic_getb(TCIC_SCTRL) & TCIC_SCTRL_ENA)
  685. state->flags |= SS_OUTPUT_ENA;
  686.     state->io_irq = scf1 & TCIC_SCF1_IRQ_MASK;
  687.     if (state->io_irq == 1) state->io_irq = 11;
  689.     reg = tcic_getb(TCIC_PWR);
  690.     state->Vcc = state->Vpp = 0;
  691.     if (reg & TCIC_PWR_VCC(psock)) {
  692. if (reg & TCIC_PWR_VPP(psock))
  693.     state->Vcc = 50;
  694. else
  695.     state->Vcc = state->Vpp = 50;
  696.     } else {
  697. if (reg & TCIC_PWR_VPP(psock)) {
  698.     state->Vcc = 50;
  699.     state->Vpp = 120;
  700. }
  701.     }
  702.     reg = tcic_aux_getb(TCIC_AUX_ILOCK);
  703.     state->flags |= (reg & TCIC_ILOCK_CRESET) ? SS_RESET : 0;
  705.     /* Card status change interrupt mask */
  706.     tcic_setw(TCIC_ADDR, TCIC_SCF2(psock));
  707.     scf2 = tcic_getw(TCIC_DATA);
  708.     state->csc_mask = (scf2 & TCIC_SCF2_MCD) ? 0 : SS_DETECT;
  709.     if (state->flags & SS_IOCARD) {
  710. state->csc_mask |= (scf2 & TCIC_SCF2_MLBAT1) ? 0 : SS_STSCHG;
  711.     } else {
  712. state->csc_mask |= (scf2 & TCIC_SCF2_MLBAT1) ? 0 : SS_BATDEAD;
  713. state->csc_mask |= (scf2 & TCIC_SCF2_MLBAT2) ? 0 : SS_BATWARN;
  714. state->csc_mask |= (scf2 & TCIC_SCF2_MRDY) ? 0 : SS_READY;
  715.     }
  717.     DEBUG(1, "tcic: GetSocket(%d) = flags %#3.3x, Vcc %d, Vpp %d, "
  718.   "io_irq %d, csc_mask %#2.2xn", lsock, state->flags,
  719.   state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
  720.     return 0;
  721. } /* tcic_get_socket */
  723. /*====================================================================*/
  725. static int tcic_set_socket(unsigned int lsock, socket_state_t *state)
  726. {
  727.     u_short psock = socket_table[lsock].psock;
  728.     u_char reg;
  729.     u_short scf1, scf2;
  731.     DEBUG(1, "tcic: SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
  732.   "io_irq %d, csc_mask %#2.2x)n", lsock, state->flags,
  733.   state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
  734.     tcic_setw(TCIC_ADDR+2, (psock << TCIC_SS_SHFT) | TCIC_ADR2_INDREG);
  736.     reg = tcic_getb(TCIC_PWR);
  737.     reg &= ~(TCIC_PWR_VCC(psock) | TCIC_PWR_VPP(psock));
  739.     if (state->Vcc == 50) {
  740. switch (state->Vpp) {
  741. case 0:   reg |= TCIC_PWR_VCC(psock) | TCIC_PWR_VPP(psock); break;
  742. case 50:  reg |= TCIC_PWR_VCC(psock); break;
  743. case 120: reg |= TCIC_PWR_VPP(psock); break;
  744. default:  return -EINVAL;
  745. }
  746.     } else if (state->Vcc != 0)
  747. return -EINVAL;
  749.     if (reg != tcic_getb(TCIC_PWR))
  750. tcic_setb(TCIC_PWR, reg);
  752.     reg = TCIC_ILOCK_HOLD_CCLK | TCIC_ILOCK_CWAIT;
  753.     if (state->flags & SS_OUTPUT_ENA) {
  754. tcic_setb(TCIC_SCTRL, TCIC_SCTRL_ENA);
  755. reg |= TCIC_ILOCK_CRESENA;
  756.     } else
  757. tcic_setb(TCIC_SCTRL, 0);
  758.     if (state->flags & SS_RESET)
  759. reg |= TCIC_ILOCK_CRESET;
  760.     tcic_aux_setb(TCIC_AUX_ILOCK, reg);
  761.     
  762.     tcic_setw(TCIC_ADDR, TCIC_SCF1(psock));
  763.     scf1 = TCIC_SCF1_FINPACK;
  764.     scf1 |= TCIC_IRQ(state->io_irq);
  765.     if (state->flags & SS_IOCARD) {
  766. scf1 |= TCIC_SCF1_IOSTS;
  767. if (state->flags & SS_SPKR_ENA)
  768.     scf1 |= TCIC_SCF1_SPKR;
  769. if (state->flags & SS_DMA_MODE)
  770.     scf1 |= TCIC_SCF1_DREQ2 << TCIC_SCF1_DMA_SHIFT;
  771.     }
  772.     tcic_setw(TCIC_DATA, scf1);
  774.     /* Some general setup stuff, and configure status interrupt */
  775.     reg = TCIC_WAIT_ASYNC | TCIC_WAIT_SENSE | to_cycles(250);
  776.     tcic_aux_setb(TCIC_AUX_WCTL, reg);
  777.     tcic_aux_setw(TCIC_AUX_SYSCFG, TCIC_SYSCFG_AUTOBUSY|0x0a00|
  778.   TCIC_IRQ(cs_irq));
  779.     
  780.     /* Card status change interrupt mask */
  781.     tcic_setw(TCIC_ADDR, TCIC_SCF2(psock));
  782.     scf2 = TCIC_SCF2_MALL;
  783.     if (state->csc_mask & SS_DETECT) scf2 &= ~TCIC_SCF2_MCD;
  784.     if (state->flags & SS_IOCARD) {
  785. if (state->csc_mask & SS_STSCHG) reg &= ~TCIC_SCF2_MLBAT1;
  786.     } else {
  787. if (state->csc_mask & SS_BATDEAD) reg &= ~TCIC_SCF2_MLBAT1;
  788. if (state->csc_mask & SS_BATWARN) reg &= ~TCIC_SCF2_MLBAT2;
  789. if (state->csc_mask & SS_READY) reg &= ~TCIC_SCF2_MRDY;
  790.     }
  791.     tcic_setw(TCIC_DATA, scf2);
  792.     /* For the ISA bus, the irq should be active-high totem-pole */
  793.     tcic_setb(TCIC_IENA, TCIC_IENA_CDCHG | TCIC_IENA_CFG_HIGH);
  795.     return 0;
  796. } /* tcic_set_socket */
  797.   
  798. /*====================================================================*/
  800. static int tcic_get_io_map(unsigned int lsock, struct pccard_io_map *io)
  801. {
  802.     u_short psock = socket_table[lsock].psock;
  803.     u_short base, ioctl;
  804.     u_int addr;
  805.     
  806.     if (io->map > 1) return -EINVAL;
  807.     tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
  808.     addr = TCIC_IWIN(psock, io->map);
  809.     tcic_setw(TCIC_ADDR, addr + TCIC_IBASE_X);
  810.     base = tcic_getw(TCIC_DATA);
  811.     tcic_setw(TCIC_ADDR, addr + TCIC_ICTL_X);
  812.     ioctl = tcic_getw(TCIC_DATA);
  814.     if (ioctl & TCIC_ICTL_TINY)
  815. io->start = io->stop = base;
  816.     else {
  817. io->start = base & (base-1);
  818. io->stop = io->start + (base ^ (base-1));
  819.     }
  820.     io->speed = to_ns(ioctl & TCIC_ICTL_WSCNT_MASK);
  821.     io->flags  = (ioctl & TCIC_ICTL_ENA) ? MAP_ACTIVE : 0;
  822.     switch (ioctl & TCIC_ICTL_BW_MASK) {
  823.     case TCIC_ICTL_BW_DYN:
  824. io->flags |= MAP_AUTOSZ; break;
  825.     case TCIC_ICTL_BW_16:
  826. io->flags |= MAP_16BIT; break;
  827.     default:
  828. break;
  829.     }
  830.     DEBUG(1, "tcic: GetIOMap(%d, %d) = %#2.2x, %d ns, "
  831.   "%#4.4x-%#4.4xn", lsock, io->map, io->flags,
  832.   io->speed, io->start, io->stop);
  833.     return 0;
  834. } /* tcic_get_io_map */
  836. /*====================================================================*/
  838. static int tcic_set_io_map(unsigned int lsock, struct pccard_io_map *io)
  839. {
  840.     u_short psock = socket_table[lsock].psock;
  841.     u_int addr;
  842.     u_short base, len, ioctl;
  843.     
  844.     DEBUG(1, "tcic: SetIOMap(%d, %d, %#2.2x, %d ns, "
  845.   "%#4.4x-%#4.4x)n", lsock, io->map, io->flags,
  846.   io->speed, io->start, io->stop);
  847.     if ((io->map > 1) || (io->start > 0xffff) || (io->stop > 0xffff) ||
  848. (io->stop < io->start)) return -EINVAL;
  849.     tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
  850.     addr = TCIC_IWIN(psock, io->map);
  852.     base = io->start; len = io->stop - io->start;
  853.     /* Check to see that len+1 is power of two, etc */
  854.     if ((len & (len+1)) || (base & len)) return -EINVAL;
  855.     base |= (len+1)>>1;
  856.     tcic_setw(TCIC_ADDR, addr + TCIC_IBASE_X);
  857.     tcic_setw(TCIC_DATA, base);
  858.     
  859.     ioctl  = (psock << TCIC_ICTL_SS_SHFT);
  860.     ioctl |= (len == 0) ? TCIC_ICTL_TINY : 0;
  861.     ioctl |= (io->flags & MAP_ACTIVE) ? TCIC_ICTL_ENA : 0;
  862.     ioctl |= to_cycles(io->speed) & TCIC_ICTL_WSCNT_MASK;
  863.     if (!(io->flags & MAP_AUTOSZ)) {
  864. ioctl |= TCIC_ICTL_QUIET;
  865. ioctl |= (io->flags & MAP_16BIT) ? TCIC_ICTL_BW_16 : TCIC_ICTL_BW_8;
  866.     }
  867.     tcic_setw(TCIC_ADDR, addr + TCIC_ICTL_X);
  868.     tcic_setw(TCIC_DATA, ioctl);
  869.     
  870.     return 0;
  871. } /* tcic_set_io_map */
  873. /*====================================================================*/
  875. static int tcic_get_mem_map(unsigned int lsock, struct pccard_mem_map *mem)
  876. {
  877.     u_short psock = socket_table[lsock].psock;
  878.     u_short addr, ctl;
  879.     u_long base, mmap;
  880.     
  881.     if (mem->map > 3) return -EINVAL;
  882.     tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
  883.     addr = TCIC_MWIN(psock, mem->map);
  884.     
  885.     tcic_setw(TCIC_ADDR, addr + TCIC_MBASE_X);
  886.     base = tcic_getw(TCIC_DATA);
  887.     if (base & TCIC_MBASE_4K_BIT) {
  888. mem->sys_start = base & TCIC_MBASE_HA_MASK;
  889. mem->sys_stop = mem->sys_start;
  890.     } else {
  891. base &= TCIC_MBASE_HA_MASK;
  892. mem->sys_start = (base & (base-1));
  893. mem->sys_stop = mem->sys_start + (base ^ (base-1));
  894.     }
  895.     mem->sys_start = mem->sys_start << TCIC_MBASE_HA_SHFT;
  896.     mem->sys_stop = (mem->sys_stop << TCIC_MBASE_HA_SHFT) + 0x0fff;
  897.     
  898.     tcic_setw(TCIC_ADDR, addr + TCIC_MMAP_X);
  899.     mmap = tcic_getw(TCIC_DATA);
  900.     mem->flags = (mmap & TCIC_MMAP_REG) ? MAP_ATTRIB : 0;
  901.     mmap &= TCIC_MMAP_CA_MASK;
  902.     mem->card_start = mem->sys_start + (mmap << TCIC_MMAP_CA_SHFT);
  903.     mem->card_start &= 0x3ffffff;
  904.     
  905.     tcic_setw(TCIC_ADDR, addr + TCIC_MCTL_X);
  906.     ctl = tcic_getw(TCIC_DATA);
  907.     mem->flags |= (ctl & TCIC_MCTL_ENA) ? MAP_ACTIVE : 0;
  908.     mem->flags |= (ctl & TCIC_MCTL_B8) ? 0 : MAP_16BIT;
  909.     mem->flags |= (ctl & TCIC_MCTL_WP) ? MAP_WRPROT : 0;
  910.     mem->speed = to_ns(ctl & TCIC_MCTL_WSCNT_MASK);
  911.     
  912.     DEBUG(1, "tcic: GetMemMap(%d, %d) = %#2.2x, %d ns, "
  913.   "%#5.5lx-%#5.5lx, %#5.5xn", lsock, mem->map, mem->flags,
  914.   mem->speed, mem->sys_start, mem->sys_stop, mem->card_start);
  915.     return 0;
  916. } /* tcic_get_mem_map */
  918. /*====================================================================*/
  919.   
  920. static int tcic_set_mem_map(unsigned int lsock, struct pccard_mem_map *mem)
  921. {
  922.     u_short psock = socket_table[lsock].psock;
  923.     u_short addr, ctl;
  924.     u_long base, len, mmap;
  926.     DEBUG(1, "tcic: SetMemMap(%d, %d, %#2.2x, %d ns, "
  927.   "%#5.5lx-%#5.5lx, %#5.5x)n", lsock, mem->map, mem->flags,
  928.   mem->speed, mem->sys_start, mem->sys_stop, mem->card_start);
  929.     if ((mem->map > 3) || (mem->card_start > 0x3ffffff) ||
  930. (mem->sys_start > 0xffffff) || (mem->sys_stop > 0xffffff) ||
  931. (mem->sys_start > mem->sys_stop) || (mem->speed > 1000))
  932. return -EINVAL;
  933.     tcic_setw(TCIC_ADDR+2, TCIC_ADR2_INDREG | (psock << TCIC_SS_SHFT));
  934.     addr = TCIC_MWIN(psock, mem->map);
  936.     base = mem->sys_start; len = mem->sys_stop - mem->sys_start;
  937.     if ((len & (len+1)) || (base & len)) return -EINVAL;
  938.     if (len == 0x0fff)
  939. base = (base >> TCIC_MBASE_HA_SHFT) | TCIC_MBASE_4K_BIT;
  940.     else
  941. base = (base | (len+1)>>1) >> TCIC_MBASE_HA_SHFT;
  942.     tcic_setw(TCIC_ADDR, addr + TCIC_MBASE_X);
  943.     tcic_setw(TCIC_DATA, base);
  944.     
  945.     mmap = mem->card_start - mem->sys_start;
  946.     mmap = (mmap >> TCIC_MMAP_CA_SHFT) & TCIC_MMAP_CA_MASK;
  947.     if (mem->flags & MAP_ATTRIB) mmap |= TCIC_MMAP_REG;
  948.     tcic_setw(TCIC_ADDR, addr + TCIC_MMAP_X);
  949.     tcic_setw(TCIC_DATA, mmap);
  951.     ctl  = TCIC_MCTL_QUIET | (psock << TCIC_MCTL_SS_SHFT);
  952.     ctl |= to_cycles(mem->speed) & TCIC_MCTL_WSCNT_MASK;
  953.     ctl |= (mem->flags & MAP_16BIT) ? 0 : TCIC_MCTL_B8;
  954.     ctl |= (mem->flags & MAP_WRPROT) ? TCIC_MCTL_WP : 0;
  955.     ctl |= (mem->flags & MAP_ACTIVE) ? TCIC_MCTL_ENA : 0;
  956.     tcic_setw(TCIC_ADDR, addr + TCIC_MCTL_X);
  957.     tcic_setw(TCIC_DATA, ctl);
  958.     
  959.     return 0;
  960. } /* tcic_set_mem_map */
  962. /*====================================================================*/
  964. static void tcic_proc_setup(unsigned int sock, struct proc_dir_entry *base)
  965. {
  966. }
  968. static int tcic_init(unsigned int s)
  969. {
  970. int i;
  971. pccard_io_map io = { 0, 0, 0, 0, 1 };
  972. pccard_mem_map mem = { 0, 0, 0, 0, 0, 0 };
  974. mem.sys_stop = 0x1000;
  975. tcic_set_socket(s, &dead_socket);
  976. for (i = 0; i < 2; i++) {
  977. io.map = i;
  978. tcic_set_io_map(s, &io);
  979. }
  980. for (i = 0; i < 5; i++) {
  981. mem.map = i;
  982. tcic_set_mem_map(s, &mem);
  983. }
  984. return 0;
  985. }
  987. static int tcic_suspend(unsigned int sock)
  988. {
  989. return tcic_set_socket(sock, &dead_socket);
  990. }
  992. static struct pccard_operations tcic_operations = {
  993. tcic_init,
  994. tcic_suspend,
  995. tcic_register_callback,
  996. tcic_inquire_socket,
  997. tcic_get_status,
  998. tcic_get_socket,
  999. tcic_set_socket,
  1000. tcic_get_io_map,
  1001. tcic_set_io_map,
  1002. tcic_get_mem_map,
  1003. tcic_set_mem_map,
  1004. tcic_proc_setup
  1005. };
  1007. /*====================================================================*/
  1009. module_init(init_tcic);
  1010. module_exit(exit_tcic);