11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Regular cardbus driver ("yenta_socket") 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * (C) Copyright 1999, 2000 Linus Torvalds 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Changelog: 71da177e4SLinus Torvalds * Aug 2002: Manfred Spraul <manfred@colorfullife.com> 81da177e4SLinus Torvalds * Dynamically adjust the size of the bridge resource 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * May 2003: Dominik Brodowski <linux@brodo.de> 111da177e4SLinus Torvalds * Merge pci_socket.c and yenta.c into one file 121da177e4SLinus Torvalds */ 131da177e4SLinus Torvalds #include <linux/init.h> 141da177e4SLinus Torvalds #include <linux/pci.h> 151da177e4SLinus Torvalds #include <linux/workqueue.h> 161da177e4SLinus Torvalds #include <linux/interrupt.h> 171da177e4SLinus Torvalds #include <linux/delay.h> 181da177e4SLinus Torvalds #include <linux/module.h> 199fea84f4SDominik Brodowski #include <linux/io.h> 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds #include <pcmcia/cs_types.h> 221da177e4SLinus Torvalds #include <pcmcia/ss.h> 231da177e4SLinus Torvalds #include <pcmcia/cs.h> 241da177e4SLinus Torvalds 251da177e4SLinus Torvalds #include "yenta_socket.h" 261da177e4SLinus Torvalds #include "i82365.h" 271da177e4SLinus Torvalds 281da177e4SLinus Torvalds static int disable_clkrun; 291da177e4SLinus Torvalds module_param(disable_clkrun, bool, 0444); 301da177e4SLinus Torvalds MODULE_PARM_DESC(disable_clkrun, "If PC card doesn't function properly, please try this option"); 311da177e4SLinus Torvalds 32fa912bcbSDaniel Ritz static int isa_probe = 1; 33fa912bcbSDaniel Ritz module_param(isa_probe, bool, 0444); 34fa912bcbSDaniel Ritz MODULE_PARM_DESC(isa_probe, "If set ISA interrupts are probed (default). Set to N to disable probing"); 35fa912bcbSDaniel Ritz 36fa912bcbSDaniel Ritz static int pwr_irqs_off; 37fa912bcbSDaniel Ritz module_param(pwr_irqs_off, bool, 0644); 38fa912bcbSDaniel Ritz MODULE_PARM_DESC(pwr_irqs_off, "Force IRQs off during power-on of slot. Use only when seeing IRQ storms!"); 39fa912bcbSDaniel Ritz 4035169529SWolfram Sang static char o2_speedup[] = "default"; 4135169529SWolfram Sang module_param_string(o2_speedup, o2_speedup, sizeof(o2_speedup), 0444); 4235169529SWolfram Sang MODULE_PARM_DESC(o2_speedup, "Use prefetch/burst for O2-bridges: 'on', 'off' " 4335169529SWolfram Sang "or 'default' (uses recommended behaviour for the detected bridge)"); 4435169529SWolfram Sang 45dd797d81SDominik Brodowski #define debug(x, s, args...) dev_dbg(&s->dev->dev, x, ##args) 461da177e4SLinus Torvalds 471da177e4SLinus Torvalds /* Don't ask.. */ 481da177e4SLinus Torvalds #define to_cycles(ns) ((ns)/120) 491da177e4SLinus Torvalds #define to_ns(cycles) ((cycles)*120) 501da177e4SLinus Torvalds 5178187865SRandy Dunlap /* 5263e7ebd0SDaniel Ritz * yenta PCI irq probing. 5363e7ebd0SDaniel Ritz * currently only used in the TI/EnE initialization code 5463e7ebd0SDaniel Ritz */ 5563e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 561da177e4SLinus Torvalds static int yenta_probe_cb_irq(struct yenta_socket *socket); 5763e7ebd0SDaniel Ritz #endif 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds 601da177e4SLinus Torvalds static unsigned int override_bios; 611da177e4SLinus Torvalds module_param(override_bios, uint, 0000); 621da177e4SLinus Torvalds MODULE_PARM_DESC(override_bios, "yenta ignore bios resource allocation"); 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds /* 651da177e4SLinus Torvalds * Generate easy-to-use ways of reading a cardbus sockets 661da177e4SLinus Torvalds * regular memory space ("cb_xxx"), configuration space 671da177e4SLinus Torvalds * ("config_xxx") and compatibility space ("exca_xxxx") 681da177e4SLinus Torvalds */ 691da177e4SLinus Torvalds static inline u32 cb_readl(struct yenta_socket *socket, unsigned reg) 701da177e4SLinus Torvalds { 711da177e4SLinus Torvalds u32 val = readl(socket->base + reg); 72dd797d81SDominik Brodowski debug("%04x %08x\n", socket, reg, val); 731da177e4SLinus Torvalds return val; 741da177e4SLinus Torvalds } 751da177e4SLinus Torvalds 761da177e4SLinus Torvalds static inline void cb_writel(struct yenta_socket *socket, unsigned reg, u32 val) 771da177e4SLinus Torvalds { 78dd797d81SDominik Brodowski debug("%04x %08x\n", socket, reg, val); 791da177e4SLinus Torvalds writel(val, socket->base + reg); 80c8751e4cSDaniel Ritz readl(socket->base + reg); /* avoid problems with PCI write posting */ 811da177e4SLinus Torvalds } 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds static inline u8 config_readb(struct yenta_socket *socket, unsigned offset) 841da177e4SLinus Torvalds { 851da177e4SLinus Torvalds u8 val; 861da177e4SLinus Torvalds pci_read_config_byte(socket->dev, offset, &val); 87dd797d81SDominik Brodowski debug("%04x %02x\n", socket, offset, val); 881da177e4SLinus Torvalds return val; 891da177e4SLinus Torvalds } 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds static inline u16 config_readw(struct yenta_socket *socket, unsigned offset) 921da177e4SLinus Torvalds { 931da177e4SLinus Torvalds u16 val; 941da177e4SLinus Torvalds pci_read_config_word(socket->dev, offset, &val); 95dd797d81SDominik Brodowski debug("%04x %04x\n", socket, offset, val); 961da177e4SLinus Torvalds return val; 971da177e4SLinus Torvalds } 981da177e4SLinus Torvalds 991da177e4SLinus Torvalds static inline u32 config_readl(struct yenta_socket *socket, unsigned offset) 1001da177e4SLinus Torvalds { 1011da177e4SLinus Torvalds u32 val; 1021da177e4SLinus Torvalds pci_read_config_dword(socket->dev, offset, &val); 103dd797d81SDominik Brodowski debug("%04x %08x\n", socket, offset, val); 1041da177e4SLinus Torvalds return val; 1051da177e4SLinus Torvalds } 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds static inline void config_writeb(struct yenta_socket *socket, unsigned offset, u8 val) 1081da177e4SLinus Torvalds { 109dd797d81SDominik Brodowski debug("%04x %02x\n", socket, offset, val); 1101da177e4SLinus Torvalds pci_write_config_byte(socket->dev, offset, val); 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds static inline void config_writew(struct yenta_socket *socket, unsigned offset, u16 val) 1141da177e4SLinus Torvalds { 115dd797d81SDominik Brodowski debug("%04x %04x\n", socket, offset, val); 1161da177e4SLinus Torvalds pci_write_config_word(socket->dev, offset, val); 1171da177e4SLinus Torvalds } 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds static inline void config_writel(struct yenta_socket *socket, unsigned offset, u32 val) 1201da177e4SLinus Torvalds { 121dd797d81SDominik Brodowski debug("%04x %08x\n", socket, offset, val); 1221da177e4SLinus Torvalds pci_write_config_dword(socket->dev, offset, val); 1231da177e4SLinus Torvalds } 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds static inline u8 exca_readb(struct yenta_socket *socket, unsigned reg) 1261da177e4SLinus Torvalds { 1271da177e4SLinus Torvalds u8 val = readb(socket->base + 0x800 + reg); 128dd797d81SDominik Brodowski debug("%04x %02x\n", socket, reg, val); 1291da177e4SLinus Torvalds return val; 1301da177e4SLinus Torvalds } 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds static inline u8 exca_readw(struct yenta_socket *socket, unsigned reg) 1331da177e4SLinus Torvalds { 1341da177e4SLinus Torvalds u16 val; 1351da177e4SLinus Torvalds val = readb(socket->base + 0x800 + reg); 1361da177e4SLinus Torvalds val |= readb(socket->base + 0x800 + reg + 1) << 8; 137dd797d81SDominik Brodowski debug("%04x %04x\n", socket, reg, val); 1381da177e4SLinus Torvalds return val; 1391da177e4SLinus Torvalds } 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds static inline void exca_writeb(struct yenta_socket *socket, unsigned reg, u8 val) 1421da177e4SLinus Torvalds { 143dd797d81SDominik Brodowski debug("%04x %02x\n", socket, reg, val); 1441da177e4SLinus Torvalds writeb(val, socket->base + 0x800 + reg); 145c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg); /* PCI write posting... */ 1461da177e4SLinus Torvalds } 1471da177e4SLinus Torvalds 1481da177e4SLinus Torvalds static void exca_writew(struct yenta_socket *socket, unsigned reg, u16 val) 1491da177e4SLinus Torvalds { 150dd797d81SDominik Brodowski debug("%04x %04x\n", socket, reg, val); 1511da177e4SLinus Torvalds writeb(val, socket->base + 0x800 + reg); 1521da177e4SLinus Torvalds writeb(val >> 8, socket->base + 0x800 + reg + 1); 153c8751e4cSDaniel Ritz 154c8751e4cSDaniel Ritz /* PCI write posting... */ 155c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg); 156c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg + 1); 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds 159030ee39cSLinus Torvalds static ssize_t show_yenta_registers(struct device *yentadev, struct device_attribute *attr, char *buf) 160030ee39cSLinus Torvalds { 161030ee39cSLinus Torvalds struct pci_dev *dev = to_pci_dev(yentadev); 162030ee39cSLinus Torvalds struct yenta_socket *socket = pci_get_drvdata(dev); 163030ee39cSLinus Torvalds int offset = 0, i; 164030ee39cSLinus Torvalds 165030ee39cSLinus Torvalds offset = snprintf(buf, PAGE_SIZE, "CB registers:"); 166030ee39cSLinus Torvalds for (i = 0; i < 0x24; i += 4) { 167030ee39cSLinus Torvalds unsigned val; 168030ee39cSLinus Torvalds if (!(i & 15)) 169030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i); 170030ee39cSLinus Torvalds val = cb_readl(socket, i); 171030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, " %08x", val); 172030ee39cSLinus Torvalds } 173030ee39cSLinus Torvalds 174030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n\nExCA registers:"); 175030ee39cSLinus Torvalds for (i = 0; i < 0x45; i++) { 176030ee39cSLinus Torvalds unsigned char val; 177030ee39cSLinus Torvalds if (!(i & 7)) { 178030ee39cSLinus Torvalds if (i & 8) { 179030ee39cSLinus Torvalds memcpy(buf + offset, " -", 2); 180030ee39cSLinus Torvalds offset += 2; 181030ee39cSLinus Torvalds } else 182030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i); 183030ee39cSLinus Torvalds } 184030ee39cSLinus Torvalds val = exca_readb(socket, i); 185030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, " %02x", val); 186030ee39cSLinus Torvalds } 187030ee39cSLinus Torvalds buf[offset++] = '\n'; 188030ee39cSLinus Torvalds return offset; 189030ee39cSLinus Torvalds } 190030ee39cSLinus Torvalds 191030ee39cSLinus Torvalds static DEVICE_ATTR(yenta_registers, S_IRUSR, show_yenta_registers, NULL); 192030ee39cSLinus Torvalds 1931da177e4SLinus Torvalds /* 1941da177e4SLinus Torvalds * Ugh, mixed-mode cardbus and 16-bit pccard state: things depend 1951da177e4SLinus Torvalds * on what kind of card is inserted.. 1961da177e4SLinus Torvalds */ 1971da177e4SLinus Torvalds static int yenta_get_status(struct pcmcia_socket *sock, unsigned int *value) 1981da177e4SLinus Torvalds { 1991da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 2001da177e4SLinus Torvalds unsigned int val; 2011da177e4SLinus Torvalds u32 state = cb_readl(socket, CB_SOCKET_STATE); 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds val = (state & CB_3VCARD) ? SS_3VCARD : 0; 2041da177e4SLinus Torvalds val |= (state & CB_XVCARD) ? SS_XVCARD : 0; 205fa912bcbSDaniel Ritz val |= (state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) ? 0 : SS_PENDING; 206fa912bcbSDaniel Ritz val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? SS_PENDING : 0; 207fa912bcbSDaniel Ritz 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds if (state & CB_CBCARD) { 2101da177e4SLinus Torvalds val |= SS_CARDBUS; 2111da177e4SLinus Torvalds val |= (state & CB_CARDSTS) ? SS_STSCHG : 0; 2121da177e4SLinus Torvalds val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? 0 : SS_DETECT; 2131da177e4SLinus Torvalds val |= (state & CB_PWRCYCLE) ? SS_POWERON | SS_READY : 0; 214fa912bcbSDaniel Ritz } else if (state & CB_16BITCARD) { 2151da177e4SLinus Torvalds u8 status = exca_readb(socket, I365_STATUS); 2161da177e4SLinus Torvalds val |= ((status & I365_CS_DETECT) == I365_CS_DETECT) ? SS_DETECT : 0; 2171da177e4SLinus Torvalds if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { 2181da177e4SLinus Torvalds val |= (status & I365_CS_STSCHG) ? 0 : SS_STSCHG; 2191da177e4SLinus Torvalds } else { 2201da177e4SLinus Torvalds val |= (status & I365_CS_BVD1) ? 0 : SS_BATDEAD; 2211da177e4SLinus Torvalds val |= (status & I365_CS_BVD2) ? 0 : SS_BATWARN; 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds val |= (status & I365_CS_WRPROT) ? SS_WRPROT : 0; 2241da177e4SLinus Torvalds val |= (status & I365_CS_READY) ? SS_READY : 0; 2251da177e4SLinus Torvalds val |= (status & I365_CS_POWERON) ? SS_POWERON : 0; 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds *value = val; 2291da177e4SLinus Torvalds return 0; 2301da177e4SLinus Torvalds } 2311da177e4SLinus Torvalds 2321da177e4SLinus Torvalds static void yenta_set_power(struct yenta_socket *socket, socket_state_t *state) 2331da177e4SLinus Torvalds { 234ea2f1590SDaniel Ritz /* some birdges require to use the ExCA registers to power 16bit cards */ 235ea2f1590SDaniel Ritz if (!(cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) && 236ea2f1590SDaniel Ritz (socket->flags & YENTA_16BIT_POWER_EXCA)) { 237ea2f1590SDaniel Ritz u8 reg, old; 238ea2f1590SDaniel Ritz reg = old = exca_readb(socket, I365_POWER); 239ea2f1590SDaniel Ritz reg &= ~(I365_VCC_MASK | I365_VPP1_MASK | I365_VPP2_MASK); 240ea2f1590SDaniel Ritz 241ea2f1590SDaniel Ritz /* i82365SL-DF style */ 242ea2f1590SDaniel Ritz if (socket->flags & YENTA_16BIT_POWER_DF) { 243ea2f1590SDaniel Ritz switch (state->Vcc) { 2449fea84f4SDominik Brodowski case 33: 2459fea84f4SDominik Brodowski reg |= I365_VCC_3V; 2469fea84f4SDominik Brodowski break; 2479fea84f4SDominik Brodowski case 50: 2489fea84f4SDominik Brodowski reg |= I365_VCC_5V; 2499fea84f4SDominik Brodowski break; 2509fea84f4SDominik Brodowski default: 2519fea84f4SDominik Brodowski reg = 0; 2529fea84f4SDominik Brodowski break; 253ea2f1590SDaniel Ritz } 254ea2f1590SDaniel Ritz switch (state->Vpp) { 255ea2f1590SDaniel Ritz case 33: 2569fea84f4SDominik Brodowski case 50: 2579fea84f4SDominik Brodowski reg |= I365_VPP1_5V; 2589fea84f4SDominik Brodowski break; 2599fea84f4SDominik Brodowski case 120: 2609fea84f4SDominik Brodowski reg |= I365_VPP1_12V; 2619fea84f4SDominik Brodowski break; 262ea2f1590SDaniel Ritz } 263ea2f1590SDaniel Ritz } else { 264ea2f1590SDaniel Ritz /* i82365SL-B style */ 265ea2f1590SDaniel Ritz switch (state->Vcc) { 2669fea84f4SDominik Brodowski case 50: 2679fea84f4SDominik Brodowski reg |= I365_VCC_5V; 2689fea84f4SDominik Brodowski break; 2699fea84f4SDominik Brodowski default: 2709fea84f4SDominik Brodowski reg = 0; 2719fea84f4SDominik Brodowski break; 272ea2f1590SDaniel Ritz } 273ea2f1590SDaniel Ritz switch (state->Vpp) { 2749fea84f4SDominik Brodowski case 50: 2759fea84f4SDominik Brodowski reg |= I365_VPP1_5V | I365_VPP2_5V; 2769fea84f4SDominik Brodowski break; 2779fea84f4SDominik Brodowski case 120: 2789fea84f4SDominik Brodowski reg |= I365_VPP1_12V | I365_VPP2_12V; 2799fea84f4SDominik Brodowski break; 280ea2f1590SDaniel Ritz } 281ea2f1590SDaniel Ritz } 282ea2f1590SDaniel Ritz 283ea2f1590SDaniel Ritz if (reg != old) 284ea2f1590SDaniel Ritz exca_writeb(socket, I365_POWER, reg); 285ea2f1590SDaniel Ritz } else { 2861da177e4SLinus Torvalds u32 reg = 0; /* CB_SC_STPCLK? */ 2871da177e4SLinus Torvalds switch (state->Vcc) { 2889fea84f4SDominik Brodowski case 33: 2899fea84f4SDominik Brodowski reg = CB_SC_VCC_3V; 2909fea84f4SDominik Brodowski break; 2919fea84f4SDominik Brodowski case 50: 2929fea84f4SDominik Brodowski reg = CB_SC_VCC_5V; 2939fea84f4SDominik Brodowski break; 2949fea84f4SDominik Brodowski default: 2959fea84f4SDominik Brodowski reg = 0; 2969fea84f4SDominik Brodowski break; 2971da177e4SLinus Torvalds } 2981da177e4SLinus Torvalds switch (state->Vpp) { 2999fea84f4SDominik Brodowski case 33: 3009fea84f4SDominik Brodowski reg |= CB_SC_VPP_3V; 3019fea84f4SDominik Brodowski break; 3029fea84f4SDominik Brodowski case 50: 3039fea84f4SDominik Brodowski reg |= CB_SC_VPP_5V; 3049fea84f4SDominik Brodowski break; 3059fea84f4SDominik Brodowski case 120: 3069fea84f4SDominik Brodowski reg |= CB_SC_VPP_12V; 3079fea84f4SDominik Brodowski break; 3081da177e4SLinus Torvalds } 3091da177e4SLinus Torvalds if (reg != cb_readl(socket, CB_SOCKET_CONTROL)) 3101da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_CONTROL, reg); 3111da177e4SLinus Torvalds } 312ea2f1590SDaniel Ritz } 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds static int yenta_set_socket(struct pcmcia_socket *sock, socket_state_t *state) 3151da177e4SLinus Torvalds { 3161da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 3171da177e4SLinus Torvalds u16 bridge; 3181da177e4SLinus Torvalds 319d250a481SDaniel Ritz /* if powering down: do it immediately */ 320d250a481SDaniel Ritz if (state->Vcc == 0) 3211da177e4SLinus Torvalds yenta_set_power(socket, state); 322d250a481SDaniel Ritz 3231da177e4SLinus Torvalds socket->io_irq = state->io_irq; 3241da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL) & ~(CB_BRIDGE_CRST | CB_BRIDGE_INTR); 3251da177e4SLinus Torvalds if (cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) { 3261da177e4SLinus Torvalds u8 intr; 3271da177e4SLinus Torvalds bridge |= (state->flags & SS_RESET) ? CB_BRIDGE_CRST : 0; 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds /* ISA interrupt control? */ 3301da177e4SLinus Torvalds intr = exca_readb(socket, I365_INTCTL); 3311da177e4SLinus Torvalds intr = (intr & ~0xf); 3321da177e4SLinus Torvalds if (!socket->cb_irq) { 3331da177e4SLinus Torvalds intr |= state->io_irq; 3341da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 3351da177e4SLinus Torvalds } 3361da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, intr); 3371da177e4SLinus Torvalds } else { 3381da177e4SLinus Torvalds u8 reg; 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds reg = exca_readb(socket, I365_INTCTL) & (I365_RING_ENA | I365_INTR_ENA); 3411da177e4SLinus Torvalds reg |= (state->flags & SS_RESET) ? 0 : I365_PC_RESET; 3421da177e4SLinus Torvalds reg |= (state->flags & SS_IOCARD) ? I365_PC_IOCARD : 0; 3431da177e4SLinus Torvalds if (state->io_irq != socket->cb_irq) { 3441da177e4SLinus Torvalds reg |= state->io_irq; 3451da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 3461da177e4SLinus Torvalds } 3471da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, reg); 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds reg = exca_readb(socket, I365_POWER) & (I365_VCC_MASK|I365_VPP1_MASK); 3501da177e4SLinus Torvalds reg |= I365_PWR_NORESET; 3519fea84f4SDominik Brodowski if (state->flags & SS_PWR_AUTO) 3529fea84f4SDominik Brodowski reg |= I365_PWR_AUTO; 3539fea84f4SDominik Brodowski if (state->flags & SS_OUTPUT_ENA) 3549fea84f4SDominik Brodowski reg |= I365_PWR_OUT; 3551da177e4SLinus Torvalds if (exca_readb(socket, I365_POWER) != reg) 3561da177e4SLinus Torvalds exca_writeb(socket, I365_POWER, reg); 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds /* CSC interrupt: no ISA irq for CSC */ 3591da177e4SLinus Torvalds reg = I365_CSC_DETECT; 3601da177e4SLinus Torvalds if (state->flags & SS_IOCARD) { 3619fea84f4SDominik Brodowski if (state->csc_mask & SS_STSCHG) 3629fea84f4SDominik Brodowski reg |= I365_CSC_STSCHG; 3631da177e4SLinus Torvalds } else { 3649fea84f4SDominik Brodowski if (state->csc_mask & SS_BATDEAD) 3659fea84f4SDominik Brodowski reg |= I365_CSC_BVD1; 3669fea84f4SDominik Brodowski if (state->csc_mask & SS_BATWARN) 3679fea84f4SDominik Brodowski reg |= I365_CSC_BVD2; 3689fea84f4SDominik Brodowski if (state->csc_mask & SS_READY) 3699fea84f4SDominik Brodowski reg |= I365_CSC_READY; 3701da177e4SLinus Torvalds } 3711da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, reg); 3721da177e4SLinus Torvalds exca_readb(socket, I365_CSC); 3731da177e4SLinus Torvalds if (sock->zoom_video) 3741da177e4SLinus Torvalds sock->zoom_video(sock, state->flags & SS_ZVCARD); 3751da177e4SLinus Torvalds } 3761da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 3771da177e4SLinus Torvalds /* Socket event mask: get card insert/remove events.. */ 3781da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 3791da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK); 380d250a481SDaniel Ritz 381d250a481SDaniel Ritz /* if powering up: do it as the last step when the socket is configured */ 382d250a481SDaniel Ritz if (state->Vcc != 0) 383d250a481SDaniel Ritz yenta_set_power(socket, state); 3841da177e4SLinus Torvalds return 0; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds static int yenta_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io) 3881da177e4SLinus Torvalds { 3891da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 3901da177e4SLinus Torvalds int map; 3911da177e4SLinus Torvalds unsigned char ioctl, addr, enable; 3921da177e4SLinus Torvalds 3931da177e4SLinus Torvalds map = io->map; 3941da177e4SLinus Torvalds 3951da177e4SLinus Torvalds if (map > 1) 3961da177e4SLinus Torvalds return -EINVAL; 3971da177e4SLinus Torvalds 3981da177e4SLinus Torvalds enable = I365_ENA_IO(map); 3991da177e4SLinus Torvalds addr = exca_readb(socket, I365_ADDRWIN); 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds /* Disable the window before changing it.. */ 4021da177e4SLinus Torvalds if (addr & enable) { 4031da177e4SLinus Torvalds addr &= ~enable; 4041da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr); 4051da177e4SLinus Torvalds } 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds exca_writew(socket, I365_IO(map)+I365_W_START, io->start); 4081da177e4SLinus Torvalds exca_writew(socket, I365_IO(map)+I365_W_STOP, io->stop); 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds ioctl = exca_readb(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map); 4119fea84f4SDominik Brodowski if (io->flags & MAP_0WS) 4129fea84f4SDominik Brodowski ioctl |= I365_IOCTL_0WS(map); 4139fea84f4SDominik Brodowski if (io->flags & MAP_16BIT) 4149fea84f4SDominik Brodowski ioctl |= I365_IOCTL_16BIT(map); 4159fea84f4SDominik Brodowski if (io->flags & MAP_AUTOSZ) 4169fea84f4SDominik Brodowski ioctl |= I365_IOCTL_IOCS16(map); 4171da177e4SLinus Torvalds exca_writeb(socket, I365_IOCTL, ioctl); 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds if (io->flags & MAP_ACTIVE) 4201da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr | enable); 4211da177e4SLinus Torvalds return 0; 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds static int yenta_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem) 4251da177e4SLinus Torvalds { 4261da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 4271da177e4SLinus Torvalds struct pci_bus_region region; 4281da177e4SLinus Torvalds int map; 4291da177e4SLinus Torvalds unsigned char addr, enable; 4301da177e4SLinus Torvalds unsigned int start, stop, card_start; 4311da177e4SLinus Torvalds unsigned short word; 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds pcibios_resource_to_bus(socket->dev, ®ion, mem->res); 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds map = mem->map; 4361da177e4SLinus Torvalds start = region.start; 4371da177e4SLinus Torvalds stop = region.end; 4381da177e4SLinus Torvalds card_start = mem->card_start; 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds if (map > 4 || start > stop || ((start ^ stop) >> 24) || 4411da177e4SLinus Torvalds (card_start >> 26) || mem->speed > 1000) 4421da177e4SLinus Torvalds return -EINVAL; 4431da177e4SLinus Torvalds 4441da177e4SLinus Torvalds enable = I365_ENA_MEM(map); 4451da177e4SLinus Torvalds addr = exca_readb(socket, I365_ADDRWIN); 4461da177e4SLinus Torvalds if (addr & enable) { 4471da177e4SLinus Torvalds addr &= ~enable; 4481da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr); 4491da177e4SLinus Torvalds } 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds exca_writeb(socket, CB_MEM_PAGE(map), start >> 24); 4521da177e4SLinus Torvalds 4531da177e4SLinus Torvalds word = (start >> 12) & 0x0fff; 4541da177e4SLinus Torvalds if (mem->flags & MAP_16BIT) 4551da177e4SLinus Torvalds word |= I365_MEM_16BIT; 4561da177e4SLinus Torvalds if (mem->flags & MAP_0WS) 4571da177e4SLinus Torvalds word |= I365_MEM_0WS; 4581da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_START, word); 4591da177e4SLinus Torvalds 4601da177e4SLinus Torvalds word = (stop >> 12) & 0x0fff; 4611da177e4SLinus Torvalds switch (to_cycles(mem->speed)) { 4629fea84f4SDominik Brodowski case 0: 4639fea84f4SDominik Brodowski break; 4649fea84f4SDominik Brodowski case 1: 4659fea84f4SDominik Brodowski word |= I365_MEM_WS0; 4669fea84f4SDominik Brodowski break; 4679fea84f4SDominik Brodowski case 2: 4689fea84f4SDominik Brodowski word |= I365_MEM_WS1; 4699fea84f4SDominik Brodowski break; 4709fea84f4SDominik Brodowski default: 4719fea84f4SDominik Brodowski word |= I365_MEM_WS1 | I365_MEM_WS0; 4729fea84f4SDominik Brodowski break; 4731da177e4SLinus Torvalds } 4741da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_STOP, word); 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds word = ((card_start - start) >> 12) & 0x3fff; 4771da177e4SLinus Torvalds if (mem->flags & MAP_WRPROT) 4781da177e4SLinus Torvalds word |= I365_MEM_WRPROT; 4791da177e4SLinus Torvalds if (mem->flags & MAP_ATTRIB) 4801da177e4SLinus Torvalds word |= I365_MEM_REG; 4811da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_OFF, word); 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds if (mem->flags & MAP_ACTIVE) 4841da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr | enable); 4851da177e4SLinus Torvalds return 0; 4861da177e4SLinus Torvalds } 4871da177e4SLinus Torvalds 4881da177e4SLinus Torvalds 489fa912bcbSDaniel Ritz 4907d12e780SDavid Howells static irqreturn_t yenta_interrupt(int irq, void *dev_id) 4911da177e4SLinus Torvalds { 492fa912bcbSDaniel Ritz unsigned int events; 493fa912bcbSDaniel Ritz struct yenta_socket *socket = (struct yenta_socket *) dev_id; 4941da177e4SLinus Torvalds u8 csc; 4951da177e4SLinus Torvalds u32 cb_event; 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds /* Clear interrupt status for the event */ 4981da177e4SLinus Torvalds cb_event = cb_readl(socket, CB_SOCKET_EVENT); 4991da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, cb_event); 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds csc = exca_readb(socket, I365_CSC); 5021da177e4SLinus Torvalds 503e4115805SDaniel Ritz if (!(cb_event || csc)) 504e4115805SDaniel Ritz return IRQ_NONE; 505e4115805SDaniel Ritz 5061da177e4SLinus Torvalds events = (cb_event & (CB_CD1EVENT | CB_CD2EVENT)) ? SS_DETECT : 0 ; 5071da177e4SLinus Torvalds events |= (csc & I365_CSC_DETECT) ? SS_DETECT : 0; 5081da177e4SLinus Torvalds if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { 5091da177e4SLinus Torvalds events |= (csc & I365_CSC_STSCHG) ? SS_STSCHG : 0; 5101da177e4SLinus Torvalds } else { 5111da177e4SLinus Torvalds events |= (csc & I365_CSC_BVD1) ? SS_BATDEAD : 0; 5121da177e4SLinus Torvalds events |= (csc & I365_CSC_BVD2) ? SS_BATWARN : 0; 5131da177e4SLinus Torvalds events |= (csc & I365_CSC_READY) ? SS_READY : 0; 5141da177e4SLinus Torvalds } 5151da177e4SLinus Torvalds 516fa912bcbSDaniel Ritz if (events) 5171da177e4SLinus Torvalds pcmcia_parse_events(&socket->socket, events); 518fa912bcbSDaniel Ritz 5191da177e4SLinus Torvalds return IRQ_HANDLED; 5201da177e4SLinus Torvalds } 5211da177e4SLinus Torvalds 5221da177e4SLinus Torvalds static void yenta_interrupt_wrapper(unsigned long data) 5231da177e4SLinus Torvalds { 5241da177e4SLinus Torvalds struct yenta_socket *socket = (struct yenta_socket *) data; 5251da177e4SLinus Torvalds 5267d12e780SDavid Howells yenta_interrupt(0, (void *)socket); 5271da177e4SLinus Torvalds socket->poll_timer.expires = jiffies + HZ; 5281da177e4SLinus Torvalds add_timer(&socket->poll_timer); 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds static void yenta_clear_maps(struct yenta_socket *socket) 5321da177e4SLinus Torvalds { 5331da177e4SLinus Torvalds int i; 5341da177e4SLinus Torvalds struct resource res = { .start = 0, .end = 0x0fff }; 5351da177e4SLinus Torvalds pccard_io_map io = { 0, 0, 0, 0, 1 }; 5361da177e4SLinus Torvalds pccard_mem_map mem = { .res = &res, }; 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds yenta_set_socket(&socket->socket, &dead_socket); 5391da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 5401da177e4SLinus Torvalds io.map = i; 5411da177e4SLinus Torvalds yenta_set_io_map(&socket->socket, &io); 5421da177e4SLinus Torvalds } 5431da177e4SLinus Torvalds for (i = 0; i < 5; i++) { 5441da177e4SLinus Torvalds mem.map = i; 5451da177e4SLinus Torvalds yenta_set_mem_map(&socket->socket, &mem); 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds 549fa912bcbSDaniel Ritz /* redoes voltage interrogation if required */ 550fa912bcbSDaniel Ritz static void yenta_interrogate(struct yenta_socket *socket) 551fa912bcbSDaniel Ritz { 552fa912bcbSDaniel Ritz u32 state; 553fa912bcbSDaniel Ritz 554fa912bcbSDaniel Ritz state = cb_readl(socket, CB_SOCKET_STATE); 555fa912bcbSDaniel Ritz if (!(state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) || 556fa912bcbSDaniel Ritz (state & (CB_CDETECT1 | CB_CDETECT2 | CB_NOTACARD | CB_BADVCCREQ)) || 557fa912bcbSDaniel Ritz ((state & (CB_16BITCARD | CB_CBCARD)) == (CB_16BITCARD | CB_CBCARD))) 558fa912bcbSDaniel Ritz cb_writel(socket, CB_SOCKET_FORCE, CB_CVSTEST); 559fa912bcbSDaniel Ritz } 560fa912bcbSDaniel Ritz 5611da177e4SLinus Torvalds /* Called at resume and initialization events */ 5621da177e4SLinus Torvalds static int yenta_sock_init(struct pcmcia_socket *sock) 5631da177e4SLinus Torvalds { 5641da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds exca_writeb(socket, I365_GBLCTL, 0x00); 5671da177e4SLinus Torvalds exca_writeb(socket, I365_GENCTL, 0x00); 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds /* Redo card voltage interrogation */ 570fa912bcbSDaniel Ritz yenta_interrogate(socket); 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds yenta_clear_maps(socket); 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds if (socket->type && socket->type->sock_init) 5751da177e4SLinus Torvalds socket->type->sock_init(socket); 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds /* Re-enable CSC interrupts */ 5781da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK); 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds return 0; 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds static int yenta_sock_suspend(struct pcmcia_socket *sock) 5841da177e4SLinus Torvalds { 5851da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds /* Disable CSC interrupts */ 5881da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0x0); 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds return 0; 5911da177e4SLinus Torvalds } 5921da177e4SLinus Torvalds 5931da177e4SLinus Torvalds /* 5941da177e4SLinus Torvalds * Use an adaptive allocation for the memory resource, 5951da177e4SLinus Torvalds * sometimes the memory behind pci bridges is limited: 5961da177e4SLinus Torvalds * 1/8 of the size of the io window of the parent. 597eb0a90b4SDominik Brodowski * max 4 MB, min 16 kB. We try very hard to not get below 598eb0a90b4SDominik Brodowski * the "ACC" values, though. 5991da177e4SLinus Torvalds */ 6009fea84f4SDominik Brodowski #define BRIDGE_MEM_MAX (4*1024*1024) 6019fea84f4SDominik Brodowski #define BRIDGE_MEM_ACC (128*1024) 6029fea84f4SDominik Brodowski #define BRIDGE_MEM_MIN (16*1024) 6031da177e4SLinus Torvalds 604eb0a90b4SDominik Brodowski #define BRIDGE_IO_MAX 512 605eb0a90b4SDominik Brodowski #define BRIDGE_IO_ACC 256 6061da177e4SLinus Torvalds #define BRIDGE_IO_MIN 32 6071da177e4SLinus Torvalds 6081da177e4SLinus Torvalds #ifndef PCIBIOS_MIN_CARDBUS_IO 6091da177e4SLinus Torvalds #define PCIBIOS_MIN_CARDBUS_IO PCIBIOS_MIN_IO 6101da177e4SLinus Torvalds #endif 6111da177e4SLinus Torvalds 612eb0a90b4SDominik Brodowski static int yenta_search_one_res(struct resource *root, struct resource *res, 613eb0a90b4SDominik Brodowski u32 min) 614eb0a90b4SDominik Brodowski { 615eb0a90b4SDominik Brodowski u32 align, size, start, end; 616eb0a90b4SDominik Brodowski 617eb0a90b4SDominik Brodowski if (res->flags & IORESOURCE_IO) { 618eb0a90b4SDominik Brodowski align = 1024; 619eb0a90b4SDominik Brodowski size = BRIDGE_IO_MAX; 620eb0a90b4SDominik Brodowski start = PCIBIOS_MIN_CARDBUS_IO; 621eb0a90b4SDominik Brodowski end = ~0U; 622eb0a90b4SDominik Brodowski } else { 623eb0a90b4SDominik Brodowski unsigned long avail = root->end - root->start; 624eb0a90b4SDominik Brodowski int i; 625eb0a90b4SDominik Brodowski size = BRIDGE_MEM_MAX; 626eb0a90b4SDominik Brodowski if (size > avail/8) { 627eb0a90b4SDominik Brodowski size = (avail+1)/8; 628eb0a90b4SDominik Brodowski /* round size down to next power of 2 */ 629eb0a90b4SDominik Brodowski i = 0; 630eb0a90b4SDominik Brodowski while ((size /= 2) != 0) 631eb0a90b4SDominik Brodowski i++; 632eb0a90b4SDominik Brodowski size = 1 << i; 633eb0a90b4SDominik Brodowski } 634eb0a90b4SDominik Brodowski if (size < min) 635eb0a90b4SDominik Brodowski size = min; 636eb0a90b4SDominik Brodowski align = size; 637eb0a90b4SDominik Brodowski start = PCIBIOS_MIN_MEM; 638eb0a90b4SDominik Brodowski end = ~0U; 639eb0a90b4SDominik Brodowski } 640eb0a90b4SDominik Brodowski 641eb0a90b4SDominik Brodowski do { 642eb0a90b4SDominik Brodowski if (allocate_resource(root, res, size, start, end, align, 643eb0a90b4SDominik Brodowski NULL, NULL) == 0) { 644eb0a90b4SDominik Brodowski return 1; 645eb0a90b4SDominik Brodowski } 646eb0a90b4SDominik Brodowski size = size/2; 647eb0a90b4SDominik Brodowski align = size; 648eb0a90b4SDominik Brodowski } while (size >= min); 649eb0a90b4SDominik Brodowski 650eb0a90b4SDominik Brodowski return 0; 651eb0a90b4SDominik Brodowski } 652eb0a90b4SDominik Brodowski 653eb0a90b4SDominik Brodowski 654eb0a90b4SDominik Brodowski static int yenta_search_res(struct yenta_socket *socket, struct resource *res, 655eb0a90b4SDominik Brodowski u32 min) 656eb0a90b4SDominik Brodowski { 657eb0a90b4SDominik Brodowski int i; 658eb0a90b4SDominik Brodowski for (i = 0; i < PCI_BUS_NUM_RESOURCES; i++) { 659eb0a90b4SDominik Brodowski struct resource *root = socket->dev->bus->resource[i]; 660eb0a90b4SDominik Brodowski if (!root) 661eb0a90b4SDominik Brodowski continue; 662eb0a90b4SDominik Brodowski 663eb0a90b4SDominik Brodowski if ((res->flags ^ root->flags) & 664eb0a90b4SDominik Brodowski (IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH)) 665eb0a90b4SDominik Brodowski continue; /* Wrong type */ 666eb0a90b4SDominik Brodowski 667eb0a90b4SDominik Brodowski if (yenta_search_one_res(root, res, min)) 668eb0a90b4SDominik Brodowski return 1; 669eb0a90b4SDominik Brodowski } 670eb0a90b4SDominik Brodowski return 0; 671eb0a90b4SDominik Brodowski } 672eb0a90b4SDominik Brodowski 673b3743fa4SDominik Brodowski static int yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned type, int addr_start, int addr_end) 6741da177e4SLinus Torvalds { 675852710d9SMatthew Wilcox struct pci_dev *dev = socket->dev; 676852710d9SMatthew Wilcox struct resource *res; 67743c34735SDominik Brodowski struct pci_bus_region region; 6781da177e4SLinus Torvalds unsigned mask; 6791da177e4SLinus Torvalds 680852710d9SMatthew Wilcox res = dev->resource + PCI_BRIDGE_RESOURCES + nr; 6817925407aSIvan Kokshaysky /* Already allocated? */ 6827925407aSIvan Kokshaysky if (res->parent) 683b3743fa4SDominik Brodowski return 0; 6847925407aSIvan Kokshaysky 6851da177e4SLinus Torvalds /* The granularity of the memory limit is 4kB, on IO it's 4 bytes */ 6861da177e4SLinus Torvalds mask = ~0xfff; 6871da177e4SLinus Torvalds if (type & IORESOURCE_IO) 6881da177e4SLinus Torvalds mask = ~3; 6891da177e4SLinus Torvalds 690852710d9SMatthew Wilcox res->name = dev->subordinate->name; 6911da177e4SLinus Torvalds res->flags = type; 6921da177e4SLinus Torvalds 69343c34735SDominik Brodowski region.start = config_readl(socket, addr_start) & mask; 69443c34735SDominik Brodowski region.end = config_readl(socket, addr_end) | ~mask; 69543c34735SDominik Brodowski if (region.start && region.end > region.start && !override_bios) { 696852710d9SMatthew Wilcox pcibios_bus_to_resource(dev, res, ®ion); 697852710d9SMatthew Wilcox if (pci_claim_resource(dev, PCI_BRIDGE_RESOURCES + nr) == 0) 698b3743fa4SDominik Brodowski return 0; 699852710d9SMatthew Wilcox dev_printk(KERN_INFO, &dev->dev, 700dd797d81SDominik Brodowski "Preassigned resource %d busy or not available, " 701dd797d81SDominik Brodowski "reconfiguring...\n", 702dd797d81SDominik Brodowski nr); 7031da177e4SLinus Torvalds } 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds if (type & IORESOURCE_IO) { 706eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_IO_MAX)) || 707eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_IO_ACC)) || 708b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_IO_MIN))) 709b3743fa4SDominik Brodowski return 1; 710eb0a90b4SDominik Brodowski } else { 711eb0a90b4SDominik Brodowski if (type & IORESOURCE_PREFETCH) { 712eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) || 713eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) || 714b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_MIN))) 715b3743fa4SDominik Brodowski return 1; 716eb0a90b4SDominik Brodowski /* Approximating prefetchable by non-prefetchable */ 717eb0a90b4SDominik Brodowski res->flags = IORESOURCE_MEM; 718eb0a90b4SDominik Brodowski } 719eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) || 720eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) || 721b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_MIN))) 722b3743fa4SDominik Brodowski return 1; 723eb0a90b4SDominik Brodowski } 724eb0a90b4SDominik Brodowski 725852710d9SMatthew Wilcox dev_printk(KERN_INFO, &dev->dev, 726dd797d81SDominik Brodowski "no resource of type %x available, trying to continue...\n", 727dd797d81SDominik Brodowski type); 728eb0a90b4SDominik Brodowski res->start = res->end = res->flags = 0; 729b3743fa4SDominik Brodowski return 0; 7301da177e4SLinus Torvalds } 7311da177e4SLinus Torvalds 7321da177e4SLinus Torvalds /* 7331da177e4SLinus Torvalds * Allocate the bridge mappings for the device.. 7341da177e4SLinus Torvalds */ 7351da177e4SLinus Torvalds static void yenta_allocate_resources(struct yenta_socket *socket) 7361da177e4SLinus Torvalds { 737b3743fa4SDominik Brodowski int program = 0; 738b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 0, IORESOURCE_IO, 73927879835SDominik Brodowski PCI_CB_IO_BASE_0, PCI_CB_IO_LIMIT_0); 740b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 1, IORESOURCE_IO, 74127879835SDominik Brodowski PCI_CB_IO_BASE_1, PCI_CB_IO_LIMIT_1); 742b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 2, IORESOURCE_MEM|IORESOURCE_PREFETCH, 74327879835SDominik Brodowski PCI_CB_MEMORY_BASE_0, PCI_CB_MEMORY_LIMIT_0); 744b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 3, IORESOURCE_MEM, 74527879835SDominik Brodowski PCI_CB_MEMORY_BASE_1, PCI_CB_MEMORY_LIMIT_1); 746b3743fa4SDominik Brodowski if (program) 747b3743fa4SDominik Brodowski pci_setup_cardbus(socket->dev->subordinate); 7481da177e4SLinus Torvalds } 7491da177e4SLinus Torvalds 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds /* 7521da177e4SLinus Torvalds * Free the bridge mappings for the device.. 7531da177e4SLinus Torvalds */ 7541da177e4SLinus Torvalds static void yenta_free_resources(struct yenta_socket *socket) 7551da177e4SLinus Torvalds { 7561da177e4SLinus Torvalds int i; 7571da177e4SLinus Torvalds for (i = 0; i < 4; i++) { 7581da177e4SLinus Torvalds struct resource *res; 7591da177e4SLinus Torvalds res = socket->dev->resource + PCI_BRIDGE_RESOURCES + i; 7601da177e4SLinus Torvalds if (res->start != 0 && res->end != 0) 7611da177e4SLinus Torvalds release_resource(res); 762b3743fa4SDominik Brodowski res->start = res->end = res->flags = 0; 7631da177e4SLinus Torvalds } 7641da177e4SLinus Torvalds } 7651da177e4SLinus Torvalds 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds /* 7681da177e4SLinus Torvalds * Close it down - release our resources and go home.. 7691da177e4SLinus Torvalds */ 770734f3fa1SMike Frysinger static void __devexit yenta_close(struct pci_dev *dev) 7711da177e4SLinus Torvalds { 7721da177e4SLinus Torvalds struct yenta_socket *sock = pci_get_drvdata(dev); 7731da177e4SLinus Torvalds 774030ee39cSLinus Torvalds /* Remove the register attributes */ 775030ee39cSLinus Torvalds device_remove_file(&dev->dev, &dev_attr_yenta_registers); 776030ee39cSLinus Torvalds 7771da177e4SLinus Torvalds /* we don't want a dying socket registered */ 7781da177e4SLinus Torvalds pcmcia_unregister_socket(&sock->socket); 7791da177e4SLinus Torvalds 7801da177e4SLinus Torvalds /* Disable all events so we don't die in an IRQ storm */ 7811da177e4SLinus Torvalds cb_writel(sock, CB_SOCKET_MASK, 0x0); 7821da177e4SLinus Torvalds exca_writeb(sock, I365_CSCINT, 0); 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds if (sock->cb_irq) 7851da177e4SLinus Torvalds free_irq(sock->cb_irq, sock); 7861da177e4SLinus Torvalds else 7871da177e4SLinus Torvalds del_timer_sync(&sock->poll_timer); 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds if (sock->base) 7901da177e4SLinus Torvalds iounmap(sock->base); 7911da177e4SLinus Torvalds yenta_free_resources(sock); 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds pci_release_regions(dev); 7941da177e4SLinus Torvalds pci_disable_device(dev); 7951da177e4SLinus Torvalds pci_set_drvdata(dev, NULL); 7961da177e4SLinus Torvalds } 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds static struct pccard_operations yenta_socket_operations = { 8001da177e4SLinus Torvalds .init = yenta_sock_init, 8011da177e4SLinus Torvalds .suspend = yenta_sock_suspend, 8021da177e4SLinus Torvalds .get_status = yenta_get_status, 8031da177e4SLinus Torvalds .set_socket = yenta_set_socket, 8041da177e4SLinus Torvalds .set_io_map = yenta_set_io_map, 8051da177e4SLinus Torvalds .set_mem_map = yenta_set_mem_map, 8061da177e4SLinus Torvalds }; 8071da177e4SLinus Torvalds 8081da177e4SLinus Torvalds 80963e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 8101da177e4SLinus Torvalds #include "ti113x.h" 81163e7ebd0SDaniel Ritz #endif 81263e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 8131da177e4SLinus Torvalds #include "ricoh.h" 81463e7ebd0SDaniel Ritz #endif 81563e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 8161da177e4SLinus Torvalds #include "topic.h" 81763e7ebd0SDaniel Ritz #endif 81863e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 8191da177e4SLinus Torvalds #include "o2micro.h" 82063e7ebd0SDaniel Ritz #endif 8211da177e4SLinus Torvalds 8221da177e4SLinus Torvalds enum { 8231da177e4SLinus Torvalds CARDBUS_TYPE_DEFAULT = -1, 8241da177e4SLinus Torvalds CARDBUS_TYPE_TI, 8251da177e4SLinus Torvalds CARDBUS_TYPE_TI113X, 8261da177e4SLinus Torvalds CARDBUS_TYPE_TI12XX, 8271da177e4SLinus Torvalds CARDBUS_TYPE_TI1250, 8281da177e4SLinus Torvalds CARDBUS_TYPE_RICOH, 829ea2f1590SDaniel Ritz CARDBUS_TYPE_TOPIC95, 8301da177e4SLinus Torvalds CARDBUS_TYPE_TOPIC97, 8311da177e4SLinus Torvalds CARDBUS_TYPE_O2MICRO, 8328c3520d4SDaniel Ritz CARDBUS_TYPE_ENE, 8331da177e4SLinus Torvalds }; 8341da177e4SLinus Torvalds 8351da177e4SLinus Torvalds /* 8361da177e4SLinus Torvalds * Different cardbus controllers have slightly different 8371da177e4SLinus Torvalds * initialization sequences etc details. List them here.. 8381da177e4SLinus Torvalds */ 8391da177e4SLinus Torvalds static struct cardbus_type cardbus_type[] = { 84063e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 8411da177e4SLinus Torvalds [CARDBUS_TYPE_TI] = { 8421da177e4SLinus Torvalds .override = ti_override, 8431da177e4SLinus Torvalds .save_state = ti_save_state, 8441da177e4SLinus Torvalds .restore_state = ti_restore_state, 8451da177e4SLinus Torvalds .sock_init = ti_init, 8461da177e4SLinus Torvalds }, 8471da177e4SLinus Torvalds [CARDBUS_TYPE_TI113X] = { 8481da177e4SLinus Torvalds .override = ti113x_override, 8491da177e4SLinus Torvalds .save_state = ti_save_state, 8501da177e4SLinus Torvalds .restore_state = ti_restore_state, 8511da177e4SLinus Torvalds .sock_init = ti_init, 8521da177e4SLinus Torvalds }, 8531da177e4SLinus Torvalds [CARDBUS_TYPE_TI12XX] = { 8541da177e4SLinus Torvalds .override = ti12xx_override, 8551da177e4SLinus Torvalds .save_state = ti_save_state, 8561da177e4SLinus Torvalds .restore_state = ti_restore_state, 8571da177e4SLinus Torvalds .sock_init = ti_init, 8581da177e4SLinus Torvalds }, 8591da177e4SLinus Torvalds [CARDBUS_TYPE_TI1250] = { 8601da177e4SLinus Torvalds .override = ti1250_override, 8611da177e4SLinus Torvalds .save_state = ti_save_state, 8621da177e4SLinus Torvalds .restore_state = ti_restore_state, 8631da177e4SLinus Torvalds .sock_init = ti_init, 8641da177e4SLinus Torvalds }, 86563e7ebd0SDaniel Ritz #endif 86663e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 8671da177e4SLinus Torvalds [CARDBUS_TYPE_RICOH] = { 8681da177e4SLinus Torvalds .override = ricoh_override, 8691da177e4SLinus Torvalds .save_state = ricoh_save_state, 8701da177e4SLinus Torvalds .restore_state = ricoh_restore_state, 8711da177e4SLinus Torvalds }, 87263e7ebd0SDaniel Ritz #endif 87363e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 874ea2f1590SDaniel Ritz [CARDBUS_TYPE_TOPIC95] = { 875ea2f1590SDaniel Ritz .override = topic95_override, 876ea2f1590SDaniel Ritz }, 8771da177e4SLinus Torvalds [CARDBUS_TYPE_TOPIC97] = { 8781da177e4SLinus Torvalds .override = topic97_override, 8791da177e4SLinus Torvalds }, 88063e7ebd0SDaniel Ritz #endif 88163e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 8821da177e4SLinus Torvalds [CARDBUS_TYPE_O2MICRO] = { 8831da177e4SLinus Torvalds .override = o2micro_override, 8841da177e4SLinus Torvalds .restore_state = o2micro_restore_state, 8851da177e4SLinus Torvalds }, 88663e7ebd0SDaniel Ritz #endif 88763e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 8888c3520d4SDaniel Ritz [CARDBUS_TYPE_ENE] = { 8898c3520d4SDaniel Ritz .override = ene_override, 8908c3520d4SDaniel Ritz .save_state = ti_save_state, 8918c3520d4SDaniel Ritz .restore_state = ti_restore_state, 8928c3520d4SDaniel Ritz .sock_init = ti_init, 8938c3520d4SDaniel Ritz }, 89463e7ebd0SDaniel Ritz #endif 8951da177e4SLinus Torvalds }; 8961da177e4SLinus Torvalds 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds /* 8991da177e4SLinus Torvalds * Only probe "regular" interrupts, don't 9001da177e4SLinus Torvalds * touch dangerous spots like the mouse irq, 9011da177e4SLinus Torvalds * because there are mice that apparently 9021da177e4SLinus Torvalds * get really confused if they get fondled 9031da177e4SLinus Torvalds * too intimately. 9041da177e4SLinus Torvalds * 9051da177e4SLinus Torvalds * Default to 11, 10, 9, 7, 6, 5, 4, 3. 9061da177e4SLinus Torvalds */ 9071da177e4SLinus Torvalds static u32 isa_interrupts = 0x0ef8; 9081da177e4SLinus Torvalds 9091da177e4SLinus Torvalds static unsigned int yenta_probe_irq(struct yenta_socket *socket, u32 isa_irq_mask) 9101da177e4SLinus Torvalds { 9111da177e4SLinus Torvalds int i; 9121da177e4SLinus Torvalds unsigned long val; 9131da177e4SLinus Torvalds u32 mask; 9141da177e4SLinus Torvalds 9151da177e4SLinus Torvalds /* 9161da177e4SLinus Torvalds * Probe for usable interrupts using the force 9171da177e4SLinus Torvalds * register to generate bogus card status events. 9181da177e4SLinus Torvalds */ 9191da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9201da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK); 9211da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 9221da177e4SLinus Torvalds val = probe_irq_on() & isa_irq_mask; 9231da177e4SLinus Torvalds for (i = 1; i < 16; i++) { 9241da177e4SLinus Torvalds if (!((val >> i) & 1)) 9251da177e4SLinus Torvalds continue; 9261da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG | (i << 4)); 9271da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS); 9281da177e4SLinus Torvalds udelay(100); 9291da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9301da177e4SLinus Torvalds } 9311da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0); 9321da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 9331da177e4SLinus Torvalds 9341da177e4SLinus Torvalds mask = probe_irq_mask(val) & 0xffff; 9351da177e4SLinus Torvalds 9361da177e4SLinus Torvalds return mask; 9371da177e4SLinus Torvalds } 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds 94078187865SRandy Dunlap /* 94163e7ebd0SDaniel Ritz * yenta PCI irq probing. 94263e7ebd0SDaniel Ritz * currently only used in the TI/EnE initialization code 94363e7ebd0SDaniel Ritz */ 94463e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 94563e7ebd0SDaniel Ritz 9461da177e4SLinus Torvalds /* interrupt handler, only used during probing */ 9477d12e780SDavid Howells static irqreturn_t yenta_probe_handler(int irq, void *dev_id) 9481da177e4SLinus Torvalds { 9491da177e4SLinus Torvalds struct yenta_socket *socket = (struct yenta_socket *) dev_id; 9501da177e4SLinus Torvalds u8 csc; 9511da177e4SLinus Torvalds u32 cb_event; 9521da177e4SLinus Torvalds 9531da177e4SLinus Torvalds /* Clear interrupt status for the event */ 9541da177e4SLinus Torvalds cb_event = cb_readl(socket, CB_SOCKET_EVENT); 9551da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9561da177e4SLinus Torvalds csc = exca_readb(socket, I365_CSC); 9571da177e4SLinus Torvalds 9581da177e4SLinus Torvalds if (cb_event || csc) { 9591da177e4SLinus Torvalds socket->probe_status = 1; 9601da177e4SLinus Torvalds return IRQ_HANDLED; 9611da177e4SLinus Torvalds } 9621da177e4SLinus Torvalds 9631da177e4SLinus Torvalds return IRQ_NONE; 9641da177e4SLinus Torvalds } 9651da177e4SLinus Torvalds 9661da177e4SLinus Torvalds /* probes the PCI interrupt, use only on override functions */ 9671da177e4SLinus Torvalds static int yenta_probe_cb_irq(struct yenta_socket *socket) 9681da177e4SLinus Torvalds { 9691da177e4SLinus Torvalds if (!socket->cb_irq) 9701da177e4SLinus Torvalds return -1; 9711da177e4SLinus Torvalds 9721da177e4SLinus Torvalds socket->probe_status = 0; 9731da177e4SLinus Torvalds 974dace1453SThomas Gleixner if (request_irq(socket->cb_irq, yenta_probe_handler, IRQF_SHARED, "yenta", socket)) { 975dd797d81SDominik Brodowski dev_printk(KERN_WARNING, &socket->dev->dev, 976dd797d81SDominik Brodowski "request_irq() in yenta_probe_cb_irq() failed!\n"); 9771da177e4SLinus Torvalds return -1; 9781da177e4SLinus Torvalds } 9791da177e4SLinus Torvalds 9801da177e4SLinus Torvalds /* generate interrupt, wait */ 9811da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG); 9821da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9831da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK); 9841da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS); 9851da177e4SLinus Torvalds 9861da177e4SLinus Torvalds msleep(100); 9871da177e4SLinus Torvalds 9881da177e4SLinus Torvalds /* disable interrupts */ 9891da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0); 9901da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 9911da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9921da177e4SLinus Torvalds exca_readb(socket, I365_CSC); 9931da177e4SLinus Torvalds 9941da177e4SLinus Torvalds free_irq(socket->cb_irq, socket); 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds return (int) socket->probe_status; 9971da177e4SLinus Torvalds } 9981da177e4SLinus Torvalds 99963e7ebd0SDaniel Ritz #endif /* CONFIG_YENTA_TI */ 10001da177e4SLinus Torvalds 10011da177e4SLinus Torvalds 10021da177e4SLinus Torvalds /* 10031da177e4SLinus Torvalds * Set static data that doesn't need re-initializing.. 10041da177e4SLinus Torvalds */ 10051da177e4SLinus Torvalds static void yenta_get_socket_capabilities(struct yenta_socket *socket, u32 isa_irq_mask) 10061da177e4SLinus Torvalds { 10071da177e4SLinus Torvalds socket->socket.pci_irq = socket->cb_irq; 1008fa912bcbSDaniel Ritz if (isa_probe) 10091da177e4SLinus Torvalds socket->socket.irq_mask = yenta_probe_irq(socket, isa_irq_mask); 1010fa912bcbSDaniel Ritz else 1011fa912bcbSDaniel Ritz socket->socket.irq_mask = 0; 10121da177e4SLinus Torvalds 1013dd797d81SDominik Brodowski dev_printk(KERN_INFO, &socket->dev->dev, 1014dd797d81SDominik Brodowski "ISA IRQ mask 0x%04x, PCI irq %d\n", 10151da177e4SLinus Torvalds socket->socket.irq_mask, socket->cb_irq); 10161da177e4SLinus Torvalds } 10171da177e4SLinus Torvalds 10181da177e4SLinus Torvalds /* 10191da177e4SLinus Torvalds * Initialize the standard cardbus registers 10201da177e4SLinus Torvalds */ 10211da177e4SLinus Torvalds static void yenta_config_init(struct yenta_socket *socket) 10221da177e4SLinus Torvalds { 10231da177e4SLinus Torvalds u16 bridge; 10241da177e4SLinus Torvalds struct pci_dev *dev = socket->dev; 10258e5d17ebSDominik Brodowski struct pci_bus_region region; 10261da177e4SLinus Torvalds 10278e5d17ebSDominik Brodowski pcibios_resource_to_bus(socket->dev, ®ion, &dev->resource[0]); 10281da177e4SLinus Torvalds 10291da177e4SLinus Torvalds config_writel(socket, CB_LEGACY_MODE_BASE, 0); 10308e5d17ebSDominik Brodowski config_writel(socket, PCI_BASE_ADDRESS_0, region.start); 10311da177e4SLinus Torvalds config_writew(socket, PCI_COMMAND, 10321da177e4SLinus Torvalds PCI_COMMAND_IO | 10331da177e4SLinus Torvalds PCI_COMMAND_MEMORY | 10341da177e4SLinus Torvalds PCI_COMMAND_MASTER | 10351da177e4SLinus Torvalds PCI_COMMAND_WAIT); 10361da177e4SLinus Torvalds 10371da177e4SLinus Torvalds /* MAGIC NUMBERS! Fixme */ 10381da177e4SLinus Torvalds config_writeb(socket, PCI_CACHE_LINE_SIZE, L1_CACHE_BYTES / 4); 10391da177e4SLinus Torvalds config_writeb(socket, PCI_LATENCY_TIMER, 168); 10401da177e4SLinus Torvalds config_writel(socket, PCI_PRIMARY_BUS, 10411da177e4SLinus Torvalds (176 << 24) | /* sec. latency timer */ 10421da177e4SLinus Torvalds (dev->subordinate->subordinate << 16) | /* subordinate bus */ 10431da177e4SLinus Torvalds (dev->subordinate->secondary << 8) | /* secondary bus */ 10441da177e4SLinus Torvalds dev->subordinate->primary); /* primary bus */ 10451da177e4SLinus Torvalds 10461da177e4SLinus Torvalds /* 10471da177e4SLinus Torvalds * Set up the bridging state: 10481da177e4SLinus Torvalds * - enable write posting. 10491da177e4SLinus Torvalds * - memory window 0 prefetchable, window 1 non-prefetchable 10501da177e4SLinus Torvalds * - PCI interrupts enabled if a PCI interrupt exists.. 10511da177e4SLinus Torvalds */ 10521da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL); 1053a413c090SDaniel Ritz bridge &= ~(CB_BRIDGE_CRST | CB_BRIDGE_PREFETCH1 | CB_BRIDGE_ISAEN | CB_BRIDGE_VGAEN); 1054a413c090SDaniel Ritz bridge |= CB_BRIDGE_PREFETCH0 | CB_BRIDGE_POSTEN; 10551da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 10561da177e4SLinus Torvalds } 10571da177e4SLinus Torvalds 1058b435261bSBernhard Kaindl /** 105966005216SRandy Dunlap * yenta_fixup_parent_bridge - Fix subordinate bus# of the parent bridge 1060b435261bSBernhard Kaindl * @cardbus_bridge: The PCI bus which the CardBus bridge bridges to 1061b435261bSBernhard Kaindl * 1062b435261bSBernhard Kaindl * Checks if devices on the bus which the CardBus bridge bridges to would be 1063b435261bSBernhard Kaindl * invisible during PCI scans because of a misconfigured subordinate number 1064b435261bSBernhard Kaindl * of the parent brige - some BIOSes seem to be too lazy to set it right. 1065b435261bSBernhard Kaindl * Does the fixup carefully by checking how far it can go without conflicts. 106678187865SRandy Dunlap * See http\://bugzilla.kernel.org/show_bug.cgi?id=2944 for more information. 1067b435261bSBernhard Kaindl */ 1068b435261bSBernhard Kaindl static void yenta_fixup_parent_bridge(struct pci_bus *cardbus_bridge) 1069b435261bSBernhard Kaindl { 1070b435261bSBernhard Kaindl struct list_head *tmp; 1071b435261bSBernhard Kaindl unsigned char upper_limit; 1072b435261bSBernhard Kaindl /* 1073b435261bSBernhard Kaindl * We only check and fix the parent bridge: All systems which need 1074b435261bSBernhard Kaindl * this fixup that have been reviewed are laptops and the only bridge 1075b435261bSBernhard Kaindl * which needed fixing was the parent bridge of the CardBus bridge: 1076b435261bSBernhard Kaindl */ 1077b435261bSBernhard Kaindl struct pci_bus *bridge_to_fix = cardbus_bridge->parent; 1078b435261bSBernhard Kaindl 1079b435261bSBernhard Kaindl /* Check bus numbers are already set up correctly: */ 1080b435261bSBernhard Kaindl if (bridge_to_fix->subordinate >= cardbus_bridge->subordinate) 1081b435261bSBernhard Kaindl return; /* The subordinate number is ok, nothing to do */ 1082b435261bSBernhard Kaindl 1083b435261bSBernhard Kaindl if (!bridge_to_fix->parent) 1084b435261bSBernhard Kaindl return; /* Root bridges are ok */ 1085b435261bSBernhard Kaindl 1086b435261bSBernhard Kaindl /* stay within the limits of the bus range of the parent: */ 1087b435261bSBernhard Kaindl upper_limit = bridge_to_fix->parent->subordinate; 1088b435261bSBernhard Kaindl 1089b435261bSBernhard Kaindl /* check the bus ranges of all silbling bridges to prevent overlap */ 1090b435261bSBernhard Kaindl list_for_each(tmp, &bridge_to_fix->parent->children) { 1091b435261bSBernhard Kaindl struct pci_bus *silbling = pci_bus_b(tmp); 1092b435261bSBernhard Kaindl /* 1093b435261bSBernhard Kaindl * If the silbling has a higher secondary bus number 1094b435261bSBernhard Kaindl * and it's secondary is equal or smaller than our 1095b435261bSBernhard Kaindl * current upper limit, set the new upper limit to 1096b435261bSBernhard Kaindl * the bus number below the silbling's range: 1097b435261bSBernhard Kaindl */ 1098b435261bSBernhard Kaindl if (silbling->secondary > bridge_to_fix->subordinate 1099b435261bSBernhard Kaindl && silbling->secondary <= upper_limit) 1100b435261bSBernhard Kaindl upper_limit = silbling->secondary - 1; 1101b435261bSBernhard Kaindl } 1102b435261bSBernhard Kaindl 1103b435261bSBernhard Kaindl /* Show that the wanted subordinate number is not possible: */ 1104b435261bSBernhard Kaindl if (cardbus_bridge->subordinate > upper_limit) 1105dd797d81SDominik Brodowski dev_printk(KERN_WARNING, &cardbus_bridge->dev, 1106dd797d81SDominik Brodowski "Upper limit for fixing this " 1107b435261bSBernhard Kaindl "bridge's parent bridge: #%02x\n", upper_limit); 1108b435261bSBernhard Kaindl 1109b435261bSBernhard Kaindl /* If we have room to increase the bridge's subordinate number, */ 1110b435261bSBernhard Kaindl if (bridge_to_fix->subordinate < upper_limit) { 1111b435261bSBernhard Kaindl 1112b435261bSBernhard Kaindl /* use the highest number of the hidden bus, within limits */ 1113b435261bSBernhard Kaindl unsigned char subordinate_to_assign = 1114b435261bSBernhard Kaindl min(cardbus_bridge->subordinate, upper_limit); 1115b435261bSBernhard Kaindl 1116dd797d81SDominik Brodowski dev_printk(KERN_INFO, &bridge_to_fix->dev, 1117dd797d81SDominik Brodowski "Raising subordinate bus# of parent " 1118b435261bSBernhard Kaindl "bus (#%02x) from #%02x to #%02x\n", 1119b435261bSBernhard Kaindl bridge_to_fix->number, 1120b435261bSBernhard Kaindl bridge_to_fix->subordinate, subordinate_to_assign); 1121b435261bSBernhard Kaindl 1122b435261bSBernhard Kaindl /* Save the new subordinate in the bus struct of the bridge */ 1123b435261bSBernhard Kaindl bridge_to_fix->subordinate = subordinate_to_assign; 1124b435261bSBernhard Kaindl 1125b435261bSBernhard Kaindl /* and update the PCI config space with the new subordinate */ 1126b435261bSBernhard Kaindl pci_write_config_byte(bridge_to_fix->self, 1127b435261bSBernhard Kaindl PCI_SUBORDINATE_BUS, bridge_to_fix->subordinate); 1128b435261bSBernhard Kaindl } 1129b435261bSBernhard Kaindl } 1130b435261bSBernhard Kaindl 11311da177e4SLinus Torvalds /* 11321da177e4SLinus Torvalds * Initialize a cardbus controller. Make sure we have a usable 11331da177e4SLinus Torvalds * interrupt, and that we can map the cardbus area. Fill in the 11341da177e4SLinus Torvalds * socket information structure.. 11351da177e4SLinus Torvalds */ 11361da177e4SLinus Torvalds static int __devinit yenta_probe(struct pci_dev *dev, const struct pci_device_id *id) 11371da177e4SLinus Torvalds { 11381da177e4SLinus Torvalds struct yenta_socket *socket; 11391da177e4SLinus Torvalds int ret; 11401da177e4SLinus Torvalds 1141c7fb0b35SIvan Kokshaysky /* 1142c7fb0b35SIvan Kokshaysky * If we failed to assign proper bus numbers for this cardbus 1143c7fb0b35SIvan Kokshaysky * controller during PCI probe, its subordinate pci_bus is NULL. 1144c7fb0b35SIvan Kokshaysky * Bail out if so. 1145c7fb0b35SIvan Kokshaysky */ 1146c7fb0b35SIvan Kokshaysky if (!dev->subordinate) { 1147dd797d81SDominik Brodowski dev_printk(KERN_ERR, &dev->dev, "no bus associated! " 1148dd797d81SDominik Brodowski "(try 'pci=assign-busses')\n"); 1149c7fb0b35SIvan Kokshaysky return -ENODEV; 1150c7fb0b35SIvan Kokshaysky } 1151c7fb0b35SIvan Kokshaysky 11528084b372SDominik Brodowski socket = kzalloc(sizeof(struct yenta_socket), GFP_KERNEL); 11531da177e4SLinus Torvalds if (!socket) 11541da177e4SLinus Torvalds return -ENOMEM; 11551da177e4SLinus Torvalds 11561da177e4SLinus Torvalds /* prepare pcmcia_socket */ 11571da177e4SLinus Torvalds socket->socket.ops = ¥ta_socket_operations; 11581da177e4SLinus Torvalds socket->socket.resource_ops = &pccard_nonstatic_ops; 115987373318SGreg Kroah-Hartman socket->socket.dev.parent = &dev->dev; 11601da177e4SLinus Torvalds socket->socket.driver_data = socket; 11611da177e4SLinus Torvalds socket->socket.owner = THIS_MODULE; 11625bc6b68aSRussell King socket->socket.features = SS_CAP_PAGE_REGS | SS_CAP_PCCARD; 11635bc6b68aSRussell King socket->socket.map_size = 0x1000; 11645bc6b68aSRussell King socket->socket.cb_dev = dev; 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds /* prepare struct yenta_socket */ 11671da177e4SLinus Torvalds socket->dev = dev; 11681da177e4SLinus Torvalds pci_set_drvdata(dev, socket); 11691da177e4SLinus Torvalds 11701da177e4SLinus Torvalds /* 11711da177e4SLinus Torvalds * Do some basic sanity checking.. 11721da177e4SLinus Torvalds */ 11731da177e4SLinus Torvalds if (pci_enable_device(dev)) { 11741da177e4SLinus Torvalds ret = -EBUSY; 11751da177e4SLinus Torvalds goto free; 11761da177e4SLinus Torvalds } 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds ret = pci_request_regions(dev, "yenta_socket"); 11791da177e4SLinus Torvalds if (ret) 11801da177e4SLinus Torvalds goto disable; 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds if (!pci_resource_start(dev, 0)) { 1183dd797d81SDominik Brodowski dev_printk(KERN_ERR, &dev->dev, "No cardbus resource!\n"); 11841da177e4SLinus Torvalds ret = -ENODEV; 11851da177e4SLinus Torvalds goto release; 11861da177e4SLinus Torvalds } 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds /* 11891da177e4SLinus Torvalds * Ok, start setup.. Map the cardbus registers, 11901da177e4SLinus Torvalds * and request the IRQ. 11911da177e4SLinus Torvalds */ 11921da177e4SLinus Torvalds socket->base = ioremap(pci_resource_start(dev, 0), 0x1000); 11931da177e4SLinus Torvalds if (!socket->base) { 11941da177e4SLinus Torvalds ret = -ENOMEM; 11951da177e4SLinus Torvalds goto release; 11961da177e4SLinus Torvalds } 11971da177e4SLinus Torvalds 11981da177e4SLinus Torvalds /* 11991da177e4SLinus Torvalds * report the subsystem vendor and device for help debugging 12001da177e4SLinus Torvalds * the irq stuff... 12011da177e4SLinus Torvalds */ 1202dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, "CardBus bridge found [%04x:%04x]\n", 1203dd797d81SDominik Brodowski dev->subsystem_vendor, dev->subsystem_device); 12041da177e4SLinus Torvalds 12051da177e4SLinus Torvalds yenta_config_init(socket); 12061da177e4SLinus Torvalds 12071da177e4SLinus Torvalds /* Disable all events */ 12081da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0x0); 12091da177e4SLinus Torvalds 12101da177e4SLinus Torvalds /* Set up the bridge regions.. */ 12111da177e4SLinus Torvalds yenta_allocate_resources(socket); 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds socket->cb_irq = dev->irq; 12141da177e4SLinus Torvalds 12151da177e4SLinus Torvalds /* Do we have special options for the device? */ 12161da177e4SLinus Torvalds if (id->driver_data != CARDBUS_TYPE_DEFAULT && 12171da177e4SLinus Torvalds id->driver_data < ARRAY_SIZE(cardbus_type)) { 12181da177e4SLinus Torvalds socket->type = &cardbus_type[id->driver_data]; 12191da177e4SLinus Torvalds 12201da177e4SLinus Torvalds ret = socket->type->override(socket); 12211da177e4SLinus Torvalds if (ret < 0) 12221da177e4SLinus Torvalds goto unmap; 12231da177e4SLinus Torvalds } 12241da177e4SLinus Torvalds 12251da177e4SLinus Torvalds /* We must finish initialization here */ 12261da177e4SLinus Torvalds 1227dace1453SThomas Gleixner if (!socket->cb_irq || request_irq(socket->cb_irq, yenta_interrupt, IRQF_SHARED, "yenta", socket)) { 12281da177e4SLinus Torvalds /* No IRQ or request_irq failed. Poll */ 12291da177e4SLinus Torvalds socket->cb_irq = 0; /* But zero is a valid IRQ number. */ 12301da177e4SLinus Torvalds init_timer(&socket->poll_timer); 12311da177e4SLinus Torvalds socket->poll_timer.function = yenta_interrupt_wrapper; 12321da177e4SLinus Torvalds socket->poll_timer.data = (unsigned long)socket; 12331da177e4SLinus Torvalds socket->poll_timer.expires = jiffies + HZ; 12341da177e4SLinus Torvalds add_timer(&socket->poll_timer); 1235dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1236dd797d81SDominik Brodowski "no PCI IRQ, CardBus support disabled for this " 1237dd797d81SDominik Brodowski "socket.\n"); 1238dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1239dd797d81SDominik Brodowski "check your BIOS CardBus, BIOS IRQ or ACPI " 1240dd797d81SDominik Brodowski "settings.\n"); 12415bc6b68aSRussell King } else { 12425bc6b68aSRussell King socket->socket.features |= SS_CAP_CARDBUS; 12431da177e4SLinus Torvalds } 12441da177e4SLinus Torvalds 12451da177e4SLinus Torvalds /* Figure out what the dang thing can do for the PCMCIA layer... */ 1246fa912bcbSDaniel Ritz yenta_interrogate(socket); 12471da177e4SLinus Torvalds yenta_get_socket_capabilities(socket, isa_interrupts); 1248dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1249dd797d81SDominik Brodowski "Socket status: %08x\n", cb_readl(socket, CB_SOCKET_STATE)); 12501da177e4SLinus Torvalds 1251b435261bSBernhard Kaindl yenta_fixup_parent_bridge(dev->subordinate); 1252b435261bSBernhard Kaindl 12531da177e4SLinus Torvalds /* Register it with the pcmcia layer.. */ 12541da177e4SLinus Torvalds ret = pcmcia_register_socket(&socket->socket); 1255030ee39cSLinus Torvalds if (ret == 0) { 1256030ee39cSLinus Torvalds /* Add the yenta register attributes */ 12574deb7c1eSJeff Garzik ret = device_create_file(&dev->dev, &dev_attr_yenta_registers); 12584deb7c1eSJeff Garzik if (ret == 0) 12591da177e4SLinus Torvalds goto out; 12604deb7c1eSJeff Garzik 12614deb7c1eSJeff Garzik /* error path... */ 12624deb7c1eSJeff Garzik pcmcia_unregister_socket(&socket->socket); 1263030ee39cSLinus Torvalds } 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds unmap: 12661da177e4SLinus Torvalds iounmap(socket->base); 12671da177e4SLinus Torvalds release: 12681da177e4SLinus Torvalds pci_release_regions(dev); 12691da177e4SLinus Torvalds disable: 12701da177e4SLinus Torvalds pci_disable_device(dev); 12711da177e4SLinus Torvalds free: 12721da177e4SLinus Torvalds kfree(socket); 12731da177e4SLinus Torvalds out: 12741da177e4SLinus Torvalds return ret; 12751da177e4SLinus Torvalds } 12761da177e4SLinus Torvalds 1277f237de58SAlexey Dobriyan #ifdef CONFIG_PM 12780c570cdeSRafael J. Wysocki static int yenta_dev_suspend_noirq(struct device *dev) 12791da177e4SLinus Torvalds { 12800c570cdeSRafael J. Wysocki struct pci_dev *pdev = to_pci_dev(dev); 12810c570cdeSRafael J. Wysocki struct yenta_socket *socket = pci_get_drvdata(pdev); 12821da177e4SLinus Torvalds int ret; 12831da177e4SLinus Torvalds 12840c570cdeSRafael J. Wysocki ret = pcmcia_socket_dev_suspend(dev); 12851da177e4SLinus Torvalds 12860c570cdeSRafael J. Wysocki if (!socket) 12870c570cdeSRafael J. Wysocki return ret; 12880c570cdeSRafael J. Wysocki 12891da177e4SLinus Torvalds if (socket->type && socket->type->save_state) 12901da177e4SLinus Torvalds socket->type->save_state(socket); 12911da177e4SLinus Torvalds 12920c570cdeSRafael J. Wysocki pci_save_state(pdev); 12930c570cdeSRafael J. Wysocki pci_read_config_dword(pdev, 16*4, &socket->saved_state[0]); 12940c570cdeSRafael J. Wysocki pci_read_config_dword(pdev, 17*4, &socket->saved_state[1]); 12950c570cdeSRafael J. Wysocki pci_disable_device(pdev); 12961da177e4SLinus Torvalds 12971da177e4SLinus Torvalds /* 12981da177e4SLinus Torvalds * Some laptops (IBM T22) do not like us putting the Cardbus 12991da177e4SLinus Torvalds * bridge into D3. At a guess, some other laptop will 13001da177e4SLinus Torvalds * probably require this, so leave it commented out for now. 13011da177e4SLinus Torvalds */ 13021da177e4SLinus Torvalds /* pci_set_power_state(dev, 3); */ 13031da177e4SLinus Torvalds 13041da177e4SLinus Torvalds return ret; 13051da177e4SLinus Torvalds } 13061da177e4SLinus Torvalds 13070c570cdeSRafael J. Wysocki static int yenta_dev_resume_noirq(struct device *dev) 13081da177e4SLinus Torvalds { 13090c570cdeSRafael J. Wysocki struct pci_dev *pdev = to_pci_dev(dev); 13100c570cdeSRafael J. Wysocki struct yenta_socket *socket = pci_get_drvdata(pdev); 13110c570cdeSRafael J. Wysocki int ret; 13121da177e4SLinus Torvalds 13130c570cdeSRafael J. Wysocki if (!socket) 13140c570cdeSRafael J. Wysocki return 0; 13154deb7c1eSJeff Garzik 13160c570cdeSRafael J. Wysocki pci_write_config_dword(pdev, 16*4, socket->saved_state[0]); 13170c570cdeSRafael J. Wysocki pci_write_config_dword(pdev, 17*4, socket->saved_state[1]); 13184deb7c1eSJeff Garzik 13190c570cdeSRafael J. Wysocki ret = pci_enable_device(pdev); 13200c570cdeSRafael J. Wysocki if (ret) 13210c570cdeSRafael J. Wysocki return ret; 13224deb7c1eSJeff Garzik 13230c570cdeSRafael J. Wysocki pci_set_master(pdev); 13241da177e4SLinus Torvalds 13251da177e4SLinus Torvalds if (socket->type && socket->type->restore_state) 13261da177e4SLinus Torvalds socket->type->restore_state(socket); 13270c570cdeSRafael J. Wysocki 13289905d1b4SRafael J. Wysocki pcmcia_socket_dev_early_resume(dev); 13299905d1b4SRafael J. Wysocki return 0; 13309905d1b4SRafael J. Wysocki } 13319905d1b4SRafael J. Wysocki 13329905d1b4SRafael J. Wysocki static int yenta_dev_resume(struct device *dev) 13339905d1b4SRafael J. Wysocki { 13349905d1b4SRafael J. Wysocki pcmcia_socket_dev_late_resume(dev); 13359905d1b4SRafael J. Wysocki return 0; 13361da177e4SLinus Torvalds } 13371da177e4SLinus Torvalds 133847145210SAlexey Dobriyan static const struct dev_pm_ops yenta_pm_ops = { 13390c570cdeSRafael J. Wysocki .suspend_noirq = yenta_dev_suspend_noirq, 13400c570cdeSRafael J. Wysocki .resume_noirq = yenta_dev_resume_noirq, 13419905d1b4SRafael J. Wysocki .resume = yenta_dev_resume, 13420c570cdeSRafael J. Wysocki .freeze_noirq = yenta_dev_suspend_noirq, 13430c570cdeSRafael J. Wysocki .thaw_noirq = yenta_dev_resume_noirq, 13449905d1b4SRafael J. Wysocki .thaw = yenta_dev_resume, 13450c570cdeSRafael J. Wysocki .poweroff_noirq = yenta_dev_suspend_noirq, 13460c570cdeSRafael J. Wysocki .restore_noirq = yenta_dev_resume_noirq, 13479905d1b4SRafael J. Wysocki .restore = yenta_dev_resume, 13480c570cdeSRafael J. Wysocki }; 13490c570cdeSRafael J. Wysocki 13500c570cdeSRafael J. Wysocki #define YENTA_PM_OPS (¥ta_pm_ops) 13510c570cdeSRafael J. Wysocki #else 13520c570cdeSRafael J. Wysocki #define YENTA_PM_OPS NULL 1353f237de58SAlexey Dobriyan #endif 13541da177e4SLinus Torvalds 13551da177e4SLinus Torvalds #define CB_ID(vend, dev, type) \ 13561da177e4SLinus Torvalds { \ 13571da177e4SLinus Torvalds .vendor = vend, \ 13581da177e4SLinus Torvalds .device = dev, \ 13591da177e4SLinus Torvalds .subvendor = PCI_ANY_ID, \ 13601da177e4SLinus Torvalds .subdevice = PCI_ANY_ID, \ 13611da177e4SLinus Torvalds .class = PCI_CLASS_BRIDGE_CARDBUS << 8, \ 13621da177e4SLinus Torvalds .class_mask = ~0, \ 13631da177e4SLinus Torvalds .driver_data = CARDBUS_TYPE_##type, \ 13641da177e4SLinus Torvalds } 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds static struct pci_device_id yenta_table[] = { 13671da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1031, TI), 13681da177e4SLinus Torvalds 13691da177e4SLinus Torvalds /* 13701da177e4SLinus Torvalds * TBD: Check if these TI variants can use more 13711da177e4SLinus Torvalds * advanced overrides instead. (I can't get the 13721da177e4SLinus Torvalds * data sheets for these devices. --rmk) 13731da177e4SLinus Torvalds */ 137463e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 13751da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1210, TI), 13761da177e4SLinus Torvalds 13771da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1130, TI113X), 13781da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1131, TI113X), 13791da177e4SLinus Torvalds 13801da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1211, TI12XX), 13811da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1220, TI12XX), 13821da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1221, TI12XX), 13831da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1225, TI12XX), 13841da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251A, TI12XX), 13851da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251B, TI12XX), 13861da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1420, TI12XX), 13871da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1450, TI12XX), 13881da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1451A, TI12XX), 13891da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1510, TI12XX), 13901da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1520, TI12XX), 13911da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1620, TI12XX), 13921da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4410, TI12XX), 13931da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4450, TI12XX), 13941da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4451, TI12XX), 13951da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4510, TI12XX), 13961da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4520, TI12XX), 13971da177e4SLinus Torvalds 13981da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1250, TI1250), 13991da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1410, TI1250), 14001da177e4SLinus Torvalds 14016c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11, TI12XX), 14026c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X515, TI12XX), 140359e35ba1SAlex Williamson CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12, TI12XX), 14046c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X420, TI12XX), 14056c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X620, TI12XX), 14066c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7410, TI12XX), 14076c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7510, TI12XX), 14086c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7610, TI12XX), 14096c1a10dbSDaniel Ritz 1410f9cb8b71SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_710, TI12XX), 1411f9cb8b71SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_712, TI12XX), 1412f9cb8b71SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_720, TI12XX), 1413f9cb8b71SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_722, TI12XX), 14148c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1211, ENE), 14158c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1225, ENE), 14168c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1410, ENE), 14178c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1420, ENE), 141863e7ebd0SDaniel Ritz #endif /* CONFIG_YENTA_TI */ 14191da177e4SLinus Torvalds 142063e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 14211da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C465, RICOH), 14221da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C466, RICOH), 14231da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C475, RICOH), 14241da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, RICOH), 14251da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C478, RICOH), 142663e7ebd0SDaniel Ritz #endif 14271da177e4SLinus Torvalds 142863e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 1429ea2f1590SDaniel Ritz CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC95, TOPIC95), 14301da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC97, TOPIC97), 14311da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC100, TOPIC97), 143263e7ebd0SDaniel Ritz #endif 14331da177e4SLinus Torvalds 143463e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 14351da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_O2, PCI_ANY_ID, O2MICRO), 143663e7ebd0SDaniel Ritz #endif 14371da177e4SLinus Torvalds 14381da177e4SLinus Torvalds /* match any cardbus bridge */ 14391da177e4SLinus Torvalds CB_ID(PCI_ANY_ID, PCI_ANY_ID, DEFAULT), 14401da177e4SLinus Torvalds { /* all zeroes */ } 14411da177e4SLinus Torvalds }; 14421da177e4SLinus Torvalds MODULE_DEVICE_TABLE(pci, yenta_table); 14431da177e4SLinus Torvalds 14441da177e4SLinus Torvalds 14451da177e4SLinus Torvalds static struct pci_driver yenta_cardbus_driver = { 14461da177e4SLinus Torvalds .name = "yenta_cardbus", 14471da177e4SLinus Torvalds .id_table = yenta_table, 14481da177e4SLinus Torvalds .probe = yenta_probe, 14491da177e4SLinus Torvalds .remove = __devexit_p(yenta_close), 14500c570cdeSRafael J. Wysocki .driver.pm = YENTA_PM_OPS, 14511da177e4SLinus Torvalds }; 14521da177e4SLinus Torvalds 14531da177e4SLinus Torvalds 14541da177e4SLinus Torvalds static int __init yenta_socket_init(void) 14551da177e4SLinus Torvalds { 14561da177e4SLinus Torvalds return pci_register_driver(¥ta_cardbus_driver); 14571da177e4SLinus Torvalds } 14581da177e4SLinus Torvalds 14591da177e4SLinus Torvalds 14601da177e4SLinus Torvalds static void __exit yenta_socket_exit(void) 14611da177e4SLinus Torvalds { 14621da177e4SLinus Torvalds pci_unregister_driver(¥ta_cardbus_driver); 14631da177e4SLinus Torvalds } 14641da177e4SLinus Torvalds 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds module_init(yenta_socket_init); 14671da177e4SLinus Torvalds module_exit(yenta_socket_exit); 14681da177e4SLinus Torvalds 14691da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 1470