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

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

嵌入式Linux

开发平台：

Unix_Linux

i82092.c：源码内容
  1. /* 
  2.  * Driver for Intel I82092AA PCI-PCMCIA bridge.
  3.  *
  4.  * (C) 2001 Red Hat, Inc.
  5.  *
  6.  * Author: Arjan Van De Ven <arjanv@redhat.com>
  7.  * Loosly based on i82365.c from the pcmcia-cs package
  8.  *
  9.  * $Id: i82092aa.c,v 1.2 2001/10/23 14:43:34 arjanv Exp $
  10.  */
  12. #include <linux/kernel.h>
  13. #include <linux/config.h>
  14. #include <linux/module.h>
  15. #include <linux/pci.h>
  16. #include <linux/init.h>
  18. #include <pcmcia/cs_types.h>
  19. #include <pcmcia/ss.h>
  20. #include <pcmcia/cs.h>
  22. #include <asm/system.h>
  23. #include <asm/io.h>
  25. #include "i82092aa.h"
  26. #include "i82365.h"
  28. /* PCI core routines */
  29. static struct pci_device_id i82092aa_pci_ids[] = {
  30. {
  31.       vendor:PCI_VENDOR_ID_INTEL,
  32.       device:PCI_DEVICE_ID_INTEL_82092AA_0,
  33.       subvendor:PCI_ANY_ID,
  34.       subdevice:PCI_ANY_ID,
  35.       class: 0, class_mask:0,
  37.  },
  38.  {} 
  39. };
  41. static struct pci_driver i82092aa_pci_drv = {
  42. name:           "i82092aa",
  43. id_table:       i82092aa_pci_ids,
  44. probe:          i82092aa_pci_probe,
  45. remove:         __devexit_p(i82092aa_pci_remove),
  46. suspend:        NULL,
  47. resume:         NULL 
  48. };
  51. /* the pccard structure and its functions */
  52. static struct pccard_operations i82092aa_operations = {
  53. init:    i82092aa_init,
  54. suspend:     i82092aa_suspend,
  55. register_callback:  i82092aa_register_callback,
  56. inquire_socket: i82092aa_inquire_socket,   
  57. get_status: i82092aa_get_status,
  58. get_socket: i82092aa_get_socket,
  59. set_socket: i82092aa_set_socket,
  60. get_io_map: i82092aa_get_io_map,
  61. set_io_map: i82092aa_set_io_map,
  62. get_mem_map: i82092aa_get_mem_map,
  63. set_mem_map: i82092aa_set_mem_map,
  64. proc_setup: i82092aa_proc_setup,
  65. };
  67. /* The card can do upto 4 sockets, allocate a structure for each of them */
  69. struct socket_info {
  70. int card_state;  /*  0 = no socket,
  71.     1 = empty socket, 
  72.     2 = card but not initialized,
  73.     3 = operational card */
  74. int  io_base;  /* base io address of the socket */
  75. socket_cap_t cap;
  77. unsigned int pending_events; /* Pending events on this interface */
  79. void (*handler)(void *info, u_int events); 
  80. /* callback to the driver of the card */
  81. void *info; /* to be passed to the handler */
  83. struct pci_dev *dev; /* The PCI device for the socket */
  84. };
  86. #define MAX_SOCKETS 4
  87. static struct socket_info sockets[MAX_SOCKETS];
  88. static int socket_count;  /* shortcut */                                                                   
  91. static int __init i82092aa_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
  92. {
  93. unsigned char configbyte;
  94. int i;
  96. enter("i82092aa_pci_probe");
  98. if (pci_enable_device(dev))
  99. return -EIO;
  101. pci_read_config_byte(dev, 0x40, &configbyte);  /* PCI Configuration Control */
  102. switch(configbyte&6) {
  103. case 0:
  104. printk(KERN_INFO "i82092aa: configured as a 2 socket device.n");
  105. socket_count = 2;
  106. break;
  107. case 2:
  108. printk(KERN_INFO "i82092aa: configured as a 1 socket device.n");
  109. socket_count = 1;
  110. break;
  111. case 4:
  112. case 6:
  113. printk(KERN_INFO "i82092aa: configured as a 4 socket device.n");
  114. socket_count = 4;
  115. break;
  117. default:
  118. printk(KERN_ERR "i82092aa: Oops, you did something we didn't think of.n");
  119. return -EIO;
  120. break;
  121. }
  123. for (i = 0;i<socket_count;i++) {
  124. sockets[i].card_state = 1; /* 1 = present but empty */
  125. sockets[i].io_base = (dev->resource[0].start & ~1);
  126.  if (sockets[i].io_base > 0) 
  127.   request_region(sockets[i].io_base, 2, "i82092aa");
  128.  
  130. sockets[i].cap.features |= SS_CAP_PCCARD;
  131. sockets[i].cap.map_size = 0x1000;
  132. sockets[i].cap.irq_mask = 0;
  133. sockets[i].cap.pci_irq  = dev->irq;
  135. if (card_present(i)) {
  136. sockets[i].card_state = 3;
  137. dprintk(KERN_DEBUG "i82092aa: slot %i is occupiedn",i);
  138. } else {
  139. dprintk(KERN_DEBUG "i82092aa: slot %i is vacantn",i);
  140. }
  141. }
  143. /* Now, specifiy that all interrupts are to be done as PCI interrupts */
  144. configbyte = 0xFF; /* bitmask, one bit per event, 1 = PCI interrupt, 0 = ISA interrupt */
  145. pci_write_config_byte(dev, 0x50, configbyte); /* PCI Interrupt Routing Register */
  148. /* Register the interrupt handler */
  149. dprintk(KERN_DEBUG "Requesting interrupt %i n",dev->irq);
  150. if (request_irq(dev->irq, i82092aa_interrupt, SA_SHIRQ, "i82092aa", i82092aa_interrupt)) {
  151. printk(KERN_ERR "i82092aa: Failed to register IRQ %d, abortingn", dev->irq);
  152. return -EIO;
  153. }
  154.  
  156. if (register_ss_entry(socket_count, &i82092aa_operations) != 0)
  157. printk(KERN_NOTICE "i82092aa: register_ss_entry() failedn");
  159. leave("i82092aa_pci_probe");
  160. return 0;
  161. }
  163. static void __devexit i82092aa_pci_remove(struct pci_dev *dev)
  164. {
  165. enter("i82092aa_pci_remove");
  167. free_irq(dev->irq, i82092aa_interrupt);
  169. leave("i82092aa_pci_remove");
  170. }
  172. static spinlock_t port_lock = SPIN_LOCK_UNLOCKED;
  174. /* basic value read/write functions */
  176. static unsigned char indirect_read(int socket, unsigned short reg)
  177. {
  178. unsigned short int port;
  179. unsigned char val;
  180. unsigned long flags;
  181. spin_lock_irqsave(&port_lock,flags);
  182. reg += socket * 0x40;
  183. port = sockets[socket].io_base;
  184. outb(reg,port);
  185. val = inb(port+1);
  186. spin_unlock_irqrestore(&port_lock,flags);
  187. return val;
  188. }
  190. static unsigned short indirect_read16(int socket, unsigned short reg)
  191. {
  192. unsigned short int port;
  193. unsigned short tmp;
  194. unsigned long flags;
  195. spin_lock_irqsave(&port_lock,flags);
  196. reg  = reg + socket * 0x40;
  197. port = sockets[socket].io_base;
  198. outb(reg,port);
  199. tmp = inb(port+1);
  200. reg++;
  201. outb(reg,port);
  202. tmp = tmp | (inb(port+1)<<8);
  203. spin_unlock_irqrestore(&port_lock,flags);
  204. return tmp;
  205. }
  207. static void indirect_write(int socket, unsigned short reg, unsigned char value)
  208. {
  209. unsigned short int port;
  210. unsigned long flags;
  211. spin_lock_irqsave(&port_lock,flags);
  212. reg = reg + socket * 0x40;
  213. port = sockets[socket].io_base; 
  214. outb(reg,port);
  215. outb(value,port+1);
  216. spin_unlock_irqrestore(&port_lock,flags);
  217. }
  219. static void indirect_setbit(int socket, unsigned short reg, unsigned char mask)
  220. {
  221. unsigned short int port;
  222. unsigned char val;
  223. unsigned long flags;
  224. spin_lock_irqsave(&port_lock,flags);
  225. reg = reg + socket * 0x40;
  226. port = sockets[socket].io_base; 
  227. outb(reg,port);
  228. val = inb(port+1);
  229. val |= mask;
  230. outb(reg,port);
  231. outb(val,port+1);
  232. spin_unlock_irqrestore(&port_lock,flags);
  233. }
  236. static void indirect_resetbit(int socket, unsigned short reg, unsigned char mask)
  237. {
  238. unsigned short int port;
  239. unsigned char val;
  240. unsigned long flags;
  241. spin_lock_irqsave(&port_lock,flags);
  242. reg = reg + socket * 0x40;
  243. port = sockets[socket].io_base; 
  244. outb(reg,port);
  245. val = inb(port+1);
  246. val &= ~mask;
  247. outb(reg,port);
  248. outb(val,port+1);
  249. spin_unlock_irqrestore(&port_lock,flags);
  250. }
  252. static void indirect_write16(int socket, unsigned short reg, unsigned short value)
  253. {
  254. unsigned short int port;
  255. unsigned char val;
  256. unsigned long flags;
  257. spin_lock_irqsave(&port_lock,flags);
  258. reg = reg + socket * 0x40;
  259. port = sockets[socket].io_base; 
  261. outb(reg,port);
  262. val = value & 255;
  263. outb(val,port+1);
  265. reg++;
  267. outb(reg,port);
  268. val = value>>8;
  269. outb(val,port+1);
  270. spin_unlock_irqrestore(&port_lock,flags);
  271. }
  273. /* simple helper functions */
  274. /* External clock time, in nanoseconds.  120 ns = 8.33 MHz */
  275. static int cycle_time = 120;
  277. static int to_cycles(int ns)
  278. {
  279. if (cycle_time!=0)
  280. return ns/cycle_time;
  281. else
  282. return 0;
  283. }
  284.     
  285. static int to_ns(int cycles)
  286. {
  287. return cycle_time*cycles;
  288. }
  291. /* Interrupt handler functionality */
  293. static void i82092aa_bh(void *dummy)
  294. {
  295.         unsigned int events;
  296. int i;
  297.                 
  298.         for (i=0; i < socket_count; i++) {
  299.          events = xchg(&(sockets[i].pending_events),0);
  300.          printk("events = %x n",events);
  301.                 if (sockets[i].handler)
  302.                  sockets[i].handler(sockets[i].info, events);
  303. }
  304. }
  305.                                                                                                                                         
  307. static struct tq_struct i82092aa_task = {
  308.         routine:        i82092aa_bh
  309. };
  310.         
  312. static void i82092aa_interrupt(int irq, void *dev, struct pt_regs *regs)
  313. {
  314. int i;
  315. int loopcount = 0;
  317. unsigned int events, active=0;
  319. /* enter("i82092aa_interrupt");*/
  321. while (1) {
  322. loopcount++;
  323. if (loopcount>20) {
  324. printk(KERN_ERR "i82092aa: infinite eventloop in interrupt n");
  325. break;
  326. }
  328. active = 0;
  330. for (i=0;i<socket_count;i++) {
  331. int csc;
  332. if (sockets[i].card_state==0) /* Inactive socket, should not happen */
  333. continue;
  335. csc = indirect_read(i,I365_CSC); /* card status change register */
  337. if ((csc==0) ||  /* no events on this socket */
  338.    (sockets[i].handler==NULL)) /* no way to handle events */
  339.     continue;
  340. events = 0;
  341.  
  342. if (csc & I365_CSC_DETECT) {
  343. events |= SS_DETECT;
  344. printk("Card detected in socket %i!n",i);
  345.  }
  347. if (indirect_read(i,I365_INTCTL) & I365_PC_IOCARD) { 
  348. /* For IO/CARDS, bit 0 means "read the card" */
  349. events |= (csc & I365_CSC_STSCHG) ? SS_STSCHG : 0; 
  350. } else {
  351. /* Check for battery/ready events */
  352. events |= (csc & I365_CSC_BVD1) ? SS_BATDEAD : 0;
  353. events |= (csc & I365_CSC_BVD2) ? SS_BATWARN : 0;
  354. events |= (csc & I365_CSC_READY) ? SS_READY : 0;
  355. }
  357. if (events) {
  358. sockets[i].pending_events |= events;
  359. schedule_task(&i82092aa_task);
  360. }
  361. active |= events;
  362. }
  364. if (active==0) /* no more events to handle */
  365. break;
  367. }
  369. /* leave("i82092aa_interrupt");*/
  370. }
  374. /* socket functions */
  376. static int card_present(int socketno)
  377. {
  378. unsigned int val;
  379. enter("card_present");
  381. if ((socketno<0) || (socketno > MAX_SOCKETS))
  382. return 0;
  383. if (sockets[socketno].io_base == 0)
  384. return 0;
  387. val = indirect_read(socketno, 1); /* Interface status register */
  388. if ((val&12)==12) {
  389. leave("card_present 1");
  390. return 1;
  391. }
  393. leave("card_present 0");
  394. return 0;
  395. }
  397. static void set_bridge_state(int sock)
  398. {
  399. enter("set_bridge_state");
  400. indirect_write(sock, I365_GBLCTL,0x00);
  401. indirect_write(sock, I365_GENCTL,0x00);
  403. indirect_setbit(sock, I365_INTCTL,0x08);
  404. leave("set_bridge_state");
  405. }
  411.       
  412. static int i82092aa_init(unsigned int s)
  413. {
  414. int i;
  415.         pccard_io_map io = { 0, 0, 0, 0, 1 };
  416.         pccard_mem_map mem = { 0, 0, 0, 0, 0, 0 };
  417.         
  418.         enter("i82092aa_init");
  419.                         
  420.         mem.sys_stop = 0x0fff;
  421.         i82092aa_set_socket(s, &dead_socket);
  422.         for (i = 0; i < 2; i++) {
  423.          io.map = i;
  424.                 i82092aa_set_io_map(s, &io);
  425. }
  426.         for (i = 0; i < 5; i++) {
  427.          mem.map = i;
  428.                 i82092aa_set_mem_map(s, &mem);
  429. }
  431. leave("i82092aa_init");
  432. return 0;
  433. }
  434.                                                                                                                                                                                                                                               
  435. static int i82092aa_suspend(unsigned int sock)
  436. {
  437. int retval;
  438. enter("i82092aa_suspend");
  439.         retval =  i82092aa_set_socket(sock, &dead_socket);
  440.         leave("i82092aa_suspend");
  441.         return retval;
  442. }
  443.        
  444. static int i82092aa_register_callback(unsigned int sock, void (*handler)(void *, unsigned int), void * info)
  445. {
  446. enter("i82092aa_register_callback");
  447. sockets[sock].handler = handler;
  448.         sockets[sock].info = info;
  449.         if (handler == NULL) {   
  450.          MOD_DEC_USE_COUNT;   
  451.   } else {
  452. MOD_INC_USE_COUNT;
  453. }
  454. leave("i82092aa_register_callback");
  455. return 0;
  456. } /* i82092aa_register_callback */
  457.                                         
  458. static int i82092aa_inquire_socket(unsigned int sock, socket_cap_t *cap)
  459. {
  460. enter("i82092aa_inquire_socket");
  461. *cap = sockets[sock].cap;
  462. leave("i82092aa_inquire_socket");
  463. return 0;
  464. } /* i82092aa_inquire_socket */
  467. static int i82092aa_get_status(unsigned int sock, u_int *value)
  468. {
  469. unsigned int status;
  471. enter("i82092aa_get_status");
  473. status = indirect_read(sock,I365_STATUS); /* Interface Status Register */
  474. *value = 0;
  476. if ((status & I365_CS_DETECT) == I365_CS_DETECT) {
  477. *value |= SS_DETECT;
  478. }
  480. /* IO cards have a different meaning of bits 0,1 */
  481. /* Also notice the inverse-logic on the bits */
  482.  if (indirect_read(sock, I365_INTCTL) & I365_PC_IOCARD) {
  483.   /* IO card */
  484.   if (!(status & I365_CS_STSCHG))
  485.   *value |= SS_STSCHG;
  486.  } else { /* non I/O card */
  487.   if (!(status & I365_CS_BVD1))
  488.   *value |= SS_BATDEAD;
  489.   if (!(status & I365_CS_BVD2))
  490.   *value |= SS_BATWARN;
  491.  
  492.  }
  493.  
  494.  if (status & I365_CS_WRPROT)
  495.   (*value) |= SS_WRPROT; /* card is write protected */
  496.  
  497.  if (status & I365_CS_READY)
  498.   (*value) |= SS_READY;    /* card is not busy */
  499.  
  500.  if (status & I365_CS_POWERON)
  501.   (*value) |= SS_POWERON;  /* power is applied to the card */
  504. leave("i82092aa_get_status");
  505. return 0;
  506. }
  509. static int i82092aa_get_socket(unsigned int sock, socket_state_t *state) 
  510. {
  511. unsigned char reg,vcc,vpp;
  513. enter("i82092aa_get_socket");
  514. state->flags    = 0;
  515. state->Vcc      = 0;
  516. state->Vpp      = 0;
  517. state->io_irq   = 0;
  518. state->csc_mask = 0;
  520. /* First the power status of the socket */
  521. reg = indirect_read(sock,I365_POWER); /* PCTRL - Power Control Register */
  523. if (reg & I365_PWR_AUTO)
  524. state->flags |= SS_PWR_AUTO;  /* Automatic Power Switch */
  526. if (reg & I365_PWR_OUT)
  527. state->flags |= SS_OUTPUT_ENA; /* Output signals are enabled */
  529. vcc = reg & I365_VCC_MASK;    vpp = reg & I365_VPP1_MASK;
  531. if (reg & I365_VCC_5V) { /* Can still be 3.3V, in this case the Vcc value will be overwritten later */
  532. state->Vcc = 50;
  534. if (vpp == I365_VPP1_5V)
  535. state->Vpp = 50;
  536. if (vpp == I365_VPP1_12V)
  537. state->Vpp = 120;
  539. }
  541. if ((reg & I365_VCC_3V)==I365_VCC_3V)
  542. state->Vcc = 33;
  545. /* Now the IO card, RESET flags and IO interrupt */
  547. reg = indirect_read(sock, I365_INTCTL); /* IGENC, Interrupt and General Control */
  549. if ((reg & I365_PC_RESET)==0)
  550. state->flags |= SS_RESET;
  551. if (reg & I365_PC_IOCARD) 
  552. state->flags |= SS_IOCARD; /* This is an IO card */
  554. /* Set the IRQ number */
  555. if (sockets[sock].dev!=NULL)
  556. state->io_irq = sockets[sock].dev->irq;
  558. /* Card status change */
  559. reg = indirect_read(sock, I365_CSCINT); /* CSCICR, Card Status Change Interrupt Configuration */
  561. if (reg & I365_CSC_DETECT) 
  562. state->csc_mask |= SS_DETECT; /* Card detect is enabled */
  564. if (state->flags & SS_IOCARD) {/* IO Cards behave different */
  565. if (reg & I365_CSC_STSCHG)
  566. state->csc_mask |= SS_STSCHG;
  567. } else {
  568. if (reg & I365_CSC_BVD1) 
  569. state->csc_mask |= SS_BATDEAD;
  570. if (reg & I365_CSC_BVD2) 
  571. state->csc_mask |= SS_BATWARN;
  572. if (reg & I365_CSC_READY) 
  573. state->csc_mask |= SS_READY;
  574. }
  576. leave("i82092aa_get_socket");
  577. return 0;
  578. }
  580. static int i82092aa_set_socket(unsigned int sock, socket_state_t *state) 
  581. {
  582. unsigned char reg;
  584. enter("i82092aa_set_socket");
  586. /* First, set the global controller options */
  588. set_bridge_state(sock);
  590. /* Values for the IGENC register */
  592. reg = 0;
  593. if (!(state->flags & SS_RESET))  /* The reset bit has "inverse" logic */
  594. reg = reg | I365_PC_RESET;  
  595. if (state->flags & SS_IOCARD) 
  596. reg = reg | I365_PC_IOCARD;
  598. indirect_write(sock,I365_INTCTL,reg); /* IGENC, Interrupt and General Control Register */
  600. /* Power registers */
  602. reg = I365_PWR_NORESET; /* default: disable resetdrv on resume */
  604. if (state->flags & SS_PWR_AUTO) {
  605. printk("Auto powern");
  606. reg |= I365_PWR_AUTO; /* automatic power mngmnt */
  607. }
  608. if (state->flags & SS_OUTPUT_ENA) {
  609. printk("Power Enabled n");
  610. reg |= I365_PWR_OUT; /* enable power */
  611. }
  613. switch (state->Vcc) {
  614. case 0:
  615. break;
  616. case 50: 
  617. printk("setting voltage to Vcc to 5V on socket %in",sock);
  618. reg |= I365_VCC_5V;
  619. break;
  620. default:
  621. printk("i82092aa: i82092aa_set_socket called with invalid VCC power value: %i ", state->Vcc);
  622. leave("i82092aa_set_socket");
  623. return -EINVAL;
  624. }
  627. switch (state->Vpp) {
  628. case 0:
  629. printk("not setting Vpp on socket %in",sock);
  630. break;
  631. case 50: 
  632. printk("setting Vpp to 5.0 for socket %in",sock);
  633. reg |= I365_VPP1_5V | I365_VPP2_5V;
  634. break;
  635. case 120: 
  636. printk("setting Vpp to 12.0n");
  637. reg |= I365_VPP1_12V | I365_VPP2_12V;
  638. break;
  639. default:
  640. printk("i82092aa: i82092aa_set_socket called with invalid VPP power value: %i ", state->Vcc);
  641. leave("i82092aa_set_socket");
  642. return -EINVAL;
  643. }
  645. if (reg != indirect_read(sock,I365_POWER)) /* only write if changed */
  646. indirect_write(sock,I365_POWER,reg);
  648. /* Enable specific interrupt events */
  650. reg = 0x00;
  651. if (state->csc_mask & SS_DETECT) {
  652. reg |= I365_CSC_DETECT;
  653. }
  654. if (state->flags & SS_IOCARD) {
  655. if (state->csc_mask & SS_STSCHG)
  656. reg |= I365_CSC_STSCHG;
  657. } else {
  658. if (state->csc_mask & SS_BATDEAD) 
  659. reg |= I365_CSC_BVD1;
  660. if (state->csc_mask & SS_BATWARN) 
  661. reg |= I365_CSC_BVD2;
  662. if (state->csc_mask & SS_READY) 
  663. reg |= I365_CSC_READY; 
  664.                         
  665. }
  667. /* now write the value and clear the (probably bogus) pending stuff by doing a dummy read*/
  669. indirect_write(sock,I365_CSCINT,reg);
  670. (void)indirect_read(sock,I365_CSC);
  672. leave("i82092aa_set_socket");
  673. return 0;
  674. }
  676. static int i82092aa_get_io_map(unsigned int sock, struct pccard_io_map *io)
  677. {
  678. unsigned char map, ioctl, addr;
  680. enter("i82092aa_get_io_map");
  681. map = io->map;
  682. if (map > 1) {
  683. leave("i82092aa_get_io_map with -EINVAL");
  684. return -EINVAL;
  685. }
  687. /* FIXME: How does this fit in with the PCI resource (re)allocation */
  688. io->start = indirect_read16(sock, I365_IO(map)+I365_W_START);
  689. io->stop  = indirect_read16(sock, I365_IO(map)+I365_W_START);
  691. ioctl = indirect_read(sock,I365_IOCTL); /* IOCREG: I/O Control Register */
  692. addr  = indirect_read(sock,I365_ADDRWIN); /* */
  694. io->speed = to_ns(ioctl & I365_IOCTL_WAIT(map)) ? 1 : 0; /* check this out later */
  695. io->flags = 0;
  697. if (addr & I365_IOCTL_16BIT(map))
  698. io->flags |= MAP_AUTOSZ;
  700. leave("i82092aa_get_io_map");
  701. return 0;
  702. }
  704. static int i82092aa_set_io_map(unsigned sock, struct pccard_io_map *io)
  705. {
  706. unsigned char map, ioctl;
  708. enter("i82092aa_set_io_map");
  710. map = io->map;
  712. /* Check error conditions */
  713. if (map > 1) {
  714. leave("i82092aa_set_io_map with invalid map");
  715. return -EINVAL;
  716. }
  717. if ((io->start > 0xffff) || (io->stop > 0xffff) || (io->stop < io->start)){
  718. leave("i82092aa_set_io_map with invalid io");
  719. return -EINVAL;
  720. }
  722. /* Turn off the window before changing anything */ 
  723. if (indirect_read(sock, I365_ADDRWIN) & I365_ENA_IO(map))
  724. indirect_resetbit(sock, I365_ADDRWIN, I365_ENA_IO(map));
  726. /* printk("set_io_map: Setting range to %x - %x n",io->start,io->stop);  */
  728. /* write the new values */
  729. indirect_write16(sock,I365_IO(map)+I365_W_START,io->start);            
  730. indirect_write16(sock,I365_IO(map)+I365_W_STOP,io->stop);            
  731.             
  732. ioctl = indirect_read(sock,I365_IOCTL) & ~I365_IOCTL_MASK(map);
  734. if (io->flags & (MAP_16BIT|MAP_AUTOSZ))
  735. ioctl |= I365_IOCTL_16BIT(map);
  737. indirect_write(sock,I365_IOCTL,ioctl);
  739. /* Turn the window back on if needed */
  740. if (io->flags & MAP_ACTIVE)
  741. indirect_setbit(sock,I365_ADDRWIN,I365_ENA_IO(map));
  743. leave("i82092aa_set_io_map");
  744. return 0;
  745. }
  747. static int i82092aa_get_mem_map(unsigned sock, struct pccard_mem_map *mem)
  748. {
  749. unsigned short base, i;
  750. unsigned char map, addr;
  752. enter("i82092aa_get_mem_map");
  754. mem->flags = 0;
  755. mem->speed = 0;
  756. map = mem->map;
  757. if (map > 4) {
  758. leave("i82092aa_get_mem_map: -EINVAL");
  759. return -EINVAL;
  760. }
  762. addr = indirect_read(sock, I365_ADDRWIN);
  764. if (addr & I365_ENA_MEM(map))
  765. mem->flags |= MAP_ACTIVE; /* yes this mapping is active */
  767. base = I365_MEM(map); 
  769. /* Find the start address - this register also has mapping info */
  771. i = indirect_read16(sock,base+I365_W_START);
  772. if (i & I365_MEM_16BIT)
  773. mem->flags |= MAP_16BIT;
  774. if (i & I365_MEM_0WS)
  775. mem->flags |= MAP_0WS;
  777. mem->sys_start = ((unsigned long)(i & 0x0fff) << 12);
  779. /* Find the end address - this register also has speed info */
  780. i = indirect_read16(sock,base+I365_W_STOP);
  781. if (i & I365_MEM_WS0)
  782. mem->speed = 1;
  783. if (i & I365_MEM_WS1)
  784. mem->speed += 2;
  785. mem->speed = to_ns(mem->speed);
  786. mem->sys_stop = ( (unsigned long)(i & 0x0fff) << 12) + 0x0fff;
  788. /* Find the card start address, also some more MAP attributes */
  790. i = indirect_read16(sock, base+I365_W_OFF);
  791. if (i & I365_MEM_WRPROT)
  792. mem->flags |= MAP_WRPROT;
  793. if (i & I365_MEM_REG)
  794. mem->flags |= MAP_ATTRIB;
  795. mem->card_start = ( (unsigned long)(i & 0x3fff)<12) + mem->sys_start;
  796. mem->card_start &=  0x3ffffff;
  798. printk("Card %i is from %lx to %lx n",sock,mem->sys_start,mem->sys_stop);
  800. leave("i82092aa_get_mem_map");
  801. return 0;
  803. }
  805. static int i82092aa_set_mem_map(unsigned sock, struct pccard_mem_map *mem)
  806. {
  807. unsigned short base, i;
  808. unsigned char map;
  810. enter("i82092aa_set_mem_map");
  812. map = mem->map;
  813. if (map > 4) {
  814. leave("i82092aa_set_mem_map: invalid map");
  815. return -EINVAL;
  816. }
  819. if ( (mem->card_start > 0x3ffffff) || (mem->sys_start > mem->sys_stop) ||
  820.      (mem->speed > 1000) ) {
  821. leave("i82092aa_set_mem_map: invalid address / speed");
  822. printk("invalid mem map for socket %i : %lx to %lx with a start of %x n",sock,mem->sys_start, mem->sys_stop, mem->card_start);
  823. return -EINVAL;
  824. }
  826. /* Turn off the window before changing anything */
  827. if (indirect_read(sock, I365_ADDRWIN) & I365_ENA_MEM(map))
  828.               indirect_resetbit(sock, I365_ADDRWIN, I365_ENA_MEM(map));
  829.                  
  830.                  
  831. /*  printk("set_mem_map: Setting map %i range to %x - %x on socket %i, speed is %i, active = %i n",map, mem->sys_start,mem->sys_stop,sock,mem->speed,mem->flags & MAP_ACTIVE);  */
  833. /* write the start address */
  834. base = I365_MEM(map);
  835. i = (mem->sys_start >> 12) & 0x0fff;
  836. if (mem->flags & MAP_16BIT) 
  837. i |= I365_MEM_16BIT;
  838. if (mem->flags & MAP_0WS)
  839. i |= I365_MEM_0WS;
  840. indirect_write16(sock,base+I365_W_START,i);
  841.                
  842. /* write the stop address */
  844. i= (mem->sys_stop >> 12) & 0x0fff;
  845. switch (to_cycles(mem->speed)) {
  846. case 0:
  847. break;
  848. case 1:
  849. i |= I365_MEM_WS0;
  850. break;
  851. case 2:
  852. i |= I365_MEM_WS1;
  853. break;
  854. default:
  855. i |= I365_MEM_WS1 | I365_MEM_WS0;
  856. break;
  857. }
  859. indirect_write16(sock,base+I365_W_STOP,i);
  861. /* card start */
  863. i = ((mem->card_start - mem->sys_start) >> 12) & 0x3fff;
  864. if (mem->flags & MAP_WRPROT)
  865. i |= I365_MEM_WRPROT;
  866. if (mem->flags & MAP_ATTRIB) {
  867. /* printk("requesting attribute memory for socket %in",sock);*/
  868. i |= I365_MEM_REG;
  869. } else {
  870. /* printk("requesting normal memory for socket %in",sock);*/
  871. }
  872. indirect_write16(sock,base+I365_W_OFF,i);
  874. /* Enable the window if necessary */
  875. if (mem->flags & MAP_ACTIVE)
  876. indirect_setbit(sock, I365_ADDRWIN, I365_ENA_MEM(map));
  877.             
  878. leave("i82092aa_set_mem_map");
  879. return 0;
  880. }
  882. static void i82092aa_proc_setup(unsigned int sock, struct proc_dir_entry *base)
  883. {
  885. }
  886. /* Module stuff */
  888. static int i82092aa_module_init(void)
  889. {
  890. enter("i82092aa_module_init");
  891. pci_register_driver(&i82092aa_pci_drv);
  892. leave("i82092aa_module_init");
  893. return 0;
  894. }
  896. static void i82092aa_module_exit(void)
  897. {
  898. enter("i82092aa_module_exit");
  899. pci_unregister_driver(&i82092aa_pci_drv);
  900. unregister_ss_entry(&i82092aa_operations);
  901. if (sockets[0].io_base>0)
  902.  release_region(sockets[0].io_base, 2);
  903. leave("i82092aa_module_exit");
  904. }
  906. module_init(i82092aa_module_init);
  907. module_exit(i82092aa_module_exit);