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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
tcic.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：24k
源码类别：

VxWorks

开发平台：

C/C++

tcic.c：源码内容
  1. /* tcic.c - Databook TCIC/2 PCMCIA host bus adaptor chip driver */
  3. /* Copyright 1984-1996 Wind River Systems, Inc. */
  4. /* Copyright (c) 1994 David A. Hinds -- All Rights Reserved */
  5. #include "copyright_wrs.h"
  7. /*
  8. modification history
  9. --------------------
  10. 01f,21jun00,rsh  upgrade to dosFs 2.0
  11. 01e,29mar96,jdi  doc: fixed error.
  12. 01d,28mar96,jdi  doc: cleaned up language and format.
  13. 01c,08mar96,hdn  added more descriptions.
  14. 01b,22feb96,hdn  cleaned up
  15. 01a,03oct95,hdn  written based on David Hinds's version 2.2.3.
  16. */
  19. /*
  20. DESCRIPTION
  21. This library contains routines to manipulate the PCMCIA functions on the
  22. Databook DB86082 PCMCIA chip.  
  24. The initialization routine tcicInit() is the only global function and is
  25. included in the PCMCIA chip table `pcmciaAdapter'.  If tcicInit() finds
  26. the TCIC chip, it registers all function pointers of the PCMCIA_CHIP
  27. structure.
  29. */
  32. #include "vxWorks.h"
  33. #include "taskLib.h"
  34. #include "intLib.h"
  35. #include "sysLib.h"
  36. #include "drv/pcmcia/pcmciaLib.h"
  37. #include "drv/pcmcia/tcic.h"
  40. /* defines */
  42. #define TCIC_GETB(reg) sysInByte  (tcicBase+reg)
  43. #define TCIC_GETW(reg) sysInWord  (tcicBase+reg)
  44. #define TCIC_SETB(reg, value) sysOutByte (tcicBase+reg, value)
  45. #define TCIC_SETW(reg, value) sysOutWord (tcicBase+reg, value)
  48. /* imports */
  50. IMPORT PCMCIA_CTRL pcmciaCtrl;
  53. /* globals */
  55. int tcicBase;
  58. /* locals */
  60. LOCAL char tcicCardStatus[TCIC_MAX_SOCKS];
  61. LOCAL SEMAPHORE tcicMuteSem;
  64. /* forward declarations */
  66. LOCAL STATUS tcicReset (int sock);
  67. LOCAL int tcicStatus (int sock);
  68. LOCAL int tcicFlagGet (int sock);
  69. LOCAL STATUS tcicFlagSet (int sock, int flag);
  70. LOCAL STATUS tcicCscOn (int sock, int irq);
  71. LOCAL STATUS tcicCscOff (int sock, int irq);
  72. LOCAL int tcicCscPoll (int sock);
  73. LOCAL int tcicIrqGet (int sock);
  74. LOCAL STATUS tcicIrqSet (int sock, int irq);
  75. LOCAL STATUS tcicIowinGet (int sock, PCMCIA_IOWIN *io);
  76. LOCAL STATUS tcicIowinSet (int sock, PCMCIA_IOWIN *io);
  77. LOCAL STATUS tcicMemwinGet (int sock, PCMCIA_MEMWIN *mem);
  78. LOCAL STATUS tcicMemwinSet (int sock, PCMCIA_MEMWIN *mem);
  79. LOCAL char tcicAuxGetb (int reg);
  80. LOCAL void tcicAuxSetb (int reg, char value);
  81. #ifdef __unused__
  82. LOCAL short tcicAuxGetw (int reg);
  83. #endif
  84. LOCAL void tcicAuxSetw (int reg, short value);
  85. LOCAL long tcicGetl (int reg);
  86. LOCAL void tcicSetl (int reg, long value);
  89. /*******************************************************************************
  90. *
  91. * tcicInit - initialize the TCIC chip
  92. *
  93. * This routine initializes the TCIC chip.
  94. *
  95. * RETURNS: OK, or ERROR if the TCIC chip cannot be found.
  96. */
  98. STATUS tcicInit
  99.     (
  100.     int     ioBase, /* IO base address */
  101.     int     intVec, /* interrupt vector */
  102.     int     intLevel, /* interrupt level */
  103.     FUNCPTR showRtn /* show routine */
  104.     )
  105.     {
  106.     PCMCIA_CTRL *pCtrl = &pcmciaCtrl;
  107.     PCMCIA_CHIP *pChip = &pCtrl->chip;
  108.     int sock = 0;
  109.     int ix;
  111.     tcicBase = ioBase;
  113.     TCIC_SETW (TCIC_ADDR, 0);
  114.     if (TCIC_GETW (TCIC_ADDR) == 0)
  115. {
  116. TCIC_SETW (TCIC_ADDR, 0xc3a5);
  117. if (TCIC_GETW (TCIC_ADDR) == 0xc3a5)
  118.     sock = 2;
  119. }
  120.     
  121.     if (sock == 0)
  122. return (ERROR);
  123.     
  124.     semMInit (&tcicMuteSem, SEM_Q_PRIORITY | SEM_DELETE_SAFE | 
  125.       SEM_INVERSION_SAFE);
  126.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  128.     tcicAuxSetb (TCIC_AUX_WCTL, TCIC_WAIT_SENSE | TCIC_WAIT_ASYNC | 7);
  129.     tcicAuxSetw (TCIC_AUX_SYSCFG, TCIC_SYSCFG_AUTOBUSY | 0x0a00);
  130.     for (ix = 0; ix < sock; ix++)
  131. {
  132.         tcicSetl (TCIC_ADDR, (sock << TCIC_ADDR_SS_SHFT) | 
  133.   TCIC_ADDR_INDREG | TCIC_SCF1(sock));
  134.         tcicAuxSetb (TCIC_AUX_ILOCK, TCIC_ILOCK_HOLD_CCLK | TCIC_ILOCK_CWAIT |
  135.      TCIC_ILOCK_CRESENA);
  136.         tcicCardStatus[sock] = TCIC_GETB (TCIC_SSTAT);
  137. }
  139.     pChip->name = "Databook TCIC2";
  140.     pChip->reset = (FUNCPTR) tcicReset;
  141.     pChip->status = (FUNCPTR) tcicStatus;
  142.     pChip->flagGet = (FUNCPTR) tcicFlagGet;
  143.     pChip->flagSet = (FUNCPTR) tcicFlagSet;
  144.     pChip->cscOn = (FUNCPTR) tcicCscOn;
  145.     pChip->cscOff = (FUNCPTR) tcicCscOff;
  146.     pChip->cscPoll = (FUNCPTR) tcicCscPoll;
  147.     pChip->irqGet = (FUNCPTR) tcicIrqGet;
  148.     pChip->irqSet = (FUNCPTR) tcicIrqSet;
  149.     pChip->iowinGet = (FUNCPTR) tcicIowinGet;
  150.     pChip->iowinSet = (FUNCPTR) tcicIowinSet;
  151.     pChip->memwinGet = (FUNCPTR) tcicMemwinGet;
  152.     pChip->memwinSet = (FUNCPTR) tcicMemwinSet;
  153.     pChip->type = PCMCIA_TCIC;
  154.     pChip->socks = sock;
  155.     pChip->installed = TRUE;
  156.     pChip->intLevel = intLevel;
  157.     pChip->memWindows = TCIC_MEM_WINDOWS;
  158.     pChip->ioWindows = TCIC_IO_WINDOWS;
  159.     pChip->showRtn = showRtn;
  161.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  163.     return (OK);
  164.     }
  166. /*******************************************************************************
  167. *
  168. * tcicStatus - Get status of the socket.
  169. *
  170. * This routine gets status of the socket.
  171. * This routine can be called in interrupt level.
  172. *
  173. * RETURNS: The status of the socket.
  174. */
  176. LOCAL int tcicStatus
  177.     (
  178.     int sock /* socket no. */
  179.     )
  180.     {
  181.     BOOL intMode = intContext ();
  183.     int valueAddr = 0;
  185.     char value;
  186.     int status;
  188.     if (intMode)
  189. valueAddr = tcicGetl (TCIC_ADDR);
  190.     else
  191.         semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  193.     tcicSetl (TCIC_ADDR, (sock << TCIC_ADDR_SS_SHFT)
  194.       | TCIC_ADDR_INDREG | TCIC_SCF1(sock));
  196.     value = TCIC_GETB (TCIC_SSTAT);
  198.     status  = (value & TCIC_SSTAT_CD) ? PC_IS_CARD : PC_NO_CARD;
  199.     status |= (value & TCIC_SSTAT_WP) ? PC_WRPROT : 0;
  201.     if (TCIC_GETW (TCIC_DATA) & TCIC_SCF1_IOSTS)
  202. status |= (value & TCIC_SSTAT_LBAT1) ? PC_STSCHG : 0;
  203.     else
  204. {
  205. status |= (value & TCIC_SSTAT_RDY) ? PC_READY : 0;
  206. status |= (value & TCIC_SSTAT_LBAT1) ? PC_BATDEAD : 0;
  207. status |= (value & TCIC_SSTAT_LBAT2) ? PC_BATWARN : 0;
  208.         }
  210.     value = TCIC_GETB (TCIC_PWR);
  211.     if (value & (TCIC_PWR_VCC (sock) | TCIC_PWR_VPP (sock)))
  212. status |= PC_POWERON;
  214.     if (intMode)
  215. tcicSetl (TCIC_ADDR, valueAddr);
  216.     else
  217.         semGive (&tcicMuteSem);   /* mutual execlusion stop */
  219.     return (status);
  220.     }
  221.   
  222. /*******************************************************************************
  223. *
  224. * tcicFlagGet - Get configuration flag from the socket.
  225. *
  226. * This routine gets configuration flag from the socket.
  227. *
  228. * RETURNS: The configuration flag of the socket.
  229. */
  231. LOCAL int tcicFlagGet
  232.     (
  233.     int sock /* socket no. */
  234.     )
  235.     {
  236.     short value;
  237.     int flag;
  239.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  241.     tcicSetl (TCIC_ADDR, (sock << TCIC_ADDR_SS_SHFT) |
  242.       TCIC_ADDR_INDREG | TCIC_SCF1(sock));
  244.     flag = (TCIC_GETW (TCIC_DATA) & TCIC_SCF1_IOSTS) ? PC_IOCARD : 0;
  246.     value = TCIC_GETB (TCIC_PWR);
  247.     if (value & TCIC_PWR_VCC (sock))
  248. {
  249. if (value & TCIC_PWR_VPP (sock))
  250.     flag |= PC_VCC_5V;
  251. else
  252.     flag |= PC_VCC_5V | PC_VPP_5V;
  253. }
  254.     else
  255. if (value & TCIC_PWR_VPP (sock))
  256.     flag |= PC_VCC_5V | PC_VPP_12V;
  258.     value = tcicAuxGetb (TCIC_AUX_ILOCK);
  259.     flag |= (value & TCIC_ILOCK_CRESET) ? PC_RESET : 0;
  260.     
  261.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  263.     return (flag);
  264.     }
  266. /*******************************************************************************
  267. *
  268. * tcicFlagSet - Set configuration flag into the socket.
  269. *
  270. * This routine sets configuration flag into the socket.
  271. *
  272. * RETURNS: OK (always).
  273. */
  275. LOCAL STATUS tcicFlagSet
  276.     (
  277.     int sock, /* socket no. */
  278.     int flag /* configuration flag */
  279.     )
  280.     {
  281.     char value;
  282.     short scf1;
  283.     short scf2;
  285.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  287.     TCIC_SETW (TCIC_ADDR+2, (sock << TCIC_SS_SHFT) | TCIC_ADR2_INDREG);
  289.     value = TCIC_GETB (TCIC_PWR);
  290.     value &= ~(TCIC_PWR_VCC (sock) | TCIC_PWR_VPP (sock));
  291.     if (flag & PC_VCC_5V)
  292. {
  293. if (flag & PC_VPP_12V)
  294.     value |= TCIC_PWR_VPP (sock);
  295. else if (flag & PC_VPP_5V)
  296.     value |= TCIC_PWR_VCC (sock);
  297. else
  298.     value |= TCIC_PWR_VCC (sock) | TCIC_PWR_VPP (sock);
  299.         }
  300.     TCIC_SETB (TCIC_PWR, value);
  301.     taskDelay (sysClkRateGet () >> 4);
  303.     TCIC_SETW (TCIC_ADDR, TCIC_SCF1 (sock));
  304.     scf1 = TCIC_GETW (TCIC_DATA);
  305.     TCIC_SETW (TCIC_ADDR, TCIC_SCF2 (sock));
  306.     scf2 = TCIC_GETW (TCIC_DATA);
  307.     if (flag & PC_IOCARD) 
  308. {
  309. scf1 |= TCIC_SCF1_IOSTS | TCIC_SCF1_SPKR;
  310. scf2 |= TCIC_SCF2_MRDY;
  311.         }
  312.     else
  313. {
  314. scf1 &= ~(TCIC_SCF1_IOSTS | TCIC_SCF1_SPKR);
  315. scf2 &= ~TCIC_SCF2_MRDY;
  316.         }
  317.     TCIC_SETW (TCIC_ADDR, TCIC_SCF1 (sock));
  318.     TCIC_SETW (TCIC_DATA, scf1);
  319.     TCIC_SETW (TCIC_ADDR, TCIC_SCF2 (sock));
  320.     TCIC_SETW (TCIC_DATA, scf2);
  322.     if (flag & PC_VCC_MASK)
  323. TCIC_SETB (TCIC_SCTRL, TCIC_SCTRL_ENA);
  325.     value = tcicAuxGetb (TCIC_AUX_ILOCK) & ~TCIC_ILOCK_CRESET;
  326.     if (flag & PC_RESET)
  327. value |= TCIC_ILOCK_CRESET;
  328.     tcicAuxSetb (TCIC_AUX_ILOCK, value);
  329.     
  330.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  332.     return (OK);
  333.     }
  334.   
  335. /*******************************************************************************
  336. *
  337. * tcicCscOn - Enables card status change interrupt.
  338. *
  339. * This routine enables card status change interrupt.
  340. *
  341. * RETURNS: OK (always).
  342. */
  344. LOCAL STATUS tcicCscOn
  345.     (
  346.     int sock, /* socket no. */
  347.     int irq /* IRQ for CSC */
  348.     )
  349.     {
  350.     char value;
  351.     short scf2;
  353.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  355.     /* Turn on all card status change interrupts */
  357.     tcicSetl (TCIC_ADDR, (sock << TCIC_ADDR_SS_SHFT) | 
  358.       TCIC_ADDR_INDREG | TCIC_SCF2(sock));
  360.     value = tcicAuxGetb (TCIC_AUX_SYSCFG);
  361.     tcicAuxSetb (TCIC_AUX_SYSCFG, value | irq);
  363.     TCIC_SETB (TCIC_IENA, TCIC_IENA_CDCHG | TCIC_IENA_CFG_HIGH);
  365.     scf2 = TCIC_GETW (TCIC_DATA);
  366.     scf2 &= TCIC_SCF2_MDBR | TCIC_SCF2_IDBR | TCIC_SCF2_RI;
  367.     TCIC_SETW (TCIC_DATA, scf2);
  369.     /* flush current card status changes */
  371.     TCIC_SETB (TCIC_ICSR, TCIC_ICSR_CLEAR);
  373.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  375.     return (OK);
  376.     }
  378. /*******************************************************************************
  379. *
  380. * tcicCscOff - Disable card status change interrupt.
  381. *
  382. * This routine disables card status change interrupt.
  383. *
  384. * RETURNS: OK (always).
  385. */
  387. LOCAL STATUS tcicCscOff
  388.     (
  389.     int sock, /* socket no. */
  390.     int irq /* IRQ for CSC */
  391.     )
  392.     {
  394.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  396.     TCIC_SETW (TCIC_ADDR+2, (sock << TCIC_SS_SHFT));
  397.     TCIC_SETB (TCIC_IENA, TCIC_IENA_CFG_OFF);
  399.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  401.     return (OK);
  402.     }
  404. /*******************************************************************************
  405. *
  406. * tcicCscPoll - Get the card status by polling the register.
  407. *
  408. * This routine gets the card status by polling the register.
  409. * This routine can be called in interrupt level.
  410. *
  411. * RETURNS: The card status of the socket.
  412. */
  414. LOCAL int tcicCscPoll
  415.     (
  416.     int sock /* socket no. */
  417.     )
  418.     {
  419.     char latch  = 0;
  420.     BOOL intMode = intContext ();
  421.     char value;
  422.     int  status;
  423.     int  ix;
  424.     int  valueAddr = 0;
  425.     
  426.     if (intMode)
  427. valueAddr = tcicGetl (TCIC_ADDR);
  428.     else
  429.         semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  431.     tcicSetl (TCIC_ADDR, (sock << TCIC_ADDR_SS_SHFT) |
  432.       TCIC_ADDR_INDREG | TCIC_SCF1(sock));
  434.     for (ix = 0; ix < 10; ix++)
  435. {
  436. /* What bits have changed state? */
  438. value = TCIC_GETB (TCIC_SSTAT);
  439. latch |= value ^ tcicCardStatus[sock];
  440. tcicCardStatus[sock] = value;
  442. /* Try to reset interrupt status register */
  444. if (TCIC_GETB (TCIC_ICSR) != 0)
  445.     TCIC_SETB (TCIC_ICSR, TCIC_ICSR_CLEAR);
  446. else
  447.     break;
  448.         }
  450.     status  = (latch & TCIC_SSTAT_CD) ? PC_DETECT : 0;
  451.     status |= (latch & TCIC_SSTAT_WP) ? PC_WRPROT : 0;
  452.     if (TCIC_GETW (TCIC_DATA) & TCIC_SCF1_IOSTS)
  453. status |= (latch & TCIC_SSTAT_LBAT1) ? PC_STSCHG : 0;
  454.     else
  455. {
  456. status |= (latch & TCIC_SSTAT_RDY)   ? PC_READY : 0;
  457. status |= (latch & TCIC_SSTAT_LBAT1) ? PC_BATDEAD : 0;
  458. status |= (latch & TCIC_SSTAT_LBAT2) ? PC_BATWARN : 0;
  459.         }
  461.     if (intMode)
  462. tcicSetl (TCIC_ADDR, valueAddr);
  463.     else
  464.         semGive (&tcicMuteSem);   /* mutual execlusion stop */
  466.     return (status);
  467.     }
  469. /*******************************************************************************
  470. *
  471. * tcicIrqGet - Get IRQ level of the socket.
  472. *
  473. * This routine gets IRQ level of the socket.
  474. *
  475. * RETURNS: The IRQ level of the socket.
  476. */
  478. LOCAL int tcicIrqGet
  479.     (
  480.     int sock /* socket no. */
  481.     )
  482.     {
  483.     int value;
  485.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  487.     tcicSetl (TCIC_ADDR, (sock << TCIC_ADDR_SS_SHFT) |
  488.       TCIC_ADDR_INDREG | TCIC_SCF1(sock));
  489.     value = TCIC_GETW (TCIC_DATA) & 0x0f;
  491.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  493.     return (value);
  494.     }
  495.   
  496. /*******************************************************************************
  497. *
  498. * tcicIrqSet - Set IRQ level of the socket.
  499. *
  500. * This routine sets IRQ level of the socket.
  501. *
  502. * RETURNS: OK, or ERROR if the IRQ level is greater than 15.
  503. */
  505. LOCAL STATUS tcicIrqSet
  506.     (
  507.     int sock, /* socket no. */
  508.     int irq /* IRQ for PC card */
  509.     )
  510.     {
  511.     short scf1;
  512.     
  513.     if (irq > 15)
  514. return (ERROR);
  516.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  518.     tcicSetl (TCIC_ADDR, (sock << TCIC_ADDR_SS_SHFT) |
  519.       TCIC_ADDR_INDREG | TCIC_SCF1(sock));
  520.     
  521.     scf1 = TCIC_GETW (TCIC_DATA);
  522.     scf1 &= ~(TCIC_SCF1_IRQOC | TCIC_SCF1_IRQ_MASK);
  523.     scf1 |= irq;
  524.     TCIC_SETW (TCIC_DATA, scf1);
  525.     
  526.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  528.     return (OK);
  529.     }
  531. /*******************************************************************************
  532. *
  533. * tcicReset - Reset a card in the socket.
  534. *
  535. * This routine resets a card in the socket.
  536. *
  537. * RETURNS: OK (always).
  538. */
  540. LOCAL STATUS tcicReset
  541.     (
  542.     int sock /* socket no. */
  543.     )
  544.     {
  545.     int ix;
  546.     short value;
  547.     
  548.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  550.     /* Turn off interrupts, select memory-only interface */
  552.     tcicSetl (TCIC_ADDR, (sock << TCIC_ADDR_SS_SHFT) |
  553.       TCIC_ADDR_INDREG | TCIC_SCF1(sock));
  554.     value = TCIC_GETW (TCIC_DATA);
  555.     value &= ~(TCIC_SCF1_IRQ_MASK | TCIC_SCF1_IOSTS);
  556.     TCIC_SETW (TCIC_DATA, value);
  557.     
  558.     /* Reset event mask, since we've turned off I/O mode */
  560.     TCIC_SETW (TCIC_ADDR, TCIC_SCF2(sock));
  561.     value = TCIC_GETW (TCIC_DATA);
  562.     value &= TCIC_SCF2_MDBR | TCIC_SCF2_IDBR | TCIC_SCF2_RI;
  563.     TCIC_SETW (TCIC_DATA, value);
  564.     
  565.     /* Turn off I/O windows */
  567.     for (ix = 0; ix < 2; ix++)
  568. {
  569. TCIC_SETW (TCIC_ADDR, TCIC_IWIN(sock, ix) + TCIC_ICTL_X);
  570. TCIC_SETW (TCIC_DATA, 0);
  571.         }
  572.     
  573.     /* Turn off memory windows */
  575.     for (ix = 0; ix < 4; ix++)
  576. {
  577. TCIC_SETW (TCIC_ADDR, TCIC_MWIN(sock, ix) + TCIC_MCTL_X);
  578. TCIC_SETW (TCIC_DATA, 0);
  579.         }
  580.     
  581.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  583.     return (OK);
  584.     }
  586. /*******************************************************************************
  587. *
  588. * tcicIowinGet - Get the IO window of the socket.
  589. *
  590. * This routine gets the IO window of the socket.
  591. *
  592. * RETURNS: OK, or ERROR if the window number is greater than max windows.
  593. */
  595. LOCAL STATUS tcicIowinGet
  596.     (
  597.     int  sock, /* socket no. */
  598.     PCMCIA_IOWIN *io /* IO window structure to get */
  599.     )
  600.     {
  601.     short base;
  602.     short ioctl;
  603.     long  addr;
  604.     
  605.     if (io->window >= TCIC_IO_WINDOWS)
  606. return (ERROR);
  608.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  610.     TCIC_SETW (TCIC_ADDR+2, TCIC_ADR2_INDREG | (sock << TCIC_SS_SHFT));
  611.     addr = TCIC_IWIN(sock, io->window);
  612.     TCIC_SETW (TCIC_ADDR, addr + TCIC_IBASE_X);
  613.     base = TCIC_GETW (TCIC_DATA);
  614.     TCIC_SETW (TCIC_ADDR, addr + TCIC_ICTL_X);
  615.     ioctl = TCIC_GETW (TCIC_DATA);
  617.     if (ioctl & TCIC_ICTL_TINY)
  618. io->start = io->stop = base;
  619.     else
  620. {
  621. io->start = base & (base-1);
  622. io->stop = io->start + (base ^ (base-1));
  623.         }
  624.     io->extraws = ioctl & TCIC_ICTL_WSCNT_MASK;
  625.     io->flags = (ioctl & TCIC_ICTL_ENA) ? MAP_ACTIVE : 0;
  626.     if ((ioctl & TCIC_ICTL_BW_MASK) == TCIC_ICTL_BW_16)
  627. io->flags |= MAP_16BIT;
  629.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  631.     return (OK);
  632.     }
  634. /*******************************************************************************
  635. *
  636. * tcicIowinSet - Set the IO window of the socket.
  637. *
  638. * This routine sets the IO window of the socket.
  639. *
  640. * RETURNS: OK, or ERROR if there is an error.
  641. */
  643. LOCAL STATUS tcicIowinSet
  644.     (
  645.     int  sock, /* socket no. */
  646.     PCMCIA_IOWIN *io /* IO window structure to set */
  647.     )
  648.     {
  649.     long addr;
  650.     int base;
  651.     int len;
  652.     int ix;
  653.     short ioctl;
  654.     
  655.     if ((io->window >= TCIC_IO_WINDOWS) || (io->start > 0xffff) ||
  656. (io->stop > 0xffff) || (io->stop < io->start))
  657. return (ERROR);
  659.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  661.     TCIC_SETW (TCIC_ADDR+2, TCIC_ADR2_INDREG | (sock << TCIC_SS_SHFT));
  662.     addr = TCIC_IWIN(sock, io->window);
  663.     base = io->start;
  664.     len  = io->stop - io->start + 1;
  666.     /* adject base address according to the length */
  668.     for (ix = 0; ix < 16; ix++)
  669. if ((1 << ix) >= len)
  670.     break;
  671.     if (len != 1)
  672. {
  673. base &= ~((1 << ix) - 1);
  674. base += 1 << (ix - 1);
  675. }
  677.     TCIC_SETW (TCIC_ADDR, addr + TCIC_IBASE_X);
  678.     TCIC_SETW (TCIC_DATA, base);
  679.     
  680.     ioctl  = TCIC_ICTL_QUIET | (sock << TCIC_ICTL_SS_SHFT);
  681.     ioctl |= (len == 0) ? TCIC_ICTL_TINY : 0;
  682.     ioctl |= (io->flags & MAP_ACTIVE) ? TCIC_ICTL_ENA : 0;
  683.     ioctl |= io->extraws & TCIC_ICTL_WSCNT_MASK;
  684.     ioctl |= (io->flags & MAP_16BIT) ? TCIC_ICTL_BW_16 : TCIC_ICTL_BW_8;
  685.     TCIC_SETW (TCIC_ADDR, addr + TCIC_ICTL_X);
  686.     TCIC_SETW (TCIC_DATA, ioctl);
  687.     
  688.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  690.     return (OK);
  691.     }
  693. /*******************************************************************************
  694. *
  695. * tcicMemwinGet - Get the memory window of the socket.
  696. *
  697. * This routine gets the memory window of the socket.
  698. *
  699. * RETURNS: OK, or ERROR if the window number is greater than max windows.
  700. */
  702. LOCAL STATUS tcicMemwinGet
  703.     (
  704.     int   sock, /* socket no. */
  705.     PCMCIA_MEMWIN *mem /* memory window structure to get */
  706.     )
  707.     {
  708.     long base;
  709.     long mmap;
  710.     short addr;
  711.     short ctl;
  712.     
  713.     if (mem->window >= TCIC_MEM_WINDOWS)
  714. return (ERROR);
  716.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  718.     TCIC_SETW (TCIC_ADDR+2, TCIC_ADR2_INDREG | (sock << TCIC_SS_SHFT));
  719.     addr = TCIC_MWIN(sock, mem->window);
  720.     
  721.     TCIC_SETW (TCIC_ADDR, addr + TCIC_MBASE_X);
  722.     base = TCIC_GETW (TCIC_DATA);
  723.     if (base & TCIC_MBASE_4K_BIT)
  724. {
  725. mem->start = base & TCIC_MBASE_HA_MASK;
  726. mem->stop  = mem->start;
  727.         }
  728.     else
  729. {
  730. base &= TCIC_MBASE_HA_MASK;
  731. mem->start = (base & (base-1));
  732. mem->stop  = mem->start + (base ^ (base-1));
  733.         }
  734.     mem->start = mem->start << TCIC_MBASE_HA_SHFT;
  735.     mem->stop  = (mem->stop << TCIC_MBASE_HA_SHFT) + 0x0fff;
  736.     
  737.     TCIC_SETW (TCIC_ADDR, addr + TCIC_MMAP_X);
  738.     mmap = TCIC_GETW(TCIC_DATA);
  739.     mem->flags = (mmap & TCIC_MMAP_REG) ? MAP_ATTRIB : 0;
  740.     mmap = (base + mmap) & TCIC_MMAP_CA_MASK;
  741.     mem->cardstart = mmap << TCIC_MMAP_CA_SHFT;
  742.     
  743.     TCIC_SETW (TCIC_ADDR, addr + TCIC_MCTL_X);
  744.     ctl = TCIC_GETW (TCIC_DATA);
  745.     mem->flags |= (ctl & TCIC_MCTL_ENA) ? MAP_ACTIVE : 0;
  746.     mem->flags |= (ctl & TCIC_MCTL_B8) ? 0 : MAP_16BIT;
  747.     mem->flags |= (ctl & TCIC_MCTL_WP) ? MAP_WRPROT : 0;
  748.     mem->extraws = (ctl & TCIC_MCTL_WSCNT_MASK);
  749.     
  750.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  752.     return (OK);
  753.     }
  755. /*******************************************************************************
  756. *
  757. * tcicMemwinSet - Set the memory window of the socket.
  758. *
  759. * This routine sets the memory window of the socket.
  760. *
  761. * RETURNS: OK, or ERROR if there is an error.
  762. */
  764. LOCAL STATUS tcicMemwinSet
  765.     (
  766.     int   sock, /* socket no. */
  767.     PCMCIA_MEMWIN *mem /* memory window structure to set */
  768.     )
  769.     {
  770.     short addr;
  771.     short ctl;
  772.     long base;
  773.     long len;
  774.     long mmap;
  775.     
  776.     if ((mem->window >= TCIC_MEM_WINDOWS) || (mem->cardstart > 0xffffff) ||
  777. (mem->start > 0xffffff) || (mem->stop > 0xffffff) ||
  778. (mem->start > mem->stop) || (mem->extraws > 7))
  779. return (ERROR);
  781.     semTake (&tcicMuteSem, WAIT_FOREVER); /* mutual execlusion start */
  783.     TCIC_SETW (TCIC_ADDR+2, TCIC_ADR2_INDREG | (sock << TCIC_SS_SHFT));
  784.     addr = TCIC_MWIN(sock, mem->window);
  786.     base = mem->start & ~0xfff;
  787.     len  = (mem->stop - base) | 0xfff;
  789.     if (len == 0x0fff)
  790. base = (base >> TCIC_MBASE_HA_SHFT) | TCIC_MBASE_4K_BIT;
  791.     else
  792. base = (base | (len+1)>>1) >> TCIC_MBASE_HA_SHFT;
  793.     TCIC_SETW (TCIC_ADDR, addr + TCIC_MBASE_X);
  794.     TCIC_SETW (TCIC_DATA, base);
  795.     
  796.     mmap = (mem->cardstart >> TCIC_MMAP_CA_SHFT) - base;
  797.     mmap &= TCIC_MMAP_CA_MASK;
  798.     if (mem->flags & MAP_ATTRIB)
  799. mmap |= TCIC_MMAP_REG;
  800.     TCIC_SETW (TCIC_ADDR, addr + TCIC_MMAP_X);
  801.     TCIC_SETW (TCIC_DATA, mmap);
  803.     ctl  = TCIC_MCTL_QUIET | (sock << TCIC_MCTL_SS_SHFT);
  804.     ctl |= mem->extraws & TCIC_MCTL_WSCNT_MASK;
  805.     ctl |= (mem->flags & MAP_16BIT) ? 0 : TCIC_MCTL_B8;
  806.     ctl |= (mem->flags & MAP_WRPROT) ? TCIC_MCTL_WP : 0;
  807.     ctl |= (mem->flags & MAP_ACTIVE) ? TCIC_MCTL_ENA : 0;
  808.     TCIC_SETW (TCIC_ADDR, addr + TCIC_MCTL_X);
  809.     TCIC_SETW (TCIC_DATA, ctl);
  810.     
  811.     semGive (&tcicMuteSem);   /* mutual execlusion stop */
  813.     return (OK);
  814.     }
  816. /*******************************************************************************
  817. *
  818. * tcicSetl - Set a long word value to the register.
  819. *
  820. * This routine sets a long word value to the register.
  821. *
  822. * RETURNS: N/A
  823. */
  825. LOCAL void tcicSetl
  826.     (
  827.     int  reg, /* register no. */
  828.     long value /* value to set */
  829.     )
  830.     {
  831.     sysOutWord (tcicBase+reg,   value & 0xffff);
  832.     sysOutWord (tcicBase+reg+2, value >> 16);
  833.     }
  835. /*******************************************************************************
  836. *
  837. * tcicGetl - Get a long word value from the register.
  838. *
  839. * This routine gets a long word value from the register.
  840. *
  841. * RETURNS: A long word value of the register.
  842. */
  844. LOCAL long tcicGetl
  845.     (
  846.     int  reg /* register no. */
  847.     )
  848.     {
  849.     long value0;
  850.     long value1;
  852.     value0 = sysInWord (tcicBase+reg);
  853.     value1 = sysInWord (tcicBase+reg+2);
  855.     return ((value1 << 16) | (value0 & 0xffff));
  856.     }
  858. /*******************************************************************************
  859. *
  860. * tcicAuxGetb - Get a byte value from the aux register.
  861. *
  862. * This routine gets a byte value from the aux register.
  863. *
  864. * RETURNS: A byte value of the register.
  865. */
  867. LOCAL char tcicAuxGetb
  868.     (
  869.     int reg /* register no. */
  870.     )
  871.     {
  872.     char mode = (TCIC_GETB (TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
  874.     TCIC_SETB (TCIC_MODE, mode);
  875.     return (TCIC_GETB (TCIC_AUX));
  876.     }
  878. /*******************************************************************************
  879. *
  880. * tcicAuxSetb - Set a byte value to the aux register.
  881. *
  882. * This routine sets a byte value to the aux register.
  883. *
  884. * RETURNS: N/A
  885. */
  887. LOCAL void tcicAuxSetb
  888.     (
  889.     int  reg, /* register no. */
  890.     char value /* value to set */
  891.     )
  892.     {
  893.     char mode = (TCIC_GETB (TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
  895.     TCIC_SETB (TCIC_MODE, mode);
  896.     TCIC_SETB (TCIC_AUX, value);
  897.     }
  898. #ifdef __unused__
  900. /*******************************************************************************
  901. *
  902. * tcicAuxGetw - Get a word value from the aux register.
  903. *
  904. * This routine gets a word value from the aux register.
  905. *
  906. * RETURNS: A word value of the register.
  907. */
  909. LOCAL short tcicAuxGetw
  910.     (
  911.     int reg /* register no. */
  912.     )
  913.     {
  914.     char mode = (TCIC_GETB (TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
  916.     TCIC_SETB (TCIC_MODE, mode);
  917.     return (TCIC_GETW (TCIC_AUX));
  918.     }
  919. #endif
  921. /*******************************************************************************
  922. *
  923. * tcicAuxSetw - Set a word value to the aux register.
  924. *
  925. * This routine sets a word value to the aux register.
  926. *
  927. * RETURNS: N/A
  928. */
  930. LOCAL void tcicAuxSetw
  931.     (
  932.     int   reg, /* register no. */
  933.     short value /* value to set */
  934.     )
  935.     {
  936.     char mode = (TCIC_GETB (TCIC_MODE) & TCIC_MODE_PGMMASK) | reg;
  938.     TCIC_SETB (TCIC_MODE, mode);
  939.     TCIC_SETW (TCIC_AUX, value);
  940.     }