LCOV - code coverage report
Current view: top level - drivers/pcmcia - yenta_socket.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 1 557 0.2 %
Date: 2022-04-01 14:17:54 Functions: 1 26 3.8 %
Branches: 0 286 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * Regular cardbus driver ("yenta_socket")
       4                 :            :  *
       5                 :            :  * (C) Copyright 1999, 2000 Linus Torvalds
       6                 :            :  *
       7                 :            :  * Changelog:
       8                 :            :  * Aug 2002: Manfred Spraul <manfred@colorfullife.com>
       9                 :            :  *      Dynamically adjust the size of the bridge resource
      10                 :            :  *
      11                 :            :  * May 2003: Dominik Brodowski <linux@brodo.de>
      12                 :            :  *      Merge pci_socket.c and yenta.c into one file
      13                 :            :  */
      14                 :            : #include <linux/init.h>
      15                 :            : #include <linux/pci.h>
      16                 :            : #include <linux/workqueue.h>
      17                 :            : #include <linux/interrupt.h>
      18                 :            : #include <linux/delay.h>
      19                 :            : #include <linux/module.h>
      20                 :            : #include <linux/io.h>
      21                 :            : #include <linux/slab.h>
      22                 :            : 
      23                 :            : #include <pcmcia/ss.h>
      24                 :            : 
      25                 :            : #include "yenta_socket.h"
      26                 :            : #include "i82365.h"
      27                 :            : 
      28                 :            : static bool disable_clkrun;
      29                 :            : module_param(disable_clkrun, bool, 0444);
      30                 :            : MODULE_PARM_DESC(disable_clkrun,
      31                 :            :                  "If PC card doesn't function properly, please try this option (TI and Ricoh bridges only)");
      32                 :            : 
      33                 :            : static bool isa_probe = 1;
      34                 :            : module_param(isa_probe, bool, 0444);
      35                 :            : MODULE_PARM_DESC(isa_probe, "If set ISA interrupts are probed (default). Set to N to disable probing");
      36                 :            : 
      37                 :            : static bool pwr_irqs_off;
      38                 :            : module_param(pwr_irqs_off, bool, 0644);
      39                 :            : MODULE_PARM_DESC(pwr_irqs_off, "Force IRQs off during power-on of slot. Use only when seeing IRQ storms!");
      40                 :            : 
      41                 :            : static char o2_speedup[] = "default";
      42                 :            : module_param_string(o2_speedup, o2_speedup, sizeof(o2_speedup), 0444);
      43                 :            : MODULE_PARM_DESC(o2_speedup, "Use prefetch/burst for O2-bridges: 'on', 'off' "
      44                 :            :         "or 'default' (uses recommended behaviour for the detected bridge)");
      45                 :            : 
      46                 :            : /*
      47                 :            :  * Only probe "regular" interrupts, don't
      48                 :            :  * touch dangerous spots like the mouse irq,
      49                 :            :  * because there are mice that apparently
      50                 :            :  * get really confused if they get fondled
      51                 :            :  * too intimately.
      52                 :            :  *
      53                 :            :  * Default to 11, 10, 9, 7, 6, 5, 4, 3.
      54                 :            :  */
      55                 :            : static u32 isa_interrupts = 0x0ef8;
      56                 :            : 
      57                 :            : 
      58                 :            : #define debug(x, s, args...) dev_dbg(&s->dev->dev, x, ##args)
      59                 :            : 
      60                 :            : /* Don't ask.. */
      61                 :            : #define to_cycles(ns)   ((ns)/120)
      62                 :            : #define to_ns(cycles)   ((cycles)*120)
      63                 :            : 
      64                 :            : /*
      65                 :            :  * yenta PCI irq probing.
      66                 :            :  * currently only used in the TI/EnE initialization code
      67                 :            :  */
      68                 :            : #ifdef CONFIG_YENTA_TI
      69                 :            : static int yenta_probe_cb_irq(struct yenta_socket *socket);
      70                 :            : static unsigned int yenta_probe_irq(struct yenta_socket *socket,
      71                 :            :                                 u32 isa_irq_mask);
      72                 :            : #endif
      73                 :            : 
      74                 :            : 
      75                 :            : static unsigned int override_bios;
      76                 :            : module_param(override_bios, uint, 0000);
      77                 :            : MODULE_PARM_DESC(override_bios, "yenta ignore bios resource allocation");
      78                 :            : 
      79                 :            : /*
      80                 :            :  * Generate easy-to-use ways of reading a cardbus sockets
      81                 :            :  * regular memory space ("cb_xxx"), configuration space
      82                 :            :  * ("config_xxx") and compatibility space ("exca_xxxx")
      83                 :            :  */
      84                 :          0 : static inline u32 cb_readl(struct yenta_socket *socket, unsigned reg)
      85                 :            : {
      86                 :          0 :         u32 val = readl(socket->base + reg);
      87                 :          0 :         debug("%04x %08x\n", socket, reg, val);
      88                 :          0 :         return val;
      89                 :            : }
      90                 :            : 
      91                 :          0 : static inline void cb_writel(struct yenta_socket *socket, unsigned reg, u32 val)
      92                 :            : {
      93                 :          0 :         debug("%04x %08x\n", socket, reg, val);
      94                 :          0 :         writel(val, socket->base + reg);
      95                 :          0 :         readl(socket->base + reg); /* avoid problems with PCI write posting */
      96                 :          0 : }
      97                 :            : 
      98                 :          0 : static inline u8 config_readb(struct yenta_socket *socket, unsigned offset)
      99                 :            : {
     100                 :          0 :         u8 val;
     101                 :          0 :         pci_read_config_byte(socket->dev, offset, &val);
     102                 :          0 :         debug("%04x %02x\n", socket, offset, val);
     103   [ #  #  #  #  :          0 :         return val;
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     104                 :            : }
     105                 :            : 
     106                 :          0 : static inline u16 config_readw(struct yenta_socket *socket, unsigned offset)
     107                 :            : {
     108                 :          0 :         u16 val;
     109                 :          0 :         pci_read_config_word(socket->dev, offset, &val);
     110                 :          0 :         debug("%04x %04x\n", socket, offset, val);
     111   [ #  #  #  # ]:          0 :         return val;
     112                 :            : }
     113                 :            : 
     114                 :          0 : static inline u32 config_readl(struct yenta_socket *socket, unsigned offset)
     115                 :            : {
     116                 :          0 :         u32 val;
     117                 :          0 :         pci_read_config_dword(socket->dev, offset, &val);
     118                 :          0 :         debug("%04x %08x\n", socket, offset, val);
     119   [ #  #  #  #  :          0 :         return val;
             #  #  #  # ]
     120                 :            : }
     121                 :            : 
     122                 :          0 : static inline void config_writeb(struct yenta_socket *socket, unsigned offset, u8 val)
     123                 :            : {
     124                 :          0 :         debug("%04x %02x\n", socket, offset, val);
     125                 :          0 :         pci_write_config_byte(socket->dev, offset, val);
     126                 :          0 : }
     127                 :            : 
     128                 :          0 : static inline void config_writew(struct yenta_socket *socket, unsigned offset, u16 val)
     129                 :            : {
     130                 :          0 :         debug("%04x %04x\n", socket, offset, val);
     131                 :          0 :         pci_write_config_word(socket->dev, offset, val);
     132                 :          0 : }
     133                 :            : 
     134                 :          0 : static inline void config_writel(struct yenta_socket *socket, unsigned offset, u32 val)
     135                 :            : {
     136                 :          0 :         debug("%04x %08x\n", socket, offset, val);
     137                 :          0 :         pci_write_config_dword(socket->dev, offset, val);
     138                 :          0 : }
     139                 :            : 
     140                 :          0 : static inline u8 exca_readb(struct yenta_socket *socket, unsigned reg)
     141                 :            : {
     142                 :          0 :         u8 val = readb(socket->base + 0x800 + reg);
     143                 :          0 :         debug("%04x %02x\n", socket, reg, val);
     144   [ #  #  #  #  :          0 :         return val;
             #  #  #  # ]
     145                 :            : }
     146                 :            : 
     147                 :            : static inline u8 exca_readw(struct yenta_socket *socket, unsigned reg)
     148                 :            : {
     149                 :            :         u16 val;
     150                 :            :         val = readb(socket->base + 0x800 + reg);
     151                 :            :         val |= readb(socket->base + 0x800 + reg + 1) << 8;
     152                 :            :         debug("%04x %04x\n", socket, reg, val);
     153                 :            :         return val;
     154                 :            : }
     155                 :            : 
     156                 :          0 : static inline void exca_writeb(struct yenta_socket *socket, unsigned reg, u8 val)
     157                 :            : {
     158                 :          0 :         debug("%04x %02x\n", socket, reg, val);
     159                 :          0 :         writeb(val, socket->base + 0x800 + reg);
     160                 :          0 :         readb(socket->base + 0x800 + reg); /* PCI write posting... */
     161                 :          0 : }
     162                 :            : 
     163                 :          0 : static void exca_writew(struct yenta_socket *socket, unsigned reg, u16 val)
     164                 :            : {
     165                 :          0 :         debug("%04x %04x\n", socket, reg, val);
     166                 :          0 :         writeb(val, socket->base + 0x800 + reg);
     167                 :          0 :         writeb(val >> 8, socket->base + 0x800 + reg + 1);
     168                 :            : 
     169                 :            :         /* PCI write posting... */
     170                 :          0 :         readb(socket->base + 0x800 + reg);
     171                 :          0 :         readb(socket->base + 0x800 + reg + 1);
     172                 :            : }
     173                 :            : 
     174                 :          0 : static ssize_t show_yenta_registers(struct device *yentadev, struct device_attribute *attr, char *buf)
     175                 :            : {
     176                 :          0 :         struct yenta_socket *socket = dev_get_drvdata(yentadev);
     177                 :          0 :         int offset = 0, i;
     178                 :            : 
     179                 :          0 :         offset = snprintf(buf, PAGE_SIZE, "CB registers:");
     180         [ #  # ]:          0 :         for (i = 0; i < 0x24; i += 4) {
     181                 :          0 :                 unsigned val;
     182         [ #  # ]:          0 :                 if (!(i & 15))
     183                 :          0 :                         offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i);
     184                 :          0 :                 val = cb_readl(socket, i);
     185                 :          0 :                 offset += snprintf(buf + offset, PAGE_SIZE - offset, " %08x", val);
     186                 :            :         }
     187                 :            : 
     188                 :          0 :         offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n\nExCA registers:");
     189         [ #  # ]:          0 :         for (i = 0; i < 0x45; i++) {
     190                 :          0 :                 unsigned char val;
     191         [ #  # ]:          0 :                 if (!(i & 7)) {
     192         [ #  # ]:          0 :                         if (i & 8) {
     193                 :          0 :                                 memcpy(buf + offset, " -", 2);
     194                 :          0 :                                 offset += 2;
     195                 :            :                         } else
     196                 :          0 :                                 offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i);
     197                 :            :                 }
     198                 :          0 :                 val = exca_readb(socket, i);
     199                 :          0 :                 offset += snprintf(buf + offset, PAGE_SIZE - offset, " %02x", val);
     200                 :            :         }
     201                 :          0 :         buf[offset++] = '\n';
     202                 :          0 :         return offset;
     203                 :            : }
     204                 :            : 
     205                 :            : static DEVICE_ATTR(yenta_registers, S_IRUSR, show_yenta_registers, NULL);
     206                 :            : 
     207                 :            : /*
     208                 :            :  * Ugh, mixed-mode cardbus and 16-bit pccard state: things depend
     209                 :            :  * on what kind of card is inserted..
     210                 :            :  */
     211                 :          0 : static int yenta_get_status(struct pcmcia_socket *sock, unsigned int *value)
     212                 :            : {
     213                 :          0 :         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
     214                 :          0 :         unsigned int val;
     215                 :          0 :         u32 state = cb_readl(socket, CB_SOCKET_STATE);
     216                 :            : 
     217                 :          0 :         val  = (state & CB_3VCARD) ? SS_3VCARD : 0;
     218                 :          0 :         val |= (state & CB_XVCARD) ? SS_XVCARD : 0;
     219         [ #  # ]:          0 :         val |= (state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) ? 0 : SS_PENDING;
     220         [ #  # ]:          0 :         val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? SS_PENDING : 0;
     221                 :            : 
     222                 :            : 
     223         [ #  # ]:          0 :         if (state & CB_CBCARD) {
     224                 :          0 :                 val |= SS_CARDBUS;
     225                 :          0 :                 val |= (state & CB_CARDSTS) ? SS_STSCHG : 0;
     226         [ #  # ]:          0 :                 val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? 0 : SS_DETECT;
     227         [ #  # ]:          0 :                 val |= (state & CB_PWRCYCLE) ? SS_POWERON | SS_READY : 0;
     228         [ #  # ]:          0 :         } else if (state & CB_16BITCARD) {
     229                 :          0 :                 u8 status = exca_readb(socket, I365_STATUS);
     230         [ #  # ]:          0 :                 val |= ((status & I365_CS_DETECT) == I365_CS_DETECT) ? SS_DETECT : 0;
     231         [ #  # ]:          0 :                 if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) {
     232         [ #  # ]:          0 :                         val |= (status & I365_CS_STSCHG) ? 0 : SS_STSCHG;
     233                 :            :                 } else {
     234         [ #  # ]:          0 :                         val |= (status & I365_CS_BVD1) ? 0 : SS_BATDEAD;
     235         [ #  # ]:          0 :                         val |= (status & I365_CS_BVD2) ? 0 : SS_BATWARN;
     236                 :            :                 }
     237                 :          0 :                 val |= (status & I365_CS_WRPROT) ? SS_WRPROT : 0;
     238                 :          0 :                 val |= (status & I365_CS_READY) ? SS_READY : 0;
     239                 :          0 :                 val |= (status & I365_CS_POWERON) ? SS_POWERON : 0;
     240                 :            :         }
     241                 :            : 
     242                 :          0 :         *value = val;
     243                 :          0 :         return 0;
     244                 :            : }
     245                 :            : 
     246                 :            : static void yenta_set_power(struct yenta_socket *socket, socket_state_t *state)
     247                 :            : {
     248                 :            :         /* some birdges require to use the ExCA registers to power 16bit cards */
     249                 :            :         if (!(cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) &&
     250                 :            :             (socket->flags & YENTA_16BIT_POWER_EXCA)) {
     251                 :            :                 u8 reg, old;
     252                 :            :                 reg = old = exca_readb(socket, I365_POWER);
     253                 :            :                 reg &= ~(I365_VCC_MASK | I365_VPP1_MASK | I365_VPP2_MASK);
     254                 :            : 
     255                 :            :                 /* i82365SL-DF style */
     256                 :            :                 if (socket->flags & YENTA_16BIT_POWER_DF) {
     257                 :            :                         switch (state->Vcc) {
     258                 :            :                         case 33:
     259                 :            :                                 reg |= I365_VCC_3V;
     260                 :            :                                 break;
     261                 :            :                         case 50:
     262                 :            :                                 reg |= I365_VCC_5V;
     263                 :            :                                 break;
     264                 :            :                         default:
     265                 :            :                                 reg = 0;
     266                 :            :                                 break;
     267                 :            :                         }
     268                 :            :                         switch (state->Vpp) {
     269                 :            :                         case 33:
     270                 :            :                         case 50:
     271                 :            :                                 reg |= I365_VPP1_5V;
     272                 :            :                                 break;
     273                 :            :                         case 120:
     274                 :            :                                 reg |= I365_VPP1_12V;
     275                 :            :                                 break;
     276                 :            :                         }
     277                 :            :                 } else {
     278                 :            :                         /* i82365SL-B style */
     279                 :            :                         switch (state->Vcc) {
     280                 :            :                         case 50:
     281                 :            :                                 reg |= I365_VCC_5V;
     282                 :            :                                 break;
     283                 :            :                         default:
     284                 :            :                                 reg = 0;
     285                 :            :                                 break;
     286                 :            :                         }
     287                 :            :                         switch (state->Vpp) {
     288                 :            :                         case 50:
     289                 :            :                                 reg |= I365_VPP1_5V | I365_VPP2_5V;
     290                 :            :                                 break;
     291                 :            :                         case 120:
     292                 :            :                                 reg |= I365_VPP1_12V | I365_VPP2_12V;
     293                 :            :                                 break;
     294                 :            :                         }
     295                 :            :                 }
     296                 :            : 
     297                 :            :                 if (reg != old)
     298                 :            :                         exca_writeb(socket, I365_POWER, reg);
     299                 :            :         } else {
     300                 :            :                 u32 reg = 0;    /* CB_SC_STPCLK? */
     301                 :            :                 switch (state->Vcc) {
     302                 :            :                 case 33:
     303                 :            :                         reg = CB_SC_VCC_3V;
     304                 :            :                         break;
     305                 :            :                 case 50:
     306                 :            :                         reg = CB_SC_VCC_5V;
     307                 :            :                         break;
     308                 :            :                 default:
     309                 :            :                         reg = 0;
     310                 :            :                         break;
     311                 :            :                 }
     312                 :            :                 switch (state->Vpp) {
     313                 :            :                 case 33:
     314                 :            :                         reg |= CB_SC_VPP_3V;
     315                 :            :                         break;
     316                 :            :                 case 50:
     317                 :            :                         reg |= CB_SC_VPP_5V;
     318                 :            :                         break;
     319                 :            :                 case 120:
     320                 :            :                         reg |= CB_SC_VPP_12V;
     321                 :            :                         break;
     322                 :            :                 }
     323                 :            :                 if (reg != cb_readl(socket, CB_SOCKET_CONTROL))
     324                 :            :                         cb_writel(socket, CB_SOCKET_CONTROL, reg);
     325                 :            :         }
     326                 :            : }
     327                 :            : 
     328                 :          0 : static int yenta_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
     329                 :            : {
     330                 :          0 :         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
     331                 :          0 :         u16 bridge;
     332                 :            : 
     333                 :            :         /* if powering down: do it immediately */
     334         [ #  # ]:          0 :         if (state->Vcc == 0)
     335                 :          0 :                 yenta_set_power(socket, state);
     336                 :            : 
     337                 :          0 :         socket->io_irq = state->io_irq;
     338                 :          0 :         bridge = config_readw(socket, CB_BRIDGE_CONTROL) & ~(CB_BRIDGE_CRST | CB_BRIDGE_INTR);
     339         [ #  # ]:          0 :         if (cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) {
     340                 :          0 :                 u8 intr;
     341                 :          0 :                 bridge |= (state->flags & SS_RESET) ? CB_BRIDGE_CRST : 0;
     342                 :            : 
     343                 :            :                 /* ISA interrupt control? */
     344                 :          0 :                 intr = exca_readb(socket, I365_INTCTL);
     345                 :          0 :                 intr = (intr & ~0xf);
     346         [ #  # ]:          0 :                 if (!socket->dev->irq) {
     347         [ #  # ]:          0 :                         intr |= socket->cb_irq ? socket->cb_irq : state->io_irq;
     348                 :          0 :                         bridge |= CB_BRIDGE_INTR;
     349                 :            :                 }
     350                 :          0 :                 exca_writeb(socket, I365_INTCTL, intr);
     351                 :            :         }  else {
     352                 :          0 :                 u8 reg;
     353                 :            : 
     354                 :          0 :                 reg = exca_readb(socket, I365_INTCTL) & (I365_RING_ENA | I365_INTR_ENA);
     355         [ #  # ]:          0 :                 reg |= (state->flags & SS_RESET) ? 0 : I365_PC_RESET;
     356                 :          0 :                 reg |= (state->flags & SS_IOCARD) ? I365_PC_IOCARD : 0;
     357         [ #  # ]:          0 :                 if (state->io_irq != socket->dev->irq) {
     358                 :          0 :                         reg |= state->io_irq;
     359                 :          0 :                         bridge |= CB_BRIDGE_INTR;
     360                 :            :                 }
     361                 :          0 :                 exca_writeb(socket, I365_INTCTL, reg);
     362                 :            : 
     363                 :          0 :                 reg = exca_readb(socket, I365_POWER) & (I365_VCC_MASK|I365_VPP1_MASK);
     364                 :          0 :                 reg |= I365_PWR_NORESET;
     365         [ #  # ]:          0 :                 if (state->flags & SS_PWR_AUTO)
     366                 :          0 :                         reg |= I365_PWR_AUTO;
     367         [ #  # ]:          0 :                 if (state->flags & SS_OUTPUT_ENA)
     368                 :          0 :                         reg |= I365_PWR_OUT;
     369         [ #  # ]:          0 :                 if (exca_readb(socket, I365_POWER) != reg)
     370                 :          0 :                         exca_writeb(socket, I365_POWER, reg);
     371                 :            : 
     372                 :            :                 /* CSC interrupt: no ISA irq for CSC */
     373                 :          0 :                 reg = exca_readb(socket, I365_CSCINT);
     374                 :          0 :                 reg &= I365_CSC_IRQ_MASK;
     375                 :          0 :                 reg |= I365_CSC_DETECT;
     376         [ #  # ]:          0 :                 if (state->flags & SS_IOCARD) {
     377         [ #  # ]:          0 :                         if (state->csc_mask & SS_STSCHG)
     378                 :          0 :                                 reg |= I365_CSC_STSCHG;
     379                 :            :                 } else {
     380         [ #  # ]:          0 :                         if (state->csc_mask & SS_BATDEAD)
     381                 :          0 :                                 reg |= I365_CSC_BVD1;
     382         [ #  # ]:          0 :                         if (state->csc_mask & SS_BATWARN)
     383                 :          0 :                                 reg |= I365_CSC_BVD2;
     384         [ #  # ]:          0 :                         if (state->csc_mask & SS_READY)
     385                 :          0 :                                 reg |= I365_CSC_READY;
     386                 :            :                 }
     387                 :          0 :                 exca_writeb(socket, I365_CSCINT, reg);
     388                 :          0 :                 exca_readb(socket, I365_CSC);
     389         [ #  # ]:          0 :                 if (sock->zoom_video)
     390                 :          0 :                         sock->zoom_video(sock, state->flags & SS_ZVCARD);
     391                 :            :         }
     392                 :          0 :         config_writew(socket, CB_BRIDGE_CONTROL, bridge);
     393                 :            :         /* Socket event mask: get card insert/remove events.. */
     394                 :          0 :         cb_writel(socket, CB_SOCKET_EVENT, -1);
     395                 :          0 :         cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK);
     396                 :            : 
     397                 :            :         /* if powering up: do it as the last step when the socket is configured */
     398         [ #  # ]:          0 :         if (state->Vcc != 0)
     399                 :          0 :                 yenta_set_power(socket, state);
     400                 :          0 :         return 0;
     401                 :            : }
     402                 :            : 
     403                 :          0 : static int yenta_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io)
     404                 :            : {
     405                 :          0 :         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
     406                 :          0 :         int map;
     407                 :          0 :         unsigned char ioctl, addr, enable;
     408                 :            : 
     409                 :          0 :         map = io->map;
     410                 :            : 
     411         [ #  # ]:          0 :         if (map > 1)
     412                 :            :                 return -EINVAL;
     413                 :            : 
     414                 :          0 :         enable = I365_ENA_IO(map);
     415                 :          0 :         addr = exca_readb(socket, I365_ADDRWIN);
     416                 :            : 
     417                 :            :         /* Disable the window before changing it.. */
     418         [ #  # ]:          0 :         if (addr & enable) {
     419                 :          0 :                 addr &= ~enable;
     420                 :          0 :                 exca_writeb(socket, I365_ADDRWIN, addr);
     421                 :            :         }
     422                 :            : 
     423                 :          0 :         exca_writew(socket, I365_IO(map)+I365_W_START, io->start);
     424                 :          0 :         exca_writew(socket, I365_IO(map)+I365_W_STOP, io->stop);
     425                 :            : 
     426                 :          0 :         ioctl = exca_readb(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map);
     427         [ #  # ]:          0 :         if (io->flags & MAP_0WS)
     428                 :          0 :                 ioctl |= I365_IOCTL_0WS(map);
     429         [ #  # ]:          0 :         if (io->flags & MAP_16BIT)
     430                 :          0 :                 ioctl |= I365_IOCTL_16BIT(map);
     431         [ #  # ]:          0 :         if (io->flags & MAP_AUTOSZ)
     432                 :          0 :                 ioctl |= I365_IOCTL_IOCS16(map);
     433                 :          0 :         exca_writeb(socket, I365_IOCTL, ioctl);
     434                 :            : 
     435         [ #  # ]:          0 :         if (io->flags & MAP_ACTIVE)
     436                 :          0 :                 exca_writeb(socket, I365_ADDRWIN, addr | enable);
     437                 :            :         return 0;
     438                 :            : }
     439                 :            : 
     440                 :          0 : static int yenta_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem)
     441                 :            : {
     442                 :          0 :         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
     443                 :          0 :         struct pci_bus_region region;
     444                 :          0 :         int map;
     445                 :          0 :         unsigned char addr, enable;
     446                 :          0 :         unsigned int start, stop, card_start;
     447                 :          0 :         unsigned short word;
     448                 :            : 
     449                 :          0 :         pcibios_resource_to_bus(socket->dev->bus, &region, mem->res);
     450                 :            : 
     451                 :          0 :         map = mem->map;
     452                 :          0 :         start = region.start;
     453                 :          0 :         stop = region.end;
     454                 :          0 :         card_start = mem->card_start;
     455                 :            : 
     456   [ #  #  #  # ]:          0 :         if (map > 4 || start > stop || ((start ^ stop) >> 24) ||
     457   [ #  #  #  # ]:          0 :             (card_start >> 26) || mem->speed > 1000)
     458                 :            :                 return -EINVAL;
     459                 :            : 
     460                 :          0 :         enable = I365_ENA_MEM(map);
     461                 :          0 :         addr = exca_readb(socket, I365_ADDRWIN);
     462         [ #  # ]:          0 :         if (addr & enable) {
     463                 :          0 :                 addr &= ~enable;
     464                 :          0 :                 exca_writeb(socket, I365_ADDRWIN, addr);
     465                 :            :         }
     466                 :            : 
     467                 :          0 :         exca_writeb(socket, CB_MEM_PAGE(map), start >> 24);
     468                 :            : 
     469                 :          0 :         word = (start >> 12) & 0x0fff;
     470         [ #  # ]:          0 :         if (mem->flags & MAP_16BIT)
     471                 :          0 :                 word |= I365_MEM_16BIT;
     472         [ #  # ]:          0 :         if (mem->flags & MAP_0WS)
     473                 :          0 :                 word |= I365_MEM_0WS;
     474                 :          0 :         exca_writew(socket, I365_MEM(map) + I365_W_START, word);
     475                 :            : 
     476                 :          0 :         word = (stop >> 12) & 0x0fff;
     477   [ #  #  #  # ]:          0 :         switch (to_cycles(mem->speed)) {
     478                 :            :         case 0:
     479                 :            :                 break;
     480                 :          0 :         case 1:
     481                 :          0 :                 word |= I365_MEM_WS0;
     482                 :          0 :                 break;
     483                 :          0 :         case 2:
     484                 :          0 :                 word |= I365_MEM_WS1;
     485                 :          0 :                 break;
     486                 :          0 :         default:
     487                 :          0 :                 word |= I365_MEM_WS1 | I365_MEM_WS0;
     488                 :          0 :                 break;
     489                 :            :         }
     490                 :          0 :         exca_writew(socket, I365_MEM(map) + I365_W_STOP, word);
     491                 :            : 
     492                 :          0 :         word = ((card_start - start) >> 12) & 0x3fff;
     493         [ #  # ]:          0 :         if (mem->flags & MAP_WRPROT)
     494                 :          0 :                 word |= I365_MEM_WRPROT;
     495         [ #  # ]:          0 :         if (mem->flags & MAP_ATTRIB)
     496                 :          0 :                 word |= I365_MEM_REG;
     497                 :          0 :         exca_writew(socket, I365_MEM(map) + I365_W_OFF, word);
     498                 :            : 
     499         [ #  # ]:          0 :         if (mem->flags & MAP_ACTIVE)
     500                 :          0 :                 exca_writeb(socket, I365_ADDRWIN, addr | enable);
     501                 :            :         return 0;
     502                 :            : }
     503                 :            : 
     504                 :            : 
     505                 :            : 
     506                 :          0 : static irqreturn_t yenta_interrupt(int irq, void *dev_id)
     507                 :            : {
     508                 :          0 :         unsigned int events;
     509                 :          0 :         struct yenta_socket *socket = (struct yenta_socket *) dev_id;
     510                 :          0 :         u8 csc;
     511                 :          0 :         u32 cb_event;
     512                 :            : 
     513                 :            :         /* Clear interrupt status for the event */
     514                 :          0 :         cb_event = cb_readl(socket, CB_SOCKET_EVENT);
     515                 :          0 :         cb_writel(socket, CB_SOCKET_EVENT, cb_event);
     516                 :            : 
     517                 :          0 :         csc = exca_readb(socket, I365_CSC);
     518                 :            : 
     519         [ #  # ]:          0 :         if (!(cb_event || csc))
     520                 :            :                 return IRQ_NONE;
     521                 :            : 
     522         [ #  # ]:          0 :         events = (cb_event & (CB_CD1EVENT | CB_CD2EVENT)) ? SS_DETECT : 0 ;
     523                 :          0 :         events |= (csc & I365_CSC_DETECT) ? SS_DETECT : 0;
     524         [ #  # ]:          0 :         if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) {
     525                 :          0 :                 events |= (csc & I365_CSC_STSCHG) ? SS_STSCHG : 0;
     526                 :            :         } else {
     527                 :          0 :                 events |= (csc & I365_CSC_BVD1) ? SS_BATDEAD : 0;
     528                 :          0 :                 events |= (csc & I365_CSC_BVD2) ? SS_BATWARN : 0;
     529                 :          0 :                 events |= (csc & I365_CSC_READY) ? SS_READY : 0;
     530                 :            :         }
     531                 :            : 
     532         [ #  # ]:          0 :         if (events)
     533                 :          0 :                 pcmcia_parse_events(&socket->socket, events);
     534                 :            : 
     535                 :            :         return IRQ_HANDLED;
     536                 :            : }
     537                 :            : 
     538                 :          0 : static void yenta_interrupt_wrapper(struct timer_list *t)
     539                 :            : {
     540                 :          0 :         struct yenta_socket *socket = from_timer(socket, t, poll_timer);
     541                 :            : 
     542                 :          0 :         yenta_interrupt(0, (void *)socket);
     543                 :          0 :         socket->poll_timer.expires = jiffies + HZ;
     544                 :          0 :         add_timer(&socket->poll_timer);
     545                 :          0 : }
     546                 :            : 
     547                 :          0 : static void yenta_clear_maps(struct yenta_socket *socket)
     548                 :            : {
     549                 :          0 :         int i;
     550                 :          0 :         struct resource res = { .start = 0, .end = 0x0fff };
     551                 :          0 :         pccard_io_map io = { 0, 0, 0, 0, 1 };
     552                 :          0 :         pccard_mem_map mem = { .res = &res, };
     553                 :            : 
     554                 :          0 :         yenta_set_socket(&socket->socket, &dead_socket);
     555         [ #  # ]:          0 :         for (i = 0; i < 2; i++) {
     556                 :          0 :                 io.map = i;
     557                 :          0 :                 yenta_set_io_map(&socket->socket, &io);
     558                 :            :         }
     559         [ #  # ]:          0 :         for (i = 0; i < 5; i++) {
     560                 :          0 :                 mem.map = i;
     561                 :          0 :                 yenta_set_mem_map(&socket->socket, &mem);
     562                 :            :         }
     563                 :          0 : }
     564                 :            : 
     565                 :            : /* redoes voltage interrogation if required */
     566                 :          0 : static void yenta_interrogate(struct yenta_socket *socket)
     567                 :            : {
     568                 :          0 :         u32 state;
     569                 :            : 
     570                 :          0 :         state = cb_readl(socket, CB_SOCKET_STATE);
     571         [ #  # ]:          0 :         if (!(state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) ||
     572         [ #  # ]:          0 :             (state & (CB_CDETECT1 | CB_CDETECT2 | CB_NOTACARD | CB_BADVCCREQ)) ||
     573         [ #  # ]:          0 :             ((state & (CB_16BITCARD | CB_CBCARD)) == (CB_16BITCARD | CB_CBCARD)))
     574                 :          0 :                 cb_writel(socket, CB_SOCKET_FORCE, CB_CVSTEST);
     575                 :          0 : }
     576                 :            : 
     577                 :            : /* Called at resume and initialization events */
     578                 :          0 : static int yenta_sock_init(struct pcmcia_socket *sock)
     579                 :            : {
     580                 :          0 :         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
     581                 :            : 
     582                 :          0 :         exca_writeb(socket, I365_GBLCTL, 0x00);
     583                 :          0 :         exca_writeb(socket, I365_GENCTL, 0x00);
     584                 :            : 
     585                 :            :         /* Redo card voltage interrogation */
     586                 :          0 :         yenta_interrogate(socket);
     587                 :            : 
     588                 :          0 :         yenta_clear_maps(socket);
     589                 :            : 
     590   [ #  #  #  # ]:          0 :         if (socket->type && socket->type->sock_init)
     591                 :          0 :                 socket->type->sock_init(socket);
     592                 :            : 
     593                 :            :         /* Re-enable CSC interrupts */
     594                 :          0 :         cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK);
     595                 :            : 
     596                 :          0 :         return 0;
     597                 :            : }
     598                 :            : 
     599                 :          0 : static int yenta_sock_suspend(struct pcmcia_socket *sock)
     600                 :            : {
     601                 :          0 :         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
     602                 :            : 
     603                 :            :         /* Disable CSC interrupts */
     604                 :          0 :         cb_writel(socket, CB_SOCKET_MASK, 0x0);
     605                 :            : 
     606                 :          0 :         return 0;
     607                 :            : }
     608                 :            : 
     609                 :            : /*
     610                 :            :  * Use an adaptive allocation for the memory resource,
     611                 :            :  * sometimes the memory behind pci bridges is limited:
     612                 :            :  * 1/8 of the size of the io window of the parent.
     613                 :            :  * max 4 MB, min 16 kB. We try very hard to not get below
     614                 :            :  * the "ACC" values, though.
     615                 :            :  */
     616                 :            : #define BRIDGE_MEM_MAX (4*1024*1024)
     617                 :            : #define BRIDGE_MEM_ACC (128*1024)
     618                 :            : #define BRIDGE_MEM_MIN (16*1024)
     619                 :            : 
     620                 :            : #define BRIDGE_IO_MAX 512
     621                 :            : #define BRIDGE_IO_ACC 256
     622                 :            : #define BRIDGE_IO_MIN 32
     623                 :            : 
     624                 :            : #ifndef PCIBIOS_MIN_CARDBUS_IO
     625                 :            : #define PCIBIOS_MIN_CARDBUS_IO PCIBIOS_MIN_IO
     626                 :            : #endif
     627                 :            : 
     628                 :          0 : static int yenta_search_one_res(struct resource *root, struct resource *res,
     629                 :            :                                 u32 min)
     630                 :            : {
     631                 :          0 :         u32 align, size, start, end;
     632                 :            : 
     633         [ #  # ]:          0 :         if (res->flags & IORESOURCE_IO) {
     634                 :            :                 align = 1024;
     635                 :            :                 size = BRIDGE_IO_MAX;
     636                 :            :                 start = PCIBIOS_MIN_CARDBUS_IO;
     637                 :            :                 end = ~0U;
     638                 :            :         } else {
     639                 :          0 :                 unsigned long avail = root->end - root->start;
     640                 :          0 :                 int i;
     641                 :          0 :                 size = BRIDGE_MEM_MAX;
     642         [ #  # ]:          0 :                 if (size > avail/8) {
     643                 :          0 :                         size = (avail+1)/8;
     644                 :            :                         /* round size down to next power of 2 */
     645                 :          0 :                         i = 0;
     646         [ #  # ]:          0 :                         while ((size /= 2) != 0)
     647                 :          0 :                                 i++;
     648                 :          0 :                         size = 1 << i;
     649                 :            :                 }
     650                 :          0 :                 if (size < min)
     651                 :            :                         size = min;
     652                 :          0 :                 align = size;
     653                 :          0 :                 start = PCIBIOS_MIN_MEM;
     654                 :          0 :                 end = ~0U;
     655                 :            :         }
     656                 :            : 
     657                 :          0 :         do {
     658         [ #  # ]:          0 :                 if (allocate_resource(root, res, size, start, end, align,
     659                 :            :                                       NULL, NULL) == 0) {
     660                 :            :                         return 1;
     661                 :            :                 }
     662                 :          0 :                 size = size/2;
     663                 :          0 :                 align = size;
     664         [ #  # ]:          0 :         } while (size >= min);
     665                 :            : 
     666                 :            :         return 0;
     667                 :            : }
     668                 :            : 
     669                 :            : 
     670                 :            : static int yenta_search_res(struct yenta_socket *socket, struct resource *res,
     671                 :            :                             u32 min)
     672                 :            : {
     673                 :            :         struct resource *root;
     674                 :            :         int i;
     675                 :            : 
     676                 :            :         pci_bus_for_each_resource(socket->dev->bus, root, i) {
     677                 :            :                 if (!root)
     678                 :            :                         continue;
     679                 :            : 
     680                 :            :                 if ((res->flags ^ root->flags) &
     681                 :            :                     (IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH))
     682                 :            :                         continue; /* Wrong type */
     683                 :            : 
     684                 :            :                 if (yenta_search_one_res(root, res, min))
     685                 :            :                         return 1;
     686                 :            :         }
     687                 :            :         return 0;
     688                 :            : }
     689                 :            : 
     690                 :          0 : static int yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned type, int addr_start, int addr_end)
     691                 :            : {
     692                 :          0 :         struct pci_dev *dev = socket->dev;
     693                 :          0 :         struct resource *res;
     694                 :          0 :         struct pci_bus_region region;
     695                 :          0 :         unsigned mask;
     696                 :            : 
     697                 :          0 :         res = dev->resource + PCI_BRIDGE_RESOURCES + nr;
     698                 :            :         /* Already allocated? */
     699         [ #  # ]:          0 :         if (res->parent)
     700                 :            :                 return 0;
     701                 :            : 
     702                 :            :         /* The granularity of the memory limit is 4kB, on IO it's 4 bytes */
     703                 :          0 :         mask = ~0xfff;
     704         [ #  # ]:          0 :         if (type & IORESOURCE_IO)
     705                 :          0 :                 mask = ~3;
     706                 :            : 
     707                 :          0 :         res->name = dev->subordinate->name;
     708                 :          0 :         res->flags = type;
     709                 :            : 
     710                 :          0 :         region.start = config_readl(socket, addr_start) & mask;
     711                 :          0 :         region.end = config_readl(socket, addr_end) | ~mask;
     712   [ #  #  #  #  :          0 :         if (region.start && region.end > region.start && !override_bios) {
                   #  # ]
     713                 :          0 :                 pcibios_bus_to_resource(dev->bus, res, &region);
     714         [ #  # ]:          0 :                 if (pci_claim_resource(dev, PCI_BRIDGE_RESOURCES + nr) == 0)
     715                 :            :                         return 0;
     716                 :          0 :                 dev_info(&dev->dev,
     717                 :            :                          "Preassigned resource %d busy or not available, reconfiguring...\n",
     718                 :            :                          nr);
     719                 :            :         }
     720                 :            : 
     721         [ #  # ]:          0 :         if (type & IORESOURCE_IO) {
     722   [ #  #  #  # ]:          0 :                 if ((yenta_search_res(socket, res, BRIDGE_IO_MAX)) ||
     723         [ #  # ]:          0 :                     (yenta_search_res(socket, res, BRIDGE_IO_ACC)) ||
     724                 :          0 :                     (yenta_search_res(socket, res, BRIDGE_IO_MIN)))
     725                 :          0 :                         return 1;
     726                 :            :         } else {
     727         [ #  # ]:          0 :                 if (type & IORESOURCE_PREFETCH) {
     728   [ #  #  #  # ]:          0 :                         if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) ||
     729         [ #  # ]:          0 :                             (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) ||
     730                 :          0 :                             (yenta_search_res(socket, res, BRIDGE_MEM_MIN)))
     731                 :          0 :                                 return 1;
     732                 :            :                         /* Approximating prefetchable by non-prefetchable */
     733                 :          0 :                         res->flags = IORESOURCE_MEM;
     734                 :            :                 }
     735   [ #  #  #  # ]:          0 :                 if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) ||
     736         [ #  # ]:          0 :                     (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) ||
     737                 :          0 :                     (yenta_search_res(socket, res, BRIDGE_MEM_MIN)))
     738                 :          0 :                         return 1;
     739                 :            :         }
     740                 :            : 
     741                 :          0 :         dev_info(&dev->dev,
     742                 :            :                  "no resource of type %x available, trying to continue...\n",
     743                 :            :                  type);
     744                 :          0 :         res->start = res->end = res->flags = 0;
     745                 :          0 :         return 0;
     746                 :            : }
     747                 :            : 
     748                 :            : /*
     749                 :            :  * Allocate the bridge mappings for the device..
     750                 :            :  */
     751                 :          0 : static void yenta_allocate_resources(struct yenta_socket *socket)
     752                 :            : {
     753                 :          0 :         int program = 0;
     754                 :          0 :         program += yenta_allocate_res(socket, 0, IORESOURCE_IO,
     755                 :            :                            PCI_CB_IO_BASE_0, PCI_CB_IO_LIMIT_0);
     756                 :          0 :         program += yenta_allocate_res(socket, 1, IORESOURCE_IO,
     757                 :            :                            PCI_CB_IO_BASE_1, PCI_CB_IO_LIMIT_1);
     758                 :          0 :         program += yenta_allocate_res(socket, 2, IORESOURCE_MEM|IORESOURCE_PREFETCH,
     759                 :            :                            PCI_CB_MEMORY_BASE_0, PCI_CB_MEMORY_LIMIT_0);
     760                 :          0 :         program += yenta_allocate_res(socket, 3, IORESOURCE_MEM,
     761                 :            :                            PCI_CB_MEMORY_BASE_1, PCI_CB_MEMORY_LIMIT_1);
     762         [ #  # ]:          0 :         if (program)
     763                 :          0 :                 pci_setup_cardbus(socket->dev->subordinate);
     764                 :          0 : }
     765                 :            : 
     766                 :            : 
     767                 :            : /*
     768                 :            :  * Free the bridge mappings for the device..
     769                 :            :  */
     770                 :            : static void yenta_free_resources(struct yenta_socket *socket)
     771                 :            : {
     772                 :            :         int i;
     773                 :            :         for (i = 0; i < 4; i++) {
     774                 :            :                 struct resource *res;
     775                 :            :                 res = socket->dev->resource + PCI_BRIDGE_RESOURCES + i;
     776                 :            :                 if (res->start != 0 && res->end != 0)
     777                 :            :                         release_resource(res);
     778                 :            :                 res->start = res->end = res->flags = 0;
     779                 :            :         }
     780                 :            : }
     781                 :            : 
     782                 :            : 
     783                 :            : /*
     784                 :            :  * Close it down - release our resources and go home..
     785                 :            :  */
     786                 :          0 : static void yenta_close(struct pci_dev *dev)
     787                 :            : {
     788                 :          0 :         struct yenta_socket *sock = pci_get_drvdata(dev);
     789                 :            : 
     790                 :            :         /* Remove the register attributes */
     791                 :          0 :         device_remove_file(&dev->dev, &dev_attr_yenta_registers);
     792                 :            : 
     793                 :            :         /* we don't want a dying socket registered */
     794                 :          0 :         pcmcia_unregister_socket(&sock->socket);
     795                 :            : 
     796                 :            :         /* Disable all events so we don't die in an IRQ storm */
     797                 :          0 :         cb_writel(sock, CB_SOCKET_MASK, 0x0);
     798                 :          0 :         exca_writeb(sock, I365_CSCINT, 0);
     799                 :            : 
     800         [ #  # ]:          0 :         if (sock->cb_irq)
     801                 :          0 :                 free_irq(sock->cb_irq, sock);
     802                 :            :         else
     803                 :          0 :                 del_timer_sync(&sock->poll_timer);
     804                 :            : 
     805                 :          0 :         iounmap(sock->base);
     806                 :          0 :         yenta_free_resources(sock);
     807                 :            : 
     808                 :          0 :         pci_release_regions(dev);
     809                 :          0 :         pci_disable_device(dev);
     810                 :          0 :         pci_set_drvdata(dev, NULL);
     811                 :          0 :         kfree(sock);
     812                 :          0 : }
     813                 :            : 
     814                 :            : 
     815                 :            : static struct pccard_operations yenta_socket_operations = {
     816                 :            :         .init                   = yenta_sock_init,
     817                 :            :         .suspend                = yenta_sock_suspend,
     818                 :            :         .get_status             = yenta_get_status,
     819                 :            :         .set_socket             = yenta_set_socket,
     820                 :            :         .set_io_map             = yenta_set_io_map,
     821                 :            :         .set_mem_map            = yenta_set_mem_map,
     822                 :            : };
     823                 :            : 
     824                 :            : 
     825                 :            : #ifdef CONFIG_YENTA_TI
     826                 :            : #include "ti113x.h"
     827                 :            : #endif
     828                 :            : #ifdef CONFIG_YENTA_RICOH
     829                 :            : #include "ricoh.h"
     830                 :            : #endif
     831                 :            : #ifdef CONFIG_YENTA_TOSHIBA
     832                 :            : #include "topic.h"
     833                 :            : #endif
     834                 :            : #ifdef CONFIG_YENTA_O2
     835                 :            : #include "o2micro.h"
     836                 :            : #endif
     837                 :            : 
     838                 :            : enum {
     839                 :            :         CARDBUS_TYPE_DEFAULT = -1,
     840                 :            :         CARDBUS_TYPE_TI,
     841                 :            :         CARDBUS_TYPE_TI113X,
     842                 :            :         CARDBUS_TYPE_TI12XX,
     843                 :            :         CARDBUS_TYPE_TI1250,
     844                 :            :         CARDBUS_TYPE_RICOH,
     845                 :            :         CARDBUS_TYPE_TOPIC95,
     846                 :            :         CARDBUS_TYPE_TOPIC97,
     847                 :            :         CARDBUS_TYPE_O2MICRO,
     848                 :            :         CARDBUS_TYPE_ENE,
     849                 :            : };
     850                 :            : 
     851                 :            : /*
     852                 :            :  * Different cardbus controllers have slightly different
     853                 :            :  * initialization sequences etc details. List them here..
     854                 :            :  */
     855                 :            : static struct cardbus_type cardbus_type[] = {
     856                 :            : #ifdef CONFIG_YENTA_TI
     857                 :            :         [CARDBUS_TYPE_TI]       = {
     858                 :            :                 .override       = ti_override,
     859                 :            :                 .save_state     = ti_save_state,
     860                 :            :                 .restore_state  = ti_restore_state,
     861                 :            :                 .sock_init      = ti_init,
     862                 :            :         },
     863                 :            :         [CARDBUS_TYPE_TI113X]   = {
     864                 :            :                 .override       = ti113x_override,
     865                 :            :                 .save_state     = ti_save_state,
     866                 :            :                 .restore_state  = ti_restore_state,
     867                 :            :                 .sock_init      = ti_init,
     868                 :            :         },
     869                 :            :         [CARDBUS_TYPE_TI12XX]   = {
     870                 :            :                 .override       = ti12xx_override,
     871                 :            :                 .save_state     = ti_save_state,
     872                 :            :                 .restore_state  = ti_restore_state,
     873                 :            :                 .sock_init      = ti_init,
     874                 :            :         },
     875                 :            :         [CARDBUS_TYPE_TI1250]   = {
     876                 :            :                 .override       = ti1250_override,
     877                 :            :                 .save_state     = ti_save_state,
     878                 :            :                 .restore_state  = ti_restore_state,
     879                 :            :                 .sock_init      = ti_init,
     880                 :            :         },
     881                 :            :         [CARDBUS_TYPE_ENE]      = {
     882                 :            :                 .override       = ene_override,
     883                 :            :                 .save_state     = ti_save_state,
     884                 :            :                 .restore_state  = ti_restore_state,
     885                 :            :                 .sock_init      = ti_init,
     886                 :            :         },
     887                 :            : #endif
     888                 :            : #ifdef CONFIG_YENTA_RICOH
     889                 :            :         [CARDBUS_TYPE_RICOH]    = {
     890                 :            :                 .override       = ricoh_override,
     891                 :            :                 .save_state     = ricoh_save_state,
     892                 :            :                 .restore_state  = ricoh_restore_state,
     893                 :            :         },
     894                 :            : #endif
     895                 :            : #ifdef CONFIG_YENTA_TOSHIBA
     896                 :            :         [CARDBUS_TYPE_TOPIC95]  = {
     897                 :            :                 .override       = topic95_override,
     898                 :            :         },
     899                 :            :         [CARDBUS_TYPE_TOPIC97]  = {
     900                 :            :                 .override       = topic97_override,
     901                 :            :         },
     902                 :            : #endif
     903                 :            : #ifdef CONFIG_YENTA_O2
     904                 :            :         [CARDBUS_TYPE_O2MICRO]  = {
     905                 :            :                 .override       = o2micro_override,
     906                 :            :                 .restore_state  = o2micro_restore_state,
     907                 :            :         },
     908                 :            : #endif
     909                 :            : };
     910                 :            : 
     911                 :            : 
     912                 :          0 : static unsigned int yenta_probe_irq(struct yenta_socket *socket, u32 isa_irq_mask)
     913                 :            : {
     914                 :          0 :         int i;
     915                 :          0 :         unsigned long val;
     916                 :          0 :         u32 mask;
     917                 :          0 :         u8 reg;
     918                 :            : 
     919                 :            :         /*
     920                 :            :          * Probe for usable interrupts using the force
     921                 :            :          * register to generate bogus card status events.
     922                 :            :          */
     923                 :          0 :         cb_writel(socket, CB_SOCKET_EVENT, -1);
     924                 :          0 :         cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK);
     925                 :          0 :         reg = exca_readb(socket, I365_CSCINT);
     926                 :          0 :         exca_writeb(socket, I365_CSCINT, 0);
     927                 :          0 :         val = probe_irq_on() & isa_irq_mask;
     928         [ #  # ]:          0 :         for (i = 1; i < 16; i++) {
     929         [ #  # ]:          0 :                 if (!((val >> i) & 1))
     930                 :          0 :                         continue;
     931                 :          0 :                 exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG | (i << 4));
     932                 :          0 :                 cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS);
     933                 :          0 :                 udelay(100);
     934                 :          0 :                 cb_writel(socket, CB_SOCKET_EVENT, -1);
     935                 :            :         }
     936                 :          0 :         cb_writel(socket, CB_SOCKET_MASK, 0);
     937                 :          0 :         exca_writeb(socket, I365_CSCINT, reg);
     938                 :            : 
     939                 :          0 :         mask = probe_irq_mask(val) & 0xffff;
     940                 :            : 
     941                 :          0 :         return mask;
     942                 :            : }
     943                 :            : 
     944                 :            : 
     945                 :            : /*
     946                 :            :  * yenta PCI irq probing.
     947                 :            :  * currently only used in the TI/EnE initialization code
     948                 :            :  */
     949                 :            : #ifdef CONFIG_YENTA_TI
     950                 :            : 
     951                 :            : /* interrupt handler, only used during probing */
     952                 :          0 : static irqreturn_t yenta_probe_handler(int irq, void *dev_id)
     953                 :            : {
     954                 :          0 :         struct yenta_socket *socket = (struct yenta_socket *) dev_id;
     955                 :          0 :         u8 csc;
     956                 :          0 :         u32 cb_event;
     957                 :            : 
     958                 :            :         /* Clear interrupt status for the event */
     959                 :          0 :         cb_event = cb_readl(socket, CB_SOCKET_EVENT);
     960                 :          0 :         cb_writel(socket, CB_SOCKET_EVENT, -1);
     961                 :          0 :         csc = exca_readb(socket, I365_CSC);
     962                 :            : 
     963         [ #  # ]:          0 :         if (cb_event || csc) {
     964                 :          0 :                 socket->probe_status = 1;
     965                 :          0 :                 return IRQ_HANDLED;
     966                 :            :         }
     967                 :            : 
     968                 :            :         return IRQ_NONE;
     969                 :            : }
     970                 :            : 
     971                 :            : /* probes the PCI interrupt, use only on override functions */
     972                 :          0 : static int yenta_probe_cb_irq(struct yenta_socket *socket)
     973                 :            : {
     974                 :          0 :         u8 reg = 0;
     975                 :            : 
     976         [ #  # ]:          0 :         if (!socket->cb_irq)
     977                 :            :                 return -1;
     978                 :            : 
     979                 :          0 :         socket->probe_status = 0;
     980                 :            : 
     981         [ #  # ]:          0 :         if (request_irq(socket->cb_irq, yenta_probe_handler, IRQF_SHARED, "yenta", socket)) {
     982                 :          0 :                 dev_warn(&socket->dev->dev,
     983                 :            :                          "request_irq() in yenta_probe_cb_irq() failed!\n");
     984                 :          0 :                 return -1;
     985                 :            :         }
     986                 :            : 
     987                 :            :         /* generate interrupt, wait */
     988         [ #  # ]:          0 :         if (!socket->dev->irq)
     989                 :          0 :                 reg = exca_readb(socket, I365_CSCINT);
     990                 :          0 :         exca_writeb(socket, I365_CSCINT, reg | I365_CSC_STSCHG);
     991                 :          0 :         cb_writel(socket, CB_SOCKET_EVENT, -1);
     992                 :          0 :         cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK);
     993                 :          0 :         cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS);
     994                 :            : 
     995                 :          0 :         msleep(100);
     996                 :            : 
     997                 :            :         /* disable interrupts */
     998                 :          0 :         cb_writel(socket, CB_SOCKET_MASK, 0);
     999                 :          0 :         exca_writeb(socket, I365_CSCINT, reg);
    1000                 :          0 :         cb_writel(socket, CB_SOCKET_EVENT, -1);
    1001                 :          0 :         exca_readb(socket, I365_CSC);
    1002                 :            : 
    1003                 :          0 :         free_irq(socket->cb_irq, socket);
    1004                 :            : 
    1005                 :          0 :         return (int) socket->probe_status;
    1006                 :            : }
    1007                 :            : 
    1008                 :            : #endif /* CONFIG_YENTA_TI */
    1009                 :            : 
    1010                 :            : 
    1011                 :            : /*
    1012                 :            :  * Set static data that doesn't need re-initializing..
    1013                 :            :  */
    1014                 :          0 : static void yenta_get_socket_capabilities(struct yenta_socket *socket, u32 isa_irq_mask)
    1015                 :            : {
    1016                 :          0 :         socket->socket.pci_irq = socket->cb_irq;
    1017         [ #  # ]:          0 :         if (isa_probe)
    1018                 :          0 :                 socket->socket.irq_mask = yenta_probe_irq(socket, isa_irq_mask);
    1019                 :            :         else
    1020                 :          0 :                 socket->socket.irq_mask = 0;
    1021                 :            : 
    1022                 :          0 :         dev_info(&socket->dev->dev, "ISA IRQ mask 0x%04x, PCI irq %d\n",
    1023                 :            :                  socket->socket.irq_mask, socket->cb_irq);
    1024                 :          0 : }
    1025                 :            : 
    1026                 :            : /*
    1027                 :            :  * Initialize the standard cardbus registers
    1028                 :            :  */
    1029                 :          0 : static void yenta_config_init(struct yenta_socket *socket)
    1030                 :            : {
    1031                 :          0 :         u16 bridge;
    1032                 :          0 :         struct pci_dev *dev = socket->dev;
    1033                 :          0 :         struct pci_bus_region region;
    1034                 :            : 
    1035                 :          0 :         pcibios_resource_to_bus(socket->dev->bus, &region, &dev->resource[0]);
    1036                 :            : 
    1037                 :          0 :         config_writel(socket, CB_LEGACY_MODE_BASE, 0);
    1038                 :          0 :         config_writel(socket, PCI_BASE_ADDRESS_0, region.start);
    1039                 :          0 :         config_writew(socket, PCI_COMMAND,
    1040                 :            :                         PCI_COMMAND_IO |
    1041                 :            :                         PCI_COMMAND_MEMORY |
    1042                 :            :                         PCI_COMMAND_MASTER |
    1043                 :            :                         PCI_COMMAND_WAIT);
    1044                 :            : 
    1045                 :            :         /* MAGIC NUMBERS! Fixme */
    1046                 :          0 :         config_writeb(socket, PCI_CACHE_LINE_SIZE, L1_CACHE_BYTES / 4);
    1047                 :          0 :         config_writeb(socket, PCI_LATENCY_TIMER, 168);
    1048                 :          0 :         config_writel(socket, PCI_PRIMARY_BUS,
    1049                 :            :                 (176 << 24) |                        /* sec. latency timer */
    1050                 :          0 :                 ((unsigned int)dev->subordinate->busn_res.end << 16) | /* subordinate bus */
    1051                 :          0 :                 ((unsigned int)dev->subordinate->busn_res.start << 8) |  /* secondary bus */
    1052                 :          0 :                 dev->subordinate->primary);                  /* primary bus */
    1053                 :            : 
    1054                 :            :         /*
    1055                 :            :          * Set up the bridging state:
    1056                 :            :          *  - enable write posting.
    1057                 :            :          *  - memory window 0 prefetchable, window 1 non-prefetchable
    1058                 :            :          *  - PCI interrupts enabled if a PCI interrupt exists..
    1059                 :            :          */
    1060                 :          0 :         bridge = config_readw(socket, CB_BRIDGE_CONTROL);
    1061                 :          0 :         bridge &= ~(CB_BRIDGE_CRST | CB_BRIDGE_PREFETCH1 | CB_BRIDGE_ISAEN | CB_BRIDGE_VGAEN);
    1062                 :          0 :         bridge |= CB_BRIDGE_PREFETCH0 | CB_BRIDGE_POSTEN;
    1063                 :          0 :         config_writew(socket, CB_BRIDGE_CONTROL, bridge);
    1064                 :          0 : }
    1065                 :            : 
    1066                 :            : /**
    1067                 :            :  * yenta_fixup_parent_bridge - Fix subordinate bus# of the parent bridge
    1068                 :            :  * @cardbus_bridge: The PCI bus which the CardBus bridge bridges to
    1069                 :            :  *
    1070                 :            :  * Checks if devices on the bus which the CardBus bridge bridges to would be
    1071                 :            :  * invisible during PCI scans because of a misconfigured subordinate number
    1072                 :            :  * of the parent brige - some BIOSes seem to be too lazy to set it right.
    1073                 :            :  * Does the fixup carefully by checking how far it can go without conflicts.
    1074                 :            :  * See http://bugzilla.kernel.org/show_bug.cgi?id=2944 for more information.
    1075                 :            :  */
    1076                 :          0 : static void yenta_fixup_parent_bridge(struct pci_bus *cardbus_bridge)
    1077                 :            : {
    1078                 :          0 :         struct pci_bus *sibling;
    1079                 :          0 :         unsigned char upper_limit;
    1080                 :            :         /*
    1081                 :            :          * We only check and fix the parent bridge: All systems which need
    1082                 :            :          * this fixup that have been reviewed are laptops and the only bridge
    1083                 :            :          * which needed fixing was the parent bridge of the CardBus bridge:
    1084                 :            :          */
    1085                 :          0 :         struct pci_bus *bridge_to_fix = cardbus_bridge->parent;
    1086                 :            : 
    1087                 :            :         /* Check bus numbers are already set up correctly: */
    1088         [ #  # ]:          0 :         if (bridge_to_fix->busn_res.end >= cardbus_bridge->busn_res.end)
    1089                 :            :                 return; /* The subordinate number is ok, nothing to do */
    1090                 :            : 
    1091         [ #  # ]:          0 :         if (!bridge_to_fix->parent)
    1092                 :            :                 return; /* Root bridges are ok */
    1093                 :            : 
    1094                 :            :         /* stay within the limits of the bus range of the parent: */
    1095                 :          0 :         upper_limit = bridge_to_fix->parent->busn_res.end;
    1096                 :            : 
    1097                 :            :         /* check the bus ranges of all sibling bridges to prevent overlap */
    1098         [ #  # ]:          0 :         list_for_each_entry(sibling, &bridge_to_fix->parent->children,
    1099                 :            :                         node) {
    1100                 :            :                 /*
    1101                 :            :                  * If the sibling has a higher secondary bus number
    1102                 :            :                  * and it's secondary is equal or smaller than our
    1103                 :            :                  * current upper limit, set the new upper limit to
    1104                 :            :                  * the bus number below the sibling's range:
    1105                 :            :                  */
    1106         [ #  # ]:          0 :                 if (sibling->busn_res.start > bridge_to_fix->busn_res.end
    1107         [ #  # ]:          0 :                     && sibling->busn_res.start <= upper_limit)
    1108                 :          0 :                         upper_limit = sibling->busn_res.start - 1;
    1109                 :            :         }
    1110                 :            : 
    1111                 :            :         /* Show that the wanted subordinate number is not possible: */
    1112         [ #  # ]:          0 :         if (cardbus_bridge->busn_res.end > upper_limit)
    1113                 :          0 :                 dev_warn(&cardbus_bridge->dev,
    1114                 :            :                          "Upper limit for fixing this bridge's parent bridge: #%02x\n",
    1115                 :            :                          upper_limit);
    1116                 :            : 
    1117                 :            :         /* If we have room to increase the bridge's subordinate number, */
    1118         [ #  # ]:          0 :         if (bridge_to_fix->busn_res.end < upper_limit) {
    1119                 :            : 
    1120                 :            :                 /* use the highest number of the hidden bus, within limits */
    1121                 :          0 :                 unsigned char subordinate_to_assign =
    1122                 :          0 :                         min_t(int, cardbus_bridge->busn_res.end, upper_limit);
    1123                 :            : 
    1124                 :          0 :                 dev_info(&bridge_to_fix->dev,
    1125                 :            :                          "Raising subordinate bus# of parent bus (#%02x) from #%02x to #%02x\n",
    1126                 :            :                          bridge_to_fix->number,
    1127                 :            :                          (int)bridge_to_fix->busn_res.end,
    1128                 :            :                          subordinate_to_assign);
    1129                 :            : 
    1130                 :            :                 /* Save the new subordinate in the bus struct of the bridge */
    1131                 :          0 :                 bridge_to_fix->busn_res.end = subordinate_to_assign;
    1132                 :            : 
    1133                 :            :                 /* and update the PCI config space with the new subordinate */
    1134                 :          0 :                 pci_write_config_byte(bridge_to_fix->self,
    1135                 :            :                         PCI_SUBORDINATE_BUS, bridge_to_fix->busn_res.end);
    1136                 :            :         }
    1137                 :            : }
    1138                 :            : 
    1139                 :            : /*
    1140                 :            :  * Initialize a cardbus controller. Make sure we have a usable
    1141                 :            :  * interrupt, and that we can map the cardbus area. Fill in the
    1142                 :            :  * socket information structure..
    1143                 :            :  */
    1144                 :          0 : static int yenta_probe(struct pci_dev *dev, const struct pci_device_id *id)
    1145                 :            : {
    1146                 :          0 :         struct yenta_socket *socket;
    1147                 :          0 :         int ret;
    1148                 :            : 
    1149                 :            :         /*
    1150                 :            :          * If we failed to assign proper bus numbers for this cardbus
    1151                 :            :          * controller during PCI probe, its subordinate pci_bus is NULL.
    1152                 :            :          * Bail out if so.
    1153                 :            :          */
    1154         [ #  # ]:          0 :         if (!dev->subordinate) {
    1155                 :          0 :                 dev_err(&dev->dev, "no bus associated! (try 'pci=assign-busses')\n");
    1156                 :          0 :                 return -ENODEV;
    1157                 :            :         }
    1158                 :            : 
    1159                 :          0 :         socket = kzalloc(sizeof(struct yenta_socket), GFP_KERNEL);
    1160         [ #  # ]:          0 :         if (!socket)
    1161                 :            :                 return -ENOMEM;
    1162                 :            : 
    1163                 :            :         /* prepare pcmcia_socket */
    1164                 :          0 :         socket->socket.ops = &yenta_socket_operations;
    1165                 :          0 :         socket->socket.resource_ops = &pccard_nonstatic_ops;
    1166                 :          0 :         socket->socket.dev.parent = &dev->dev;
    1167                 :          0 :         socket->socket.driver_data = socket;
    1168                 :          0 :         socket->socket.owner = THIS_MODULE;
    1169                 :          0 :         socket->socket.features = SS_CAP_PAGE_REGS | SS_CAP_PCCARD;
    1170                 :          0 :         socket->socket.map_size = 0x1000;
    1171                 :          0 :         socket->socket.cb_dev = dev;
    1172                 :            : 
    1173                 :            :         /* prepare struct yenta_socket */
    1174                 :          0 :         socket->dev = dev;
    1175                 :          0 :         pci_set_drvdata(dev, socket);
    1176                 :            : 
    1177                 :            :         /*
    1178                 :            :          * Do some basic sanity checking..
    1179                 :            :          */
    1180         [ #  # ]:          0 :         if (pci_enable_device(dev)) {
    1181                 :          0 :                 ret = -EBUSY;
    1182                 :          0 :                 goto free;
    1183                 :            :         }
    1184                 :            : 
    1185                 :          0 :         ret = pci_request_regions(dev, "yenta_socket");
    1186         [ #  # ]:          0 :         if (ret)
    1187                 :          0 :                 goto disable;
    1188                 :            : 
    1189         [ #  # ]:          0 :         if (!pci_resource_start(dev, 0)) {
    1190                 :          0 :                 dev_err(&dev->dev, "No cardbus resource!\n");
    1191                 :          0 :                 ret = -ENODEV;
    1192                 :          0 :                 goto release;
    1193                 :            :         }
    1194                 :            : 
    1195                 :            :         /*
    1196                 :            :          * Ok, start setup.. Map the cardbus registers,
    1197                 :            :          * and request the IRQ.
    1198                 :            :          */
    1199                 :          0 :         socket->base = ioremap(pci_resource_start(dev, 0), 0x1000);
    1200         [ #  # ]:          0 :         if (!socket->base) {
    1201                 :          0 :                 ret = -ENOMEM;
    1202                 :          0 :                 goto release;
    1203                 :            :         }
    1204                 :            : 
    1205                 :            :         /*
    1206                 :            :          * report the subsystem vendor and device for help debugging
    1207                 :            :          * the irq stuff...
    1208                 :            :          */
    1209                 :          0 :         dev_info(&dev->dev, "CardBus bridge found [%04x:%04x]\n",
    1210                 :            :                  dev->subsystem_vendor, dev->subsystem_device);
    1211                 :            : 
    1212                 :          0 :         yenta_config_init(socket);
    1213                 :            : 
    1214                 :            :         /* Disable all events */
    1215                 :          0 :         cb_writel(socket, CB_SOCKET_MASK, 0x0);
    1216                 :            : 
    1217                 :            :         /* Set up the bridge regions.. */
    1218                 :          0 :         yenta_allocate_resources(socket);
    1219                 :            : 
    1220                 :          0 :         socket->cb_irq = dev->irq;
    1221                 :            : 
    1222                 :            :         /* Do we have special options for the device? */
    1223         [ #  # ]:          0 :         if (id->driver_data != CARDBUS_TYPE_DEFAULT &&
    1224                 :            :             id->driver_data < ARRAY_SIZE(cardbus_type)) {
    1225                 :          0 :                 socket->type = &cardbus_type[id->driver_data];
    1226                 :            : 
    1227                 :          0 :                 ret = socket->type->override(socket);
    1228         [ #  # ]:          0 :                 if (ret < 0)
    1229                 :          0 :                         goto unmap;
    1230                 :            :         }
    1231                 :            : 
    1232                 :            :         /* We must finish initialization here */
    1233                 :            : 
    1234   [ #  #  #  # ]:          0 :         if (!socket->cb_irq || request_irq(socket->cb_irq, yenta_interrupt, IRQF_SHARED, "yenta", socket)) {
    1235                 :            :                 /* No IRQ or request_irq failed. Poll */
    1236                 :          0 :                 socket->cb_irq = 0; /* But zero is a valid IRQ number. */
    1237                 :          0 :                 timer_setup(&socket->poll_timer, yenta_interrupt_wrapper, 0);
    1238                 :          0 :                 mod_timer(&socket->poll_timer, jiffies + HZ);
    1239                 :          0 :                 dev_info(&dev->dev,
    1240                 :            :                          "no PCI IRQ, CardBus support disabled for this socket.\n");
    1241                 :          0 :                 dev_info(&dev->dev,
    1242                 :            :                          "check your BIOS CardBus, BIOS IRQ or ACPI settings.\n");
    1243                 :            :         } else {
    1244                 :          0 :                 socket->socket.features |= SS_CAP_CARDBUS;
    1245                 :            :         }
    1246                 :            : 
    1247                 :            :         /* Figure out what the dang thing can do for the PCMCIA layer... */
    1248                 :          0 :         yenta_interrogate(socket);
    1249                 :          0 :         yenta_get_socket_capabilities(socket, isa_interrupts);
    1250                 :          0 :         dev_info(&dev->dev, "Socket status: %08x\n",
    1251                 :            :                  cb_readl(socket, CB_SOCKET_STATE));
    1252                 :            : 
    1253                 :          0 :         yenta_fixup_parent_bridge(dev->subordinate);
    1254                 :            : 
    1255                 :            :         /* Register it with the pcmcia layer.. */
    1256                 :          0 :         ret = pcmcia_register_socket(&socket->socket);
    1257         [ #  # ]:          0 :         if (ret)
    1258                 :          0 :                 goto free_irq;
    1259                 :            : 
    1260                 :            :         /* Add the yenta register attributes */
    1261                 :          0 :         ret = device_create_file(&dev->dev, &dev_attr_yenta_registers);
    1262         [ #  # ]:          0 :         if (ret)
    1263                 :          0 :                 goto unregister_socket;
    1264                 :            : 
    1265                 :            :         return ret;
    1266                 :            : 
    1267                 :            :         /* error path... */
    1268                 :            :  unregister_socket:
    1269                 :          0 :         pcmcia_unregister_socket(&socket->socket);
    1270                 :          0 :  free_irq:
    1271         [ #  # ]:          0 :         if (socket->cb_irq)
    1272                 :          0 :                 free_irq(socket->cb_irq, socket);
    1273                 :            :         else
    1274                 :          0 :                 del_timer_sync(&socket->poll_timer);
    1275                 :          0 :  unmap:
    1276                 :          0 :         iounmap(socket->base);
    1277                 :          0 :         yenta_free_resources(socket);
    1278                 :          0 :  release:
    1279                 :          0 :         pci_release_regions(dev);
    1280                 :          0 :  disable:
    1281                 :          0 :         pci_disable_device(dev);
    1282                 :          0 :  free:
    1283                 :          0 :         pci_set_drvdata(dev, NULL);
    1284                 :          0 :         kfree(socket);
    1285                 :          0 :         return ret;
    1286                 :            : }
    1287                 :            : 
    1288                 :            : #ifdef CONFIG_PM
    1289                 :          0 : static int yenta_dev_suspend_noirq(struct device *dev)
    1290                 :            : {
    1291                 :          0 :         struct pci_dev *pdev = to_pci_dev(dev);
    1292         [ #  # ]:          0 :         struct yenta_socket *socket = pci_get_drvdata(pdev);
    1293                 :            : 
    1294         [ #  # ]:          0 :         if (!socket)
    1295                 :            :                 return 0;
    1296                 :            : 
    1297   [ #  #  #  # ]:          0 :         if (socket->type && socket->type->save_state)
    1298                 :          0 :                 socket->type->save_state(socket);
    1299                 :            : 
    1300                 :          0 :         pci_save_state(pdev);
    1301                 :          0 :         pci_read_config_dword(pdev, 16*4, &socket->saved_state[0]);
    1302                 :          0 :         pci_read_config_dword(pdev, 17*4, &socket->saved_state[1]);
    1303                 :          0 :         pci_disable_device(pdev);
    1304                 :            : 
    1305                 :          0 :         return 0;
    1306                 :            : }
    1307                 :            : 
    1308                 :          0 : static int yenta_dev_resume_noirq(struct device *dev)
    1309                 :            : {
    1310                 :          0 :         struct pci_dev *pdev = to_pci_dev(dev);
    1311         [ #  # ]:          0 :         struct yenta_socket *socket = pci_get_drvdata(pdev);
    1312                 :          0 :         int ret;
    1313                 :            : 
    1314         [ #  # ]:          0 :         if (!socket)
    1315                 :            :                 return 0;
    1316                 :            : 
    1317                 :          0 :         pci_write_config_dword(pdev, 16*4, socket->saved_state[0]);
    1318                 :          0 :         pci_write_config_dword(pdev, 17*4, socket->saved_state[1]);
    1319                 :            : 
    1320                 :          0 :         ret = pci_enable_device(pdev);
    1321         [ #  # ]:          0 :         if (ret)
    1322                 :            :                 return ret;
    1323                 :            : 
    1324                 :          0 :         pci_set_master(pdev);
    1325                 :            : 
    1326   [ #  #  #  # ]:          0 :         if (socket->type && socket->type->restore_state)
    1327                 :          0 :                 socket->type->restore_state(socket);
    1328                 :            : 
    1329                 :            :         return 0;
    1330                 :            : }
    1331                 :            : 
    1332                 :            : static const struct dev_pm_ops yenta_pm_ops = {
    1333                 :            :         .suspend_noirq = yenta_dev_suspend_noirq,
    1334                 :            :         .resume_noirq = yenta_dev_resume_noirq,
    1335                 :            :         .freeze_noirq = yenta_dev_suspend_noirq,
    1336                 :            :         .thaw_noirq = yenta_dev_resume_noirq,
    1337                 :            :         .poweroff_noirq = yenta_dev_suspend_noirq,
    1338                 :            :         .restore_noirq = yenta_dev_resume_noirq,
    1339                 :            : };
    1340                 :            : 
    1341                 :            : #define YENTA_PM_OPS    (&yenta_pm_ops)
    1342                 :            : #else
    1343                 :            : #define YENTA_PM_OPS    NULL
    1344                 :            : #endif
    1345                 :            : 
    1346                 :            : #define CB_ID(vend, dev, type)                          \
    1347                 :            :         {                                               \
    1348                 :            :                 .vendor         = vend,                 \
    1349                 :            :                 .device         = dev,                  \
    1350                 :            :                 .subvendor      = PCI_ANY_ID,           \
    1351                 :            :                 .subdevice      = PCI_ANY_ID,           \
    1352                 :            :                 .class          = PCI_CLASS_BRIDGE_CARDBUS << 8, \
    1353                 :            :                 .class_mask     = ~0,                   \
    1354                 :            :                 .driver_data    = CARDBUS_TYPE_##type,  \
    1355                 :            :         }
    1356                 :            : 
    1357                 :            : static const struct pci_device_id yenta_table[] = {
    1358                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1031, TI),
    1359                 :            : 
    1360                 :            :         /*
    1361                 :            :          * TBD: Check if these TI variants can use more
    1362                 :            :          * advanced overrides instead.  (I can't get the
    1363                 :            :          * data sheets for these devices. --rmk)
    1364                 :            :          */
    1365                 :            : #ifdef CONFIG_YENTA_TI
    1366                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1210, TI),
    1367                 :            : 
    1368                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1130, TI113X),
    1369                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1131, TI113X),
    1370                 :            : 
    1371                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1211, TI12XX),
    1372                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1220, TI12XX),
    1373                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1221, TI12XX),
    1374                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1225, TI12XX),
    1375                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251A, TI12XX),
    1376                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251B, TI12XX),
    1377                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1420, TI12XX),
    1378                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1450, TI12XX),
    1379                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1451A, TI12XX),
    1380                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1510, TI12XX),
    1381                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1520, TI12XX),
    1382                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1620, TI12XX),
    1383                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4410, TI12XX),
    1384                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4450, TI12XX),
    1385                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4451, TI12XX),
    1386                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4510, TI12XX),
    1387                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4520, TI12XX),
    1388                 :            : 
    1389                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1250, TI1250),
    1390                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1410, TI1250),
    1391                 :            : 
    1392                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11, TI12XX),
    1393                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X515, TI12XX),
    1394                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12, TI12XX),
    1395                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X420, TI12XX),
    1396                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X620, TI12XX),
    1397                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7410, TI12XX),
    1398                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7510, TI12XX),
    1399                 :            :         CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7610, TI12XX),
    1400                 :            : 
    1401                 :            :         CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_710, ENE),
    1402                 :            :         CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_712, ENE),
    1403                 :            :         CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_720, ENE),
    1404                 :            :         CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_722, ENE),
    1405                 :            :         CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1211, ENE),
    1406                 :            :         CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1225, ENE),
    1407                 :            :         CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1410, ENE),
    1408                 :            :         CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1420, ENE),
    1409                 :            : #endif /* CONFIG_YENTA_TI */
    1410                 :            : 
    1411                 :            : #ifdef CONFIG_YENTA_RICOH
    1412                 :            :         CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C465, RICOH),
    1413                 :            :         CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C466, RICOH),
    1414                 :            :         CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C475, RICOH),
    1415                 :            :         CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, RICOH),
    1416                 :            :         CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C478, RICOH),
    1417                 :            : #endif
    1418                 :            : 
    1419                 :            : #ifdef CONFIG_YENTA_TOSHIBA
    1420                 :            :         CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC95, TOPIC95),
    1421                 :            :         CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC97, TOPIC97),
    1422                 :            :         CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC100, TOPIC97),
    1423                 :            : #endif
    1424                 :            : 
    1425                 :            : #ifdef CONFIG_YENTA_O2
    1426                 :            :         CB_ID(PCI_VENDOR_ID_O2, PCI_ANY_ID, O2MICRO),
    1427                 :            : #endif
    1428                 :            : 
    1429                 :            :         /* match any cardbus bridge */
    1430                 :            :         CB_ID(PCI_ANY_ID, PCI_ANY_ID, DEFAULT),
    1431                 :            :         { /* all zeroes */ }
    1432                 :            : };
    1433                 :            : MODULE_DEVICE_TABLE(pci, yenta_table);
    1434                 :            : 
    1435                 :            : 
    1436                 :            : static struct pci_driver yenta_cardbus_driver = {
    1437                 :            :         .name           = "yenta_cardbus",
    1438                 :            :         .id_table       = yenta_table,
    1439                 :            :         .probe          = yenta_probe,
    1440                 :            :         .remove         = yenta_close,
    1441                 :            :         .driver.pm      = YENTA_PM_OPS,
    1442                 :            : };
    1443                 :            : 
    1444                 :         11 : module_pci_driver(yenta_cardbus_driver);
    1445                 :            : 
    1446                 :            : MODULE_LICENSE("GPL");

Generated by: LCOV version 1.14