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 450d3a940dSJens Künzer /* 460d3a940dSJens Künzer * Only probe "regular" interrupts, don't 470d3a940dSJens Künzer * touch dangerous spots like the mouse irq, 480d3a940dSJens Künzer * because there are mice that apparently 490d3a940dSJens Künzer * get really confused if they get fondled 500d3a940dSJens Künzer * too intimately. 510d3a940dSJens Künzer * 520d3a940dSJens Künzer * Default to 11, 10, 9, 7, 6, 5, 4, 3. 530d3a940dSJens Künzer */ 540d3a940dSJens Künzer static u32 isa_interrupts = 0x0ef8; 550d3a940dSJens Künzer 560d3a940dSJens Künzer 57dd797d81SDominik Brodowski #define debug(x, s, args...) dev_dbg(&s->dev->dev, x, ##args) 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds /* Don't ask.. */ 601da177e4SLinus Torvalds #define to_cycles(ns) ((ns)/120) 611da177e4SLinus Torvalds #define to_ns(cycles) ((cycles)*120) 621da177e4SLinus Torvalds 6378187865SRandy Dunlap /* 6463e7ebd0SDaniel Ritz * yenta PCI irq probing. 6563e7ebd0SDaniel Ritz * currently only used in the TI/EnE initialization code 6663e7ebd0SDaniel Ritz */ 6763e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 681da177e4SLinus Torvalds static int yenta_probe_cb_irq(struct yenta_socket *socket); 690d3a940dSJens Künzer static unsigned int yenta_probe_irq(struct yenta_socket *socket, 700d3a940dSJens Künzer u32 isa_irq_mask); 7163e7ebd0SDaniel Ritz #endif 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds static unsigned int override_bios; 751da177e4SLinus Torvalds module_param(override_bios, uint, 0000); 761da177e4SLinus Torvalds MODULE_PARM_DESC(override_bios, "yenta ignore bios resource allocation"); 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds /* 791da177e4SLinus Torvalds * Generate easy-to-use ways of reading a cardbus sockets 801da177e4SLinus Torvalds * regular memory space ("cb_xxx"), configuration space 811da177e4SLinus Torvalds * ("config_xxx") and compatibility space ("exca_xxxx") 821da177e4SLinus Torvalds */ 831da177e4SLinus Torvalds static inline u32 cb_readl(struct yenta_socket *socket, unsigned reg) 841da177e4SLinus Torvalds { 851da177e4SLinus Torvalds u32 val = readl(socket->base + reg); 86dd797d81SDominik Brodowski debug("%04x %08x\n", socket, reg, val); 871da177e4SLinus Torvalds return val; 881da177e4SLinus Torvalds } 891da177e4SLinus Torvalds 901da177e4SLinus Torvalds static inline void cb_writel(struct yenta_socket *socket, unsigned reg, u32 val) 911da177e4SLinus Torvalds { 92dd797d81SDominik Brodowski debug("%04x %08x\n", socket, reg, val); 931da177e4SLinus Torvalds writel(val, socket->base + reg); 94c8751e4cSDaniel Ritz readl(socket->base + reg); /* avoid problems with PCI write posting */ 951da177e4SLinus Torvalds } 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds static inline u8 config_readb(struct yenta_socket *socket, unsigned offset) 981da177e4SLinus Torvalds { 991da177e4SLinus Torvalds u8 val; 1001da177e4SLinus Torvalds pci_read_config_byte(socket->dev, offset, &val); 101dd797d81SDominik Brodowski debug("%04x %02x\n", socket, offset, val); 1021da177e4SLinus Torvalds return val; 1031da177e4SLinus Torvalds } 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds static inline u16 config_readw(struct yenta_socket *socket, unsigned offset) 1061da177e4SLinus Torvalds { 1071da177e4SLinus Torvalds u16 val; 1081da177e4SLinus Torvalds pci_read_config_word(socket->dev, offset, &val); 109dd797d81SDominik Brodowski debug("%04x %04x\n", socket, offset, val); 1101da177e4SLinus Torvalds return val; 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds static inline u32 config_readl(struct yenta_socket *socket, unsigned offset) 1141da177e4SLinus Torvalds { 1151da177e4SLinus Torvalds u32 val; 1161da177e4SLinus Torvalds pci_read_config_dword(socket->dev, offset, &val); 117dd797d81SDominik Brodowski debug("%04x %08x\n", socket, offset, val); 1181da177e4SLinus Torvalds return val; 1191da177e4SLinus Torvalds } 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds static inline void config_writeb(struct yenta_socket *socket, unsigned offset, u8 val) 1221da177e4SLinus Torvalds { 123dd797d81SDominik Brodowski debug("%04x %02x\n", socket, offset, val); 1241da177e4SLinus Torvalds pci_write_config_byte(socket->dev, offset, val); 1251da177e4SLinus Torvalds } 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds static inline void config_writew(struct yenta_socket *socket, unsigned offset, u16 val) 1281da177e4SLinus Torvalds { 129dd797d81SDominik Brodowski debug("%04x %04x\n", socket, offset, val); 1301da177e4SLinus Torvalds pci_write_config_word(socket->dev, offset, val); 1311da177e4SLinus Torvalds } 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds static inline void config_writel(struct yenta_socket *socket, unsigned offset, u32 val) 1341da177e4SLinus Torvalds { 135dd797d81SDominik Brodowski debug("%04x %08x\n", socket, offset, val); 1361da177e4SLinus Torvalds pci_write_config_dword(socket->dev, offset, val); 1371da177e4SLinus Torvalds } 1381da177e4SLinus Torvalds 1391da177e4SLinus Torvalds static inline u8 exca_readb(struct yenta_socket *socket, unsigned reg) 1401da177e4SLinus Torvalds { 1411da177e4SLinus Torvalds u8 val = readb(socket->base + 0x800 + reg); 142dd797d81SDominik Brodowski debug("%04x %02x\n", socket, reg, val); 1431da177e4SLinus Torvalds return val; 1441da177e4SLinus Torvalds } 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds static inline u8 exca_readw(struct yenta_socket *socket, unsigned reg) 1471da177e4SLinus Torvalds { 1481da177e4SLinus Torvalds u16 val; 1491da177e4SLinus Torvalds val = readb(socket->base + 0x800 + reg); 1501da177e4SLinus Torvalds val |= readb(socket->base + 0x800 + reg + 1) << 8; 151dd797d81SDominik Brodowski debug("%04x %04x\n", socket, reg, val); 1521da177e4SLinus Torvalds return val; 1531da177e4SLinus Torvalds } 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds static inline void exca_writeb(struct yenta_socket *socket, unsigned reg, u8 val) 1561da177e4SLinus Torvalds { 157dd797d81SDominik Brodowski debug("%04x %02x\n", socket, reg, val); 1581da177e4SLinus Torvalds writeb(val, socket->base + 0x800 + reg); 159c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg); /* PCI write posting... */ 1601da177e4SLinus Torvalds } 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds static void exca_writew(struct yenta_socket *socket, unsigned reg, u16 val) 1631da177e4SLinus Torvalds { 164dd797d81SDominik Brodowski debug("%04x %04x\n", socket, reg, val); 1651da177e4SLinus Torvalds writeb(val, socket->base + 0x800 + reg); 1661da177e4SLinus Torvalds writeb(val >> 8, socket->base + 0x800 + reg + 1); 167c8751e4cSDaniel Ritz 168c8751e4cSDaniel Ritz /* PCI write posting... */ 169c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg); 170c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg + 1); 1711da177e4SLinus Torvalds } 1721da177e4SLinus Torvalds 173030ee39cSLinus Torvalds static ssize_t show_yenta_registers(struct device *yentadev, struct device_attribute *attr, char *buf) 174030ee39cSLinus Torvalds { 175030ee39cSLinus Torvalds struct pci_dev *dev = to_pci_dev(yentadev); 176030ee39cSLinus Torvalds struct yenta_socket *socket = pci_get_drvdata(dev); 177030ee39cSLinus Torvalds int offset = 0, i; 178030ee39cSLinus Torvalds 179030ee39cSLinus Torvalds offset = snprintf(buf, PAGE_SIZE, "CB registers:"); 180030ee39cSLinus Torvalds for (i = 0; i < 0x24; i += 4) { 181030ee39cSLinus Torvalds unsigned val; 182030ee39cSLinus Torvalds if (!(i & 15)) 183030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i); 184030ee39cSLinus Torvalds val = cb_readl(socket, i); 185030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, " %08x", val); 186030ee39cSLinus Torvalds } 187030ee39cSLinus Torvalds 188030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n\nExCA registers:"); 189030ee39cSLinus Torvalds for (i = 0; i < 0x45; i++) { 190030ee39cSLinus Torvalds unsigned char val; 191030ee39cSLinus Torvalds if (!(i & 7)) { 192030ee39cSLinus Torvalds if (i & 8) { 193030ee39cSLinus Torvalds memcpy(buf + offset, " -", 2); 194030ee39cSLinus Torvalds offset += 2; 195030ee39cSLinus Torvalds } else 196030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i); 197030ee39cSLinus Torvalds } 198030ee39cSLinus Torvalds val = exca_readb(socket, i); 199030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, " %02x", val); 200030ee39cSLinus Torvalds } 201030ee39cSLinus Torvalds buf[offset++] = '\n'; 202030ee39cSLinus Torvalds return offset; 203030ee39cSLinus Torvalds } 204030ee39cSLinus Torvalds 205030ee39cSLinus Torvalds static DEVICE_ATTR(yenta_registers, S_IRUSR, show_yenta_registers, NULL); 206030ee39cSLinus Torvalds 2071da177e4SLinus Torvalds /* 2081da177e4SLinus Torvalds * Ugh, mixed-mode cardbus and 16-bit pccard state: things depend 2091da177e4SLinus Torvalds * on what kind of card is inserted.. 2101da177e4SLinus Torvalds */ 2111da177e4SLinus Torvalds static int yenta_get_status(struct pcmcia_socket *sock, unsigned int *value) 2121da177e4SLinus Torvalds { 2131da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 2141da177e4SLinus Torvalds unsigned int val; 2151da177e4SLinus Torvalds u32 state = cb_readl(socket, CB_SOCKET_STATE); 2161da177e4SLinus Torvalds 2171da177e4SLinus Torvalds val = (state & CB_3VCARD) ? SS_3VCARD : 0; 2181da177e4SLinus Torvalds val |= (state & CB_XVCARD) ? SS_XVCARD : 0; 219fa912bcbSDaniel Ritz val |= (state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) ? 0 : SS_PENDING; 220fa912bcbSDaniel Ritz val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? SS_PENDING : 0; 221fa912bcbSDaniel Ritz 2221da177e4SLinus Torvalds 2231da177e4SLinus Torvalds if (state & CB_CBCARD) { 2241da177e4SLinus Torvalds val |= SS_CARDBUS; 2251da177e4SLinus Torvalds val |= (state & CB_CARDSTS) ? SS_STSCHG : 0; 2261da177e4SLinus Torvalds val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? 0 : SS_DETECT; 2271da177e4SLinus Torvalds val |= (state & CB_PWRCYCLE) ? SS_POWERON | SS_READY : 0; 228fa912bcbSDaniel Ritz } else if (state & CB_16BITCARD) { 2291da177e4SLinus Torvalds u8 status = exca_readb(socket, I365_STATUS); 2301da177e4SLinus Torvalds val |= ((status & I365_CS_DETECT) == I365_CS_DETECT) ? SS_DETECT : 0; 2311da177e4SLinus Torvalds if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { 2321da177e4SLinus Torvalds val |= (status & I365_CS_STSCHG) ? 0 : SS_STSCHG; 2331da177e4SLinus Torvalds } else { 2341da177e4SLinus Torvalds val |= (status & I365_CS_BVD1) ? 0 : SS_BATDEAD; 2351da177e4SLinus Torvalds val |= (status & I365_CS_BVD2) ? 0 : SS_BATWARN; 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds val |= (status & I365_CS_WRPROT) ? SS_WRPROT : 0; 2381da177e4SLinus Torvalds val |= (status & I365_CS_READY) ? SS_READY : 0; 2391da177e4SLinus Torvalds val |= (status & I365_CS_POWERON) ? SS_POWERON : 0; 2401da177e4SLinus Torvalds } 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds *value = val; 2431da177e4SLinus Torvalds return 0; 2441da177e4SLinus Torvalds } 2451da177e4SLinus Torvalds 2461da177e4SLinus Torvalds static void yenta_set_power(struct yenta_socket *socket, socket_state_t *state) 2471da177e4SLinus Torvalds { 248ea2f1590SDaniel Ritz /* some birdges require to use the ExCA registers to power 16bit cards */ 249ea2f1590SDaniel Ritz if (!(cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) && 250ea2f1590SDaniel Ritz (socket->flags & YENTA_16BIT_POWER_EXCA)) { 251ea2f1590SDaniel Ritz u8 reg, old; 252ea2f1590SDaniel Ritz reg = old = exca_readb(socket, I365_POWER); 253ea2f1590SDaniel Ritz reg &= ~(I365_VCC_MASK | I365_VPP1_MASK | I365_VPP2_MASK); 254ea2f1590SDaniel Ritz 255ea2f1590SDaniel Ritz /* i82365SL-DF style */ 256ea2f1590SDaniel Ritz if (socket->flags & YENTA_16BIT_POWER_DF) { 257ea2f1590SDaniel Ritz switch (state->Vcc) { 2589fea84f4SDominik Brodowski case 33: 2599fea84f4SDominik Brodowski reg |= I365_VCC_3V; 2609fea84f4SDominik Brodowski break; 2619fea84f4SDominik Brodowski case 50: 2629fea84f4SDominik Brodowski reg |= I365_VCC_5V; 2639fea84f4SDominik Brodowski break; 2649fea84f4SDominik Brodowski default: 2659fea84f4SDominik Brodowski reg = 0; 2669fea84f4SDominik Brodowski break; 267ea2f1590SDaniel Ritz } 268ea2f1590SDaniel Ritz switch (state->Vpp) { 269ea2f1590SDaniel Ritz case 33: 2709fea84f4SDominik Brodowski case 50: 2719fea84f4SDominik Brodowski reg |= I365_VPP1_5V; 2729fea84f4SDominik Brodowski break; 2739fea84f4SDominik Brodowski case 120: 2749fea84f4SDominik Brodowski reg |= I365_VPP1_12V; 2759fea84f4SDominik Brodowski break; 276ea2f1590SDaniel Ritz } 277ea2f1590SDaniel Ritz } else { 278ea2f1590SDaniel Ritz /* i82365SL-B style */ 279ea2f1590SDaniel Ritz switch (state->Vcc) { 2809fea84f4SDominik Brodowski case 50: 2819fea84f4SDominik Brodowski reg |= I365_VCC_5V; 2829fea84f4SDominik Brodowski break; 2839fea84f4SDominik Brodowski default: 2849fea84f4SDominik Brodowski reg = 0; 2859fea84f4SDominik Brodowski break; 286ea2f1590SDaniel Ritz } 287ea2f1590SDaniel Ritz switch (state->Vpp) { 2889fea84f4SDominik Brodowski case 50: 2899fea84f4SDominik Brodowski reg |= I365_VPP1_5V | I365_VPP2_5V; 2909fea84f4SDominik Brodowski break; 2919fea84f4SDominik Brodowski case 120: 2929fea84f4SDominik Brodowski reg |= I365_VPP1_12V | I365_VPP2_12V; 2939fea84f4SDominik Brodowski break; 294ea2f1590SDaniel Ritz } 295ea2f1590SDaniel Ritz } 296ea2f1590SDaniel Ritz 297ea2f1590SDaniel Ritz if (reg != old) 298ea2f1590SDaniel Ritz exca_writeb(socket, I365_POWER, reg); 299ea2f1590SDaniel Ritz } else { 3001da177e4SLinus Torvalds u32 reg = 0; /* CB_SC_STPCLK? */ 3011da177e4SLinus Torvalds switch (state->Vcc) { 3029fea84f4SDominik Brodowski case 33: 3039fea84f4SDominik Brodowski reg = CB_SC_VCC_3V; 3049fea84f4SDominik Brodowski break; 3059fea84f4SDominik Brodowski case 50: 3069fea84f4SDominik Brodowski reg = CB_SC_VCC_5V; 3079fea84f4SDominik Brodowski break; 3089fea84f4SDominik Brodowski default: 3099fea84f4SDominik Brodowski reg = 0; 3109fea84f4SDominik Brodowski break; 3111da177e4SLinus Torvalds } 3121da177e4SLinus Torvalds switch (state->Vpp) { 3139fea84f4SDominik Brodowski case 33: 3149fea84f4SDominik Brodowski reg |= CB_SC_VPP_3V; 3159fea84f4SDominik Brodowski break; 3169fea84f4SDominik Brodowski case 50: 3179fea84f4SDominik Brodowski reg |= CB_SC_VPP_5V; 3189fea84f4SDominik Brodowski break; 3199fea84f4SDominik Brodowski case 120: 3209fea84f4SDominik Brodowski reg |= CB_SC_VPP_12V; 3219fea84f4SDominik Brodowski break; 3221da177e4SLinus Torvalds } 3231da177e4SLinus Torvalds if (reg != cb_readl(socket, CB_SOCKET_CONTROL)) 3241da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_CONTROL, reg); 3251da177e4SLinus Torvalds } 326ea2f1590SDaniel Ritz } 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds static int yenta_set_socket(struct pcmcia_socket *sock, socket_state_t *state) 3291da177e4SLinus Torvalds { 3301da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 3311da177e4SLinus Torvalds u16 bridge; 3321da177e4SLinus Torvalds 333d250a481SDaniel Ritz /* if powering down: do it immediately */ 334d250a481SDaniel Ritz if (state->Vcc == 0) 3351da177e4SLinus Torvalds yenta_set_power(socket, state); 336d250a481SDaniel Ritz 3371da177e4SLinus Torvalds socket->io_irq = state->io_irq; 3381da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL) & ~(CB_BRIDGE_CRST | CB_BRIDGE_INTR); 3391da177e4SLinus Torvalds if (cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) { 3401da177e4SLinus Torvalds u8 intr; 3411da177e4SLinus Torvalds bridge |= (state->flags & SS_RESET) ? CB_BRIDGE_CRST : 0; 3421da177e4SLinus Torvalds 3431da177e4SLinus Torvalds /* ISA interrupt control? */ 3441da177e4SLinus Torvalds intr = exca_readb(socket, I365_INTCTL); 3451da177e4SLinus Torvalds intr = (intr & ~0xf); 346ba8819e9SJens Künzer if (!socket->dev->irq) { 347ba8819e9SJens Künzer intr |= socket->cb_irq ? socket->cb_irq : state->io_irq; 3481da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, intr); 3511da177e4SLinus Torvalds } else { 3521da177e4SLinus Torvalds u8 reg; 3531da177e4SLinus Torvalds 3541da177e4SLinus Torvalds reg = exca_readb(socket, I365_INTCTL) & (I365_RING_ENA | I365_INTR_ENA); 3551da177e4SLinus Torvalds reg |= (state->flags & SS_RESET) ? 0 : I365_PC_RESET; 3561da177e4SLinus Torvalds reg |= (state->flags & SS_IOCARD) ? I365_PC_IOCARD : 0; 357ba8819e9SJens Künzer if (state->io_irq != socket->dev->irq) { 3581da177e4SLinus Torvalds reg |= state->io_irq; 3591da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 3601da177e4SLinus Torvalds } 3611da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, reg); 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds reg = exca_readb(socket, I365_POWER) & (I365_VCC_MASK|I365_VPP1_MASK); 3641da177e4SLinus Torvalds reg |= I365_PWR_NORESET; 3659fea84f4SDominik Brodowski if (state->flags & SS_PWR_AUTO) 3669fea84f4SDominik Brodowski reg |= I365_PWR_AUTO; 3679fea84f4SDominik Brodowski if (state->flags & SS_OUTPUT_ENA) 3689fea84f4SDominik Brodowski reg |= I365_PWR_OUT; 3691da177e4SLinus Torvalds if (exca_readb(socket, I365_POWER) != reg) 3701da177e4SLinus Torvalds exca_writeb(socket, I365_POWER, reg); 3711da177e4SLinus Torvalds 3721da177e4SLinus Torvalds /* CSC interrupt: no ISA irq for CSC */ 37328ca8dd7SJens Künzer reg = exca_readb(socket, I365_CSCINT); 37428ca8dd7SJens Künzer reg &= I365_CSC_IRQ_MASK; 37528ca8dd7SJens Künzer reg |= I365_CSC_DETECT; 3761da177e4SLinus Torvalds if (state->flags & SS_IOCARD) { 3779fea84f4SDominik Brodowski if (state->csc_mask & SS_STSCHG) 3789fea84f4SDominik Brodowski reg |= I365_CSC_STSCHG; 3791da177e4SLinus Torvalds } else { 3809fea84f4SDominik Brodowski if (state->csc_mask & SS_BATDEAD) 3819fea84f4SDominik Brodowski reg |= I365_CSC_BVD1; 3829fea84f4SDominik Brodowski if (state->csc_mask & SS_BATWARN) 3839fea84f4SDominik Brodowski reg |= I365_CSC_BVD2; 3849fea84f4SDominik Brodowski if (state->csc_mask & SS_READY) 3859fea84f4SDominik Brodowski reg |= I365_CSC_READY; 3861da177e4SLinus Torvalds } 3871da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, reg); 3881da177e4SLinus Torvalds exca_readb(socket, I365_CSC); 3891da177e4SLinus Torvalds if (sock->zoom_video) 3901da177e4SLinus Torvalds sock->zoom_video(sock, state->flags & SS_ZVCARD); 3911da177e4SLinus Torvalds } 3921da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 3931da177e4SLinus Torvalds /* Socket event mask: get card insert/remove events.. */ 3941da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 3951da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK); 396d250a481SDaniel Ritz 397d250a481SDaniel Ritz /* if powering up: do it as the last step when the socket is configured */ 398d250a481SDaniel Ritz if (state->Vcc != 0) 399d250a481SDaniel Ritz yenta_set_power(socket, state); 4001da177e4SLinus Torvalds return 0; 4011da177e4SLinus Torvalds } 4021da177e4SLinus Torvalds 4031da177e4SLinus Torvalds static int yenta_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io) 4041da177e4SLinus Torvalds { 4051da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 4061da177e4SLinus Torvalds int map; 4071da177e4SLinus Torvalds unsigned char ioctl, addr, enable; 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds map = io->map; 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds if (map > 1) 4121da177e4SLinus Torvalds return -EINVAL; 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds enable = I365_ENA_IO(map); 4151da177e4SLinus Torvalds addr = exca_readb(socket, I365_ADDRWIN); 4161da177e4SLinus Torvalds 4171da177e4SLinus Torvalds /* Disable the window before changing it.. */ 4181da177e4SLinus Torvalds if (addr & enable) { 4191da177e4SLinus Torvalds addr &= ~enable; 4201da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr); 4211da177e4SLinus Torvalds } 4221da177e4SLinus Torvalds 4231da177e4SLinus Torvalds exca_writew(socket, I365_IO(map)+I365_W_START, io->start); 4241da177e4SLinus Torvalds exca_writew(socket, I365_IO(map)+I365_W_STOP, io->stop); 4251da177e4SLinus Torvalds 4261da177e4SLinus Torvalds ioctl = exca_readb(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map); 4279fea84f4SDominik Brodowski if (io->flags & MAP_0WS) 4289fea84f4SDominik Brodowski ioctl |= I365_IOCTL_0WS(map); 4299fea84f4SDominik Brodowski if (io->flags & MAP_16BIT) 4309fea84f4SDominik Brodowski ioctl |= I365_IOCTL_16BIT(map); 4319fea84f4SDominik Brodowski if (io->flags & MAP_AUTOSZ) 4329fea84f4SDominik Brodowski ioctl |= I365_IOCTL_IOCS16(map); 4331da177e4SLinus Torvalds exca_writeb(socket, I365_IOCTL, ioctl); 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds if (io->flags & MAP_ACTIVE) 4361da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr | enable); 4371da177e4SLinus Torvalds return 0; 4381da177e4SLinus Torvalds } 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds static int yenta_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem) 4411da177e4SLinus Torvalds { 4421da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 4431da177e4SLinus Torvalds struct pci_bus_region region; 4441da177e4SLinus Torvalds int map; 4451da177e4SLinus Torvalds unsigned char addr, enable; 4461da177e4SLinus Torvalds unsigned int start, stop, card_start; 4471da177e4SLinus Torvalds unsigned short word; 4481da177e4SLinus Torvalds 4491da177e4SLinus Torvalds pcibios_resource_to_bus(socket->dev, ®ion, mem->res); 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds map = mem->map; 4521da177e4SLinus Torvalds start = region.start; 4531da177e4SLinus Torvalds stop = region.end; 4541da177e4SLinus Torvalds card_start = mem->card_start; 4551da177e4SLinus Torvalds 4561da177e4SLinus Torvalds if (map > 4 || start > stop || ((start ^ stop) >> 24) || 4571da177e4SLinus Torvalds (card_start >> 26) || mem->speed > 1000) 4581da177e4SLinus Torvalds return -EINVAL; 4591da177e4SLinus Torvalds 4601da177e4SLinus Torvalds enable = I365_ENA_MEM(map); 4611da177e4SLinus Torvalds addr = exca_readb(socket, I365_ADDRWIN); 4621da177e4SLinus Torvalds if (addr & enable) { 4631da177e4SLinus Torvalds addr &= ~enable; 4641da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr); 4651da177e4SLinus Torvalds } 4661da177e4SLinus Torvalds 4671da177e4SLinus Torvalds exca_writeb(socket, CB_MEM_PAGE(map), start >> 24); 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds word = (start >> 12) & 0x0fff; 4701da177e4SLinus Torvalds if (mem->flags & MAP_16BIT) 4711da177e4SLinus Torvalds word |= I365_MEM_16BIT; 4721da177e4SLinus Torvalds if (mem->flags & MAP_0WS) 4731da177e4SLinus Torvalds word |= I365_MEM_0WS; 4741da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_START, word); 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds word = (stop >> 12) & 0x0fff; 4771da177e4SLinus Torvalds switch (to_cycles(mem->speed)) { 4789fea84f4SDominik Brodowski case 0: 4799fea84f4SDominik Brodowski break; 4809fea84f4SDominik Brodowski case 1: 4819fea84f4SDominik Brodowski word |= I365_MEM_WS0; 4829fea84f4SDominik Brodowski break; 4839fea84f4SDominik Brodowski case 2: 4849fea84f4SDominik Brodowski word |= I365_MEM_WS1; 4859fea84f4SDominik Brodowski break; 4869fea84f4SDominik Brodowski default: 4879fea84f4SDominik Brodowski word |= I365_MEM_WS1 | I365_MEM_WS0; 4889fea84f4SDominik Brodowski break; 4891da177e4SLinus Torvalds } 4901da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_STOP, word); 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds word = ((card_start - start) >> 12) & 0x3fff; 4931da177e4SLinus Torvalds if (mem->flags & MAP_WRPROT) 4941da177e4SLinus Torvalds word |= I365_MEM_WRPROT; 4951da177e4SLinus Torvalds if (mem->flags & MAP_ATTRIB) 4961da177e4SLinus Torvalds word |= I365_MEM_REG; 4971da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_OFF, word); 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds if (mem->flags & MAP_ACTIVE) 5001da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr | enable); 5011da177e4SLinus Torvalds return 0; 5021da177e4SLinus Torvalds } 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds 505fa912bcbSDaniel Ritz 5067d12e780SDavid Howells static irqreturn_t yenta_interrupt(int irq, void *dev_id) 5071da177e4SLinus Torvalds { 508fa912bcbSDaniel Ritz unsigned int events; 509fa912bcbSDaniel Ritz struct yenta_socket *socket = (struct yenta_socket *) dev_id; 5101da177e4SLinus Torvalds u8 csc; 5111da177e4SLinus Torvalds u32 cb_event; 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds /* Clear interrupt status for the event */ 5141da177e4SLinus Torvalds cb_event = cb_readl(socket, CB_SOCKET_EVENT); 5151da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, cb_event); 5161da177e4SLinus Torvalds 5171da177e4SLinus Torvalds csc = exca_readb(socket, I365_CSC); 5181da177e4SLinus Torvalds 519e4115805SDaniel Ritz if (!(cb_event || csc)) 520e4115805SDaniel Ritz return IRQ_NONE; 521e4115805SDaniel Ritz 5221da177e4SLinus Torvalds events = (cb_event & (CB_CD1EVENT | CB_CD2EVENT)) ? SS_DETECT : 0 ; 5231da177e4SLinus Torvalds events |= (csc & I365_CSC_DETECT) ? SS_DETECT : 0; 5241da177e4SLinus Torvalds if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { 5251da177e4SLinus Torvalds events |= (csc & I365_CSC_STSCHG) ? SS_STSCHG : 0; 5261da177e4SLinus Torvalds } else { 5271da177e4SLinus Torvalds events |= (csc & I365_CSC_BVD1) ? SS_BATDEAD : 0; 5281da177e4SLinus Torvalds events |= (csc & I365_CSC_BVD2) ? SS_BATWARN : 0; 5291da177e4SLinus Torvalds events |= (csc & I365_CSC_READY) ? SS_READY : 0; 5301da177e4SLinus Torvalds } 5311da177e4SLinus Torvalds 532fa912bcbSDaniel Ritz if (events) 5331da177e4SLinus Torvalds pcmcia_parse_events(&socket->socket, events); 534fa912bcbSDaniel Ritz 5351da177e4SLinus Torvalds return IRQ_HANDLED; 5361da177e4SLinus Torvalds } 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds static void yenta_interrupt_wrapper(unsigned long data) 5391da177e4SLinus Torvalds { 5401da177e4SLinus Torvalds struct yenta_socket *socket = (struct yenta_socket *) data; 5411da177e4SLinus Torvalds 5427d12e780SDavid Howells yenta_interrupt(0, (void *)socket); 5431da177e4SLinus Torvalds socket->poll_timer.expires = jiffies + HZ; 5441da177e4SLinus Torvalds add_timer(&socket->poll_timer); 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds static void yenta_clear_maps(struct yenta_socket *socket) 5481da177e4SLinus Torvalds { 5491da177e4SLinus Torvalds int i; 5501da177e4SLinus Torvalds struct resource res = { .start = 0, .end = 0x0fff }; 5511da177e4SLinus Torvalds pccard_io_map io = { 0, 0, 0, 0, 1 }; 5521da177e4SLinus Torvalds pccard_mem_map mem = { .res = &res, }; 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds yenta_set_socket(&socket->socket, &dead_socket); 5551da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 5561da177e4SLinus Torvalds io.map = i; 5571da177e4SLinus Torvalds yenta_set_io_map(&socket->socket, &io); 5581da177e4SLinus Torvalds } 5591da177e4SLinus Torvalds for (i = 0; i < 5; i++) { 5601da177e4SLinus Torvalds mem.map = i; 5611da177e4SLinus Torvalds yenta_set_mem_map(&socket->socket, &mem); 5621da177e4SLinus Torvalds } 5631da177e4SLinus Torvalds } 5641da177e4SLinus Torvalds 565fa912bcbSDaniel Ritz /* redoes voltage interrogation if required */ 566fa912bcbSDaniel Ritz static void yenta_interrogate(struct yenta_socket *socket) 567fa912bcbSDaniel Ritz { 568fa912bcbSDaniel Ritz u32 state; 569fa912bcbSDaniel Ritz 570fa912bcbSDaniel Ritz state = cb_readl(socket, CB_SOCKET_STATE); 571fa912bcbSDaniel Ritz if (!(state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) || 572fa912bcbSDaniel Ritz (state & (CB_CDETECT1 | CB_CDETECT2 | CB_NOTACARD | CB_BADVCCREQ)) || 573fa912bcbSDaniel Ritz ((state & (CB_16BITCARD | CB_CBCARD)) == (CB_16BITCARD | CB_CBCARD))) 574fa912bcbSDaniel Ritz cb_writel(socket, CB_SOCKET_FORCE, CB_CVSTEST); 575fa912bcbSDaniel Ritz } 576fa912bcbSDaniel Ritz 5771da177e4SLinus Torvalds /* Called at resume and initialization events */ 5781da177e4SLinus Torvalds static int yenta_sock_init(struct pcmcia_socket *sock) 5791da177e4SLinus Torvalds { 5801da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds exca_writeb(socket, I365_GBLCTL, 0x00); 5831da177e4SLinus Torvalds exca_writeb(socket, I365_GENCTL, 0x00); 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds /* Redo card voltage interrogation */ 586fa912bcbSDaniel Ritz yenta_interrogate(socket); 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds yenta_clear_maps(socket); 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds if (socket->type && socket->type->sock_init) 5911da177e4SLinus Torvalds socket->type->sock_init(socket); 5921da177e4SLinus Torvalds 5931da177e4SLinus Torvalds /* Re-enable CSC interrupts */ 5941da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK); 5951da177e4SLinus Torvalds 5961da177e4SLinus Torvalds return 0; 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds static int yenta_sock_suspend(struct pcmcia_socket *sock) 6001da177e4SLinus Torvalds { 6011da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds /* Disable CSC interrupts */ 6041da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0x0); 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds return 0; 6071da177e4SLinus Torvalds } 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds /* 6101da177e4SLinus Torvalds * Use an adaptive allocation for the memory resource, 6111da177e4SLinus Torvalds * sometimes the memory behind pci bridges is limited: 6121da177e4SLinus Torvalds * 1/8 of the size of the io window of the parent. 613eb0a90b4SDominik Brodowski * max 4 MB, min 16 kB. We try very hard to not get below 614eb0a90b4SDominik Brodowski * the "ACC" values, though. 6151da177e4SLinus Torvalds */ 6169fea84f4SDominik Brodowski #define BRIDGE_MEM_MAX (4*1024*1024) 6179fea84f4SDominik Brodowski #define BRIDGE_MEM_ACC (128*1024) 6189fea84f4SDominik Brodowski #define BRIDGE_MEM_MIN (16*1024) 6191da177e4SLinus Torvalds 620eb0a90b4SDominik Brodowski #define BRIDGE_IO_MAX 512 621eb0a90b4SDominik Brodowski #define BRIDGE_IO_ACC 256 6221da177e4SLinus Torvalds #define BRIDGE_IO_MIN 32 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds #ifndef PCIBIOS_MIN_CARDBUS_IO 6251da177e4SLinus Torvalds #define PCIBIOS_MIN_CARDBUS_IO PCIBIOS_MIN_IO 6261da177e4SLinus Torvalds #endif 6271da177e4SLinus Torvalds 628eb0a90b4SDominik Brodowski static int yenta_search_one_res(struct resource *root, struct resource *res, 629eb0a90b4SDominik Brodowski u32 min) 630eb0a90b4SDominik Brodowski { 631eb0a90b4SDominik Brodowski u32 align, size, start, end; 632eb0a90b4SDominik Brodowski 633eb0a90b4SDominik Brodowski if (res->flags & IORESOURCE_IO) { 634eb0a90b4SDominik Brodowski align = 1024; 635eb0a90b4SDominik Brodowski size = BRIDGE_IO_MAX; 636eb0a90b4SDominik Brodowski start = PCIBIOS_MIN_CARDBUS_IO; 637eb0a90b4SDominik Brodowski end = ~0U; 638eb0a90b4SDominik Brodowski } else { 639eb0a90b4SDominik Brodowski unsigned long avail = root->end - root->start; 640eb0a90b4SDominik Brodowski int i; 641eb0a90b4SDominik Brodowski size = BRIDGE_MEM_MAX; 642eb0a90b4SDominik Brodowski if (size > avail/8) { 643eb0a90b4SDominik Brodowski size = (avail+1)/8; 644eb0a90b4SDominik Brodowski /* round size down to next power of 2 */ 645eb0a90b4SDominik Brodowski i = 0; 646eb0a90b4SDominik Brodowski while ((size /= 2) != 0) 647eb0a90b4SDominik Brodowski i++; 648eb0a90b4SDominik Brodowski size = 1 << i; 649eb0a90b4SDominik Brodowski } 650eb0a90b4SDominik Brodowski if (size < min) 651eb0a90b4SDominik Brodowski size = min; 652eb0a90b4SDominik Brodowski align = size; 653eb0a90b4SDominik Brodowski start = PCIBIOS_MIN_MEM; 654eb0a90b4SDominik Brodowski end = ~0U; 655eb0a90b4SDominik Brodowski } 656eb0a90b4SDominik Brodowski 657eb0a90b4SDominik Brodowski do { 658eb0a90b4SDominik Brodowski if (allocate_resource(root, res, size, start, end, align, 659eb0a90b4SDominik Brodowski NULL, NULL) == 0) { 660eb0a90b4SDominik Brodowski return 1; 661eb0a90b4SDominik Brodowski } 662eb0a90b4SDominik Brodowski size = size/2; 663eb0a90b4SDominik Brodowski align = size; 664eb0a90b4SDominik Brodowski } while (size >= min); 665eb0a90b4SDominik Brodowski 666eb0a90b4SDominik Brodowski return 0; 667eb0a90b4SDominik Brodowski } 668eb0a90b4SDominik Brodowski 669eb0a90b4SDominik Brodowski 670eb0a90b4SDominik Brodowski static int yenta_search_res(struct yenta_socket *socket, struct resource *res, 671eb0a90b4SDominik Brodowski u32 min) 672eb0a90b4SDominik Brodowski { 67389a74eccSBjorn Helgaas struct resource *root; 674eb0a90b4SDominik Brodowski int i; 67589a74eccSBjorn Helgaas 67689a74eccSBjorn Helgaas pci_bus_for_each_resource(socket->dev->bus, root, i) { 677eb0a90b4SDominik Brodowski if (!root) 678eb0a90b4SDominik Brodowski continue; 679eb0a90b4SDominik Brodowski 680eb0a90b4SDominik Brodowski if ((res->flags ^ root->flags) & 681eb0a90b4SDominik Brodowski (IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH)) 682eb0a90b4SDominik Brodowski continue; /* Wrong type */ 683eb0a90b4SDominik Brodowski 684eb0a90b4SDominik Brodowski if (yenta_search_one_res(root, res, min)) 685eb0a90b4SDominik Brodowski return 1; 686eb0a90b4SDominik Brodowski } 687eb0a90b4SDominik Brodowski return 0; 688eb0a90b4SDominik Brodowski } 689eb0a90b4SDominik Brodowski 690b3743fa4SDominik Brodowski static int yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned type, int addr_start, int addr_end) 6911da177e4SLinus Torvalds { 692852710d9SMatthew Wilcox struct pci_dev *dev = socket->dev; 693852710d9SMatthew Wilcox struct resource *res; 69443c34735SDominik Brodowski struct pci_bus_region region; 6951da177e4SLinus Torvalds unsigned mask; 6961da177e4SLinus Torvalds 697852710d9SMatthew Wilcox res = dev->resource + PCI_BRIDGE_RESOURCES + nr; 6987925407aSIvan Kokshaysky /* Already allocated? */ 6997925407aSIvan Kokshaysky if (res->parent) 700b3743fa4SDominik Brodowski return 0; 7017925407aSIvan Kokshaysky 7021da177e4SLinus Torvalds /* The granularity of the memory limit is 4kB, on IO it's 4 bytes */ 7031da177e4SLinus Torvalds mask = ~0xfff; 7041da177e4SLinus Torvalds if (type & IORESOURCE_IO) 7051da177e4SLinus Torvalds mask = ~3; 7061da177e4SLinus Torvalds 707852710d9SMatthew Wilcox res->name = dev->subordinate->name; 7081da177e4SLinus Torvalds res->flags = type; 7091da177e4SLinus Torvalds 71043c34735SDominik Brodowski region.start = config_readl(socket, addr_start) & mask; 71143c34735SDominik Brodowski region.end = config_readl(socket, addr_end) | ~mask; 71243c34735SDominik Brodowski if (region.start && region.end > region.start && !override_bios) { 713852710d9SMatthew Wilcox pcibios_bus_to_resource(dev, res, ®ion); 714852710d9SMatthew Wilcox if (pci_claim_resource(dev, PCI_BRIDGE_RESOURCES + nr) == 0) 715b3743fa4SDominik Brodowski return 0; 716852710d9SMatthew Wilcox dev_printk(KERN_INFO, &dev->dev, 717dd797d81SDominik Brodowski "Preassigned resource %d busy or not available, " 718dd797d81SDominik Brodowski "reconfiguring...\n", 719dd797d81SDominik Brodowski nr); 7201da177e4SLinus Torvalds } 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds if (type & IORESOURCE_IO) { 723eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_IO_MAX)) || 724eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_IO_ACC)) || 725b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_IO_MIN))) 726b3743fa4SDominik Brodowski return 1; 727eb0a90b4SDominik Brodowski } else { 728eb0a90b4SDominik Brodowski if (type & IORESOURCE_PREFETCH) { 729eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) || 730eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) || 731b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_MIN))) 732b3743fa4SDominik Brodowski return 1; 733eb0a90b4SDominik Brodowski /* Approximating prefetchable by non-prefetchable */ 734eb0a90b4SDominik Brodowski res->flags = IORESOURCE_MEM; 735eb0a90b4SDominik Brodowski } 736eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) || 737eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) || 738b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_MIN))) 739b3743fa4SDominik Brodowski return 1; 740eb0a90b4SDominik Brodowski } 741eb0a90b4SDominik Brodowski 742852710d9SMatthew Wilcox dev_printk(KERN_INFO, &dev->dev, 743dd797d81SDominik Brodowski "no resource of type %x available, trying to continue...\n", 744dd797d81SDominik Brodowski type); 745eb0a90b4SDominik Brodowski res->start = res->end = res->flags = 0; 746b3743fa4SDominik Brodowski return 0; 7471da177e4SLinus Torvalds } 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds /* 7501da177e4SLinus Torvalds * Allocate the bridge mappings for the device.. 7511da177e4SLinus Torvalds */ 7521da177e4SLinus Torvalds static void yenta_allocate_resources(struct yenta_socket *socket) 7531da177e4SLinus Torvalds { 754b3743fa4SDominik Brodowski int program = 0; 755b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 0, IORESOURCE_IO, 75627879835SDominik Brodowski PCI_CB_IO_BASE_0, PCI_CB_IO_LIMIT_0); 757b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 1, IORESOURCE_IO, 75827879835SDominik Brodowski PCI_CB_IO_BASE_1, PCI_CB_IO_LIMIT_1); 759b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 2, IORESOURCE_MEM|IORESOURCE_PREFETCH, 76027879835SDominik Brodowski PCI_CB_MEMORY_BASE_0, PCI_CB_MEMORY_LIMIT_0); 761b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 3, IORESOURCE_MEM, 76227879835SDominik Brodowski PCI_CB_MEMORY_BASE_1, PCI_CB_MEMORY_LIMIT_1); 763b3743fa4SDominik Brodowski if (program) 764b3743fa4SDominik Brodowski pci_setup_cardbus(socket->dev->subordinate); 7651da177e4SLinus Torvalds } 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds 7681da177e4SLinus Torvalds /* 7691da177e4SLinus Torvalds * Free the bridge mappings for the device.. 7701da177e4SLinus Torvalds */ 7711da177e4SLinus Torvalds static void yenta_free_resources(struct yenta_socket *socket) 7721da177e4SLinus Torvalds { 7731da177e4SLinus Torvalds int i; 7741da177e4SLinus Torvalds for (i = 0; i < 4; i++) { 7751da177e4SLinus Torvalds struct resource *res; 7761da177e4SLinus Torvalds res = socket->dev->resource + PCI_BRIDGE_RESOURCES + i; 7771da177e4SLinus Torvalds if (res->start != 0 && res->end != 0) 7781da177e4SLinus Torvalds release_resource(res); 779b3743fa4SDominik Brodowski res->start = res->end = res->flags = 0; 7801da177e4SLinus Torvalds } 7811da177e4SLinus Torvalds } 7821da177e4SLinus Torvalds 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds /* 7851da177e4SLinus Torvalds * Close it down - release our resources and go home.. 7861da177e4SLinus Torvalds */ 787734f3fa1SMike Frysinger static void __devexit yenta_close(struct pci_dev *dev) 7881da177e4SLinus Torvalds { 7891da177e4SLinus Torvalds struct yenta_socket *sock = pci_get_drvdata(dev); 7901da177e4SLinus Torvalds 791030ee39cSLinus Torvalds /* Remove the register attributes */ 792030ee39cSLinus Torvalds device_remove_file(&dev->dev, &dev_attr_yenta_registers); 793030ee39cSLinus Torvalds 7941da177e4SLinus Torvalds /* we don't want a dying socket registered */ 7951da177e4SLinus Torvalds pcmcia_unregister_socket(&sock->socket); 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds /* Disable all events so we don't die in an IRQ storm */ 7981da177e4SLinus Torvalds cb_writel(sock, CB_SOCKET_MASK, 0x0); 7991da177e4SLinus Torvalds exca_writeb(sock, I365_CSCINT, 0); 8001da177e4SLinus Torvalds 8011da177e4SLinus Torvalds if (sock->cb_irq) 8021da177e4SLinus Torvalds free_irq(sock->cb_irq, sock); 8031da177e4SLinus Torvalds else 8041da177e4SLinus Torvalds del_timer_sync(&sock->poll_timer); 8051da177e4SLinus Torvalds 8061da177e4SLinus Torvalds if (sock->base) 8071da177e4SLinus Torvalds iounmap(sock->base); 8081da177e4SLinus Torvalds yenta_free_resources(sock); 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds pci_release_regions(dev); 8111da177e4SLinus Torvalds pci_disable_device(dev); 8121da177e4SLinus Torvalds pci_set_drvdata(dev, NULL); 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvalds static struct pccard_operations yenta_socket_operations = { 8171da177e4SLinus Torvalds .init = yenta_sock_init, 8181da177e4SLinus Torvalds .suspend = yenta_sock_suspend, 8191da177e4SLinus Torvalds .get_status = yenta_get_status, 8201da177e4SLinus Torvalds .set_socket = yenta_set_socket, 8211da177e4SLinus Torvalds .set_io_map = yenta_set_io_map, 8221da177e4SLinus Torvalds .set_mem_map = yenta_set_mem_map, 8231da177e4SLinus Torvalds }; 8241da177e4SLinus Torvalds 8251da177e4SLinus Torvalds 82663e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 8271da177e4SLinus Torvalds #include "ti113x.h" 82863e7ebd0SDaniel Ritz #endif 82963e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 8301da177e4SLinus Torvalds #include "ricoh.h" 83163e7ebd0SDaniel Ritz #endif 83263e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 8331da177e4SLinus Torvalds #include "topic.h" 83463e7ebd0SDaniel Ritz #endif 83563e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 8361da177e4SLinus Torvalds #include "o2micro.h" 83763e7ebd0SDaniel Ritz #endif 8381da177e4SLinus Torvalds 8391da177e4SLinus Torvalds enum { 8401da177e4SLinus Torvalds CARDBUS_TYPE_DEFAULT = -1, 8411da177e4SLinus Torvalds CARDBUS_TYPE_TI, 8421da177e4SLinus Torvalds CARDBUS_TYPE_TI113X, 8431da177e4SLinus Torvalds CARDBUS_TYPE_TI12XX, 8441da177e4SLinus Torvalds CARDBUS_TYPE_TI1250, 8451da177e4SLinus Torvalds CARDBUS_TYPE_RICOH, 846ea2f1590SDaniel Ritz CARDBUS_TYPE_TOPIC95, 8471da177e4SLinus Torvalds CARDBUS_TYPE_TOPIC97, 8481da177e4SLinus Torvalds CARDBUS_TYPE_O2MICRO, 8498c3520d4SDaniel Ritz CARDBUS_TYPE_ENE, 8501da177e4SLinus Torvalds }; 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds /* 8531da177e4SLinus Torvalds * Different cardbus controllers have slightly different 8541da177e4SLinus Torvalds * initialization sequences etc details. List them here.. 8551da177e4SLinus Torvalds */ 8561da177e4SLinus Torvalds static struct cardbus_type cardbus_type[] = { 85763e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 8581da177e4SLinus Torvalds [CARDBUS_TYPE_TI] = { 8591da177e4SLinus Torvalds .override = ti_override, 8601da177e4SLinus Torvalds .save_state = ti_save_state, 8611da177e4SLinus Torvalds .restore_state = ti_restore_state, 8621da177e4SLinus Torvalds .sock_init = ti_init, 8631da177e4SLinus Torvalds }, 8641da177e4SLinus Torvalds [CARDBUS_TYPE_TI113X] = { 8651da177e4SLinus Torvalds .override = ti113x_override, 8661da177e4SLinus Torvalds .save_state = ti_save_state, 8671da177e4SLinus Torvalds .restore_state = ti_restore_state, 8681da177e4SLinus Torvalds .sock_init = ti_init, 8691da177e4SLinus Torvalds }, 8701da177e4SLinus Torvalds [CARDBUS_TYPE_TI12XX] = { 8711da177e4SLinus Torvalds .override = ti12xx_override, 8721da177e4SLinus Torvalds .save_state = ti_save_state, 8731da177e4SLinus Torvalds .restore_state = ti_restore_state, 8741da177e4SLinus Torvalds .sock_init = ti_init, 8751da177e4SLinus Torvalds }, 8761da177e4SLinus Torvalds [CARDBUS_TYPE_TI1250] = { 8771da177e4SLinus Torvalds .override = ti1250_override, 8781da177e4SLinus Torvalds .save_state = ti_save_state, 8791da177e4SLinus Torvalds .restore_state = ti_restore_state, 8801da177e4SLinus Torvalds .sock_init = ti_init, 8811da177e4SLinus Torvalds }, 88263e7ebd0SDaniel Ritz #endif 88363e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 8841da177e4SLinus Torvalds [CARDBUS_TYPE_RICOH] = { 8851da177e4SLinus Torvalds .override = ricoh_override, 8861da177e4SLinus Torvalds .save_state = ricoh_save_state, 8871da177e4SLinus Torvalds .restore_state = ricoh_restore_state, 8881da177e4SLinus Torvalds }, 88963e7ebd0SDaniel Ritz #endif 89063e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 891ea2f1590SDaniel Ritz [CARDBUS_TYPE_TOPIC95] = { 892ea2f1590SDaniel Ritz .override = topic95_override, 893ea2f1590SDaniel Ritz }, 8941da177e4SLinus Torvalds [CARDBUS_TYPE_TOPIC97] = { 8951da177e4SLinus Torvalds .override = topic97_override, 8961da177e4SLinus Torvalds }, 89763e7ebd0SDaniel Ritz #endif 89863e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 8991da177e4SLinus Torvalds [CARDBUS_TYPE_O2MICRO] = { 9001da177e4SLinus Torvalds .override = o2micro_override, 9011da177e4SLinus Torvalds .restore_state = o2micro_restore_state, 9021da177e4SLinus Torvalds }, 90363e7ebd0SDaniel Ritz #endif 90463e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 9058c3520d4SDaniel Ritz [CARDBUS_TYPE_ENE] = { 9068c3520d4SDaniel Ritz .override = ene_override, 9078c3520d4SDaniel Ritz .save_state = ti_save_state, 9088c3520d4SDaniel Ritz .restore_state = ti_restore_state, 9098c3520d4SDaniel Ritz .sock_init = ti_init, 9108c3520d4SDaniel Ritz }, 91163e7ebd0SDaniel Ritz #endif 9121da177e4SLinus Torvalds }; 9131da177e4SLinus Torvalds 9141da177e4SLinus Torvalds 9151da177e4SLinus Torvalds static unsigned int yenta_probe_irq(struct yenta_socket *socket, u32 isa_irq_mask) 9161da177e4SLinus Torvalds { 9171da177e4SLinus Torvalds int i; 9181da177e4SLinus Torvalds unsigned long val; 9191da177e4SLinus Torvalds u32 mask; 92028ca8dd7SJens Künzer u8 reg; 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds /* 9231da177e4SLinus Torvalds * Probe for usable interrupts using the force 9241da177e4SLinus Torvalds * register to generate bogus card status events. 9251da177e4SLinus Torvalds */ 9261da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9271da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK); 92828ca8dd7SJens Künzer reg = exca_readb(socket, I365_CSCINT); 9291da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 9301da177e4SLinus Torvalds val = probe_irq_on() & isa_irq_mask; 9311da177e4SLinus Torvalds for (i = 1; i < 16; i++) { 9321da177e4SLinus Torvalds if (!((val >> i) & 1)) 9331da177e4SLinus Torvalds continue; 9341da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG | (i << 4)); 9351da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS); 9361da177e4SLinus Torvalds udelay(100); 9371da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9381da177e4SLinus Torvalds } 9391da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0); 94028ca8dd7SJens Künzer exca_writeb(socket, I365_CSCINT, reg); 9411da177e4SLinus Torvalds 9421da177e4SLinus Torvalds mask = probe_irq_mask(val) & 0xffff; 9431da177e4SLinus Torvalds 9441da177e4SLinus Torvalds return mask; 9451da177e4SLinus Torvalds } 9461da177e4SLinus Torvalds 9471da177e4SLinus Torvalds 94878187865SRandy Dunlap /* 94963e7ebd0SDaniel Ritz * yenta PCI irq probing. 95063e7ebd0SDaniel Ritz * currently only used in the TI/EnE initialization code 95163e7ebd0SDaniel Ritz */ 95263e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 95363e7ebd0SDaniel Ritz 9541da177e4SLinus Torvalds /* interrupt handler, only used during probing */ 9557d12e780SDavid Howells static irqreturn_t yenta_probe_handler(int irq, void *dev_id) 9561da177e4SLinus Torvalds { 9571da177e4SLinus Torvalds struct yenta_socket *socket = (struct yenta_socket *) dev_id; 9581da177e4SLinus Torvalds u8 csc; 9591da177e4SLinus Torvalds u32 cb_event; 9601da177e4SLinus Torvalds 9611da177e4SLinus Torvalds /* Clear interrupt status for the event */ 9621da177e4SLinus Torvalds cb_event = cb_readl(socket, CB_SOCKET_EVENT); 9631da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9641da177e4SLinus Torvalds csc = exca_readb(socket, I365_CSC); 9651da177e4SLinus Torvalds 9661da177e4SLinus Torvalds if (cb_event || csc) { 9671da177e4SLinus Torvalds socket->probe_status = 1; 9681da177e4SLinus Torvalds return IRQ_HANDLED; 9691da177e4SLinus Torvalds } 9701da177e4SLinus Torvalds 9711da177e4SLinus Torvalds return IRQ_NONE; 9721da177e4SLinus Torvalds } 9731da177e4SLinus Torvalds 9741da177e4SLinus Torvalds /* probes the PCI interrupt, use only on override functions */ 9751da177e4SLinus Torvalds static int yenta_probe_cb_irq(struct yenta_socket *socket) 9761da177e4SLinus Torvalds { 97728ca8dd7SJens Künzer u8 reg; 97828ca8dd7SJens Künzer 9791da177e4SLinus Torvalds if (!socket->cb_irq) 9801da177e4SLinus Torvalds return -1; 9811da177e4SLinus Torvalds 9821da177e4SLinus Torvalds socket->probe_status = 0; 9831da177e4SLinus Torvalds 984dace1453SThomas Gleixner if (request_irq(socket->cb_irq, yenta_probe_handler, IRQF_SHARED, "yenta", socket)) { 985dd797d81SDominik Brodowski dev_printk(KERN_WARNING, &socket->dev->dev, 986dd797d81SDominik Brodowski "request_irq() in yenta_probe_cb_irq() failed!\n"); 9871da177e4SLinus Torvalds return -1; 9881da177e4SLinus Torvalds } 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds /* generate interrupt, wait */ 99128ca8dd7SJens Künzer reg = exca_readb(socket, I365_CSCINT); 99228ca8dd7SJens Künzer exca_writeb(socket, I365_CSCINT, reg | I365_CSC_STSCHG); 9931da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9941da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK); 9951da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS); 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds msleep(100); 9981da177e4SLinus Torvalds 9991da177e4SLinus Torvalds /* disable interrupts */ 10001da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0); 100128ca8dd7SJens Künzer exca_writeb(socket, I365_CSCINT, reg); 10021da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 10031da177e4SLinus Torvalds exca_readb(socket, I365_CSC); 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvalds free_irq(socket->cb_irq, socket); 10061da177e4SLinus Torvalds 10071da177e4SLinus Torvalds return (int) socket->probe_status; 10081da177e4SLinus Torvalds } 10091da177e4SLinus Torvalds 101063e7ebd0SDaniel Ritz #endif /* CONFIG_YENTA_TI */ 10111da177e4SLinus Torvalds 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds /* 10141da177e4SLinus Torvalds * Set static data that doesn't need re-initializing.. 10151da177e4SLinus Torvalds */ 10161da177e4SLinus Torvalds static void yenta_get_socket_capabilities(struct yenta_socket *socket, u32 isa_irq_mask) 10171da177e4SLinus Torvalds { 10181da177e4SLinus Torvalds socket->socket.pci_irq = socket->cb_irq; 1019fa912bcbSDaniel Ritz if (isa_probe) 10201da177e4SLinus Torvalds socket->socket.irq_mask = yenta_probe_irq(socket, isa_irq_mask); 1021fa912bcbSDaniel Ritz else 1022fa912bcbSDaniel Ritz socket->socket.irq_mask = 0; 10231da177e4SLinus Torvalds 1024dd797d81SDominik Brodowski dev_printk(KERN_INFO, &socket->dev->dev, 1025dd797d81SDominik Brodowski "ISA IRQ mask 0x%04x, PCI irq %d\n", 10261da177e4SLinus Torvalds socket->socket.irq_mask, socket->cb_irq); 10271da177e4SLinus Torvalds } 10281da177e4SLinus Torvalds 10291da177e4SLinus Torvalds /* 10301da177e4SLinus Torvalds * Initialize the standard cardbus registers 10311da177e4SLinus Torvalds */ 10321da177e4SLinus Torvalds static void yenta_config_init(struct yenta_socket *socket) 10331da177e4SLinus Torvalds { 10341da177e4SLinus Torvalds u16 bridge; 10351da177e4SLinus Torvalds struct pci_dev *dev = socket->dev; 10368e5d17ebSDominik Brodowski struct pci_bus_region region; 10371da177e4SLinus Torvalds 10388e5d17ebSDominik Brodowski pcibios_resource_to_bus(socket->dev, ®ion, &dev->resource[0]); 10391da177e4SLinus Torvalds 10401da177e4SLinus Torvalds config_writel(socket, CB_LEGACY_MODE_BASE, 0); 10418e5d17ebSDominik Brodowski config_writel(socket, PCI_BASE_ADDRESS_0, region.start); 10421da177e4SLinus Torvalds config_writew(socket, PCI_COMMAND, 10431da177e4SLinus Torvalds PCI_COMMAND_IO | 10441da177e4SLinus Torvalds PCI_COMMAND_MEMORY | 10451da177e4SLinus Torvalds PCI_COMMAND_MASTER | 10461da177e4SLinus Torvalds PCI_COMMAND_WAIT); 10471da177e4SLinus Torvalds 10481da177e4SLinus Torvalds /* MAGIC NUMBERS! Fixme */ 10491da177e4SLinus Torvalds config_writeb(socket, PCI_CACHE_LINE_SIZE, L1_CACHE_BYTES / 4); 10501da177e4SLinus Torvalds config_writeb(socket, PCI_LATENCY_TIMER, 168); 10511da177e4SLinus Torvalds config_writel(socket, PCI_PRIMARY_BUS, 10521da177e4SLinus Torvalds (176 << 24) | /* sec. latency timer */ 10531da177e4SLinus Torvalds (dev->subordinate->subordinate << 16) | /* subordinate bus */ 10541da177e4SLinus Torvalds (dev->subordinate->secondary << 8) | /* secondary bus */ 10551da177e4SLinus Torvalds dev->subordinate->primary); /* primary bus */ 10561da177e4SLinus Torvalds 10571da177e4SLinus Torvalds /* 10581da177e4SLinus Torvalds * Set up the bridging state: 10591da177e4SLinus Torvalds * - enable write posting. 10601da177e4SLinus Torvalds * - memory window 0 prefetchable, window 1 non-prefetchable 10611da177e4SLinus Torvalds * - PCI interrupts enabled if a PCI interrupt exists.. 10621da177e4SLinus Torvalds */ 10631da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL); 1064a413c090SDaniel Ritz bridge &= ~(CB_BRIDGE_CRST | CB_BRIDGE_PREFETCH1 | CB_BRIDGE_ISAEN | CB_BRIDGE_VGAEN); 1065a413c090SDaniel Ritz bridge |= CB_BRIDGE_PREFETCH0 | CB_BRIDGE_POSTEN; 10661da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 10671da177e4SLinus Torvalds } 10681da177e4SLinus Torvalds 1069b435261bSBernhard Kaindl /** 107066005216SRandy Dunlap * yenta_fixup_parent_bridge - Fix subordinate bus# of the parent bridge 1071b435261bSBernhard Kaindl * @cardbus_bridge: The PCI bus which the CardBus bridge bridges to 1072b435261bSBernhard Kaindl * 1073b435261bSBernhard Kaindl * Checks if devices on the bus which the CardBus bridge bridges to would be 1074b435261bSBernhard Kaindl * invisible during PCI scans because of a misconfigured subordinate number 1075b435261bSBernhard Kaindl * of the parent brige - some BIOSes seem to be too lazy to set it right. 1076b435261bSBernhard Kaindl * Does the fixup carefully by checking how far it can go without conflicts. 107778187865SRandy Dunlap * See http\://bugzilla.kernel.org/show_bug.cgi?id=2944 for more information. 1078b435261bSBernhard Kaindl */ 1079b435261bSBernhard Kaindl static void yenta_fixup_parent_bridge(struct pci_bus *cardbus_bridge) 1080b435261bSBernhard Kaindl { 1081b435261bSBernhard Kaindl struct list_head *tmp; 1082b435261bSBernhard Kaindl unsigned char upper_limit; 1083b435261bSBernhard Kaindl /* 1084b435261bSBernhard Kaindl * We only check and fix the parent bridge: All systems which need 1085b435261bSBernhard Kaindl * this fixup that have been reviewed are laptops and the only bridge 1086b435261bSBernhard Kaindl * which needed fixing was the parent bridge of the CardBus bridge: 1087b435261bSBernhard Kaindl */ 1088b435261bSBernhard Kaindl struct pci_bus *bridge_to_fix = cardbus_bridge->parent; 1089b435261bSBernhard Kaindl 1090b435261bSBernhard Kaindl /* Check bus numbers are already set up correctly: */ 1091b435261bSBernhard Kaindl if (bridge_to_fix->subordinate >= cardbus_bridge->subordinate) 1092b435261bSBernhard Kaindl return; /* The subordinate number is ok, nothing to do */ 1093b435261bSBernhard Kaindl 1094b435261bSBernhard Kaindl if (!bridge_to_fix->parent) 1095b435261bSBernhard Kaindl return; /* Root bridges are ok */ 1096b435261bSBernhard Kaindl 1097b435261bSBernhard Kaindl /* stay within the limits of the bus range of the parent: */ 1098b435261bSBernhard Kaindl upper_limit = bridge_to_fix->parent->subordinate; 1099b435261bSBernhard Kaindl 1100b435261bSBernhard Kaindl /* check the bus ranges of all silbling bridges to prevent overlap */ 1101b435261bSBernhard Kaindl list_for_each(tmp, &bridge_to_fix->parent->children) { 1102b435261bSBernhard Kaindl struct pci_bus *silbling = pci_bus_b(tmp); 1103b435261bSBernhard Kaindl /* 1104b435261bSBernhard Kaindl * If the silbling has a higher secondary bus number 1105b435261bSBernhard Kaindl * and it's secondary is equal or smaller than our 1106b435261bSBernhard Kaindl * current upper limit, set the new upper limit to 1107b435261bSBernhard Kaindl * the bus number below the silbling's range: 1108b435261bSBernhard Kaindl */ 1109b435261bSBernhard Kaindl if (silbling->secondary > bridge_to_fix->subordinate 1110b435261bSBernhard Kaindl && silbling->secondary <= upper_limit) 1111b435261bSBernhard Kaindl upper_limit = silbling->secondary - 1; 1112b435261bSBernhard Kaindl } 1113b435261bSBernhard Kaindl 1114b435261bSBernhard Kaindl /* Show that the wanted subordinate number is not possible: */ 1115b435261bSBernhard Kaindl if (cardbus_bridge->subordinate > upper_limit) 1116dd797d81SDominik Brodowski dev_printk(KERN_WARNING, &cardbus_bridge->dev, 1117dd797d81SDominik Brodowski "Upper limit for fixing this " 1118b435261bSBernhard Kaindl "bridge's parent bridge: #%02x\n", upper_limit); 1119b435261bSBernhard Kaindl 1120b435261bSBernhard Kaindl /* If we have room to increase the bridge's subordinate number, */ 1121b435261bSBernhard Kaindl if (bridge_to_fix->subordinate < upper_limit) { 1122b435261bSBernhard Kaindl 1123b435261bSBernhard Kaindl /* use the highest number of the hidden bus, within limits */ 1124b435261bSBernhard Kaindl unsigned char subordinate_to_assign = 1125b435261bSBernhard Kaindl min(cardbus_bridge->subordinate, upper_limit); 1126b435261bSBernhard Kaindl 1127dd797d81SDominik Brodowski dev_printk(KERN_INFO, &bridge_to_fix->dev, 1128dd797d81SDominik Brodowski "Raising subordinate bus# of parent " 1129b435261bSBernhard Kaindl "bus (#%02x) from #%02x to #%02x\n", 1130b435261bSBernhard Kaindl bridge_to_fix->number, 1131b435261bSBernhard Kaindl bridge_to_fix->subordinate, subordinate_to_assign); 1132b435261bSBernhard Kaindl 1133b435261bSBernhard Kaindl /* Save the new subordinate in the bus struct of the bridge */ 1134b435261bSBernhard Kaindl bridge_to_fix->subordinate = subordinate_to_assign; 1135b435261bSBernhard Kaindl 1136b435261bSBernhard Kaindl /* and update the PCI config space with the new subordinate */ 1137b435261bSBernhard Kaindl pci_write_config_byte(bridge_to_fix->self, 1138b435261bSBernhard Kaindl PCI_SUBORDINATE_BUS, bridge_to_fix->subordinate); 1139b435261bSBernhard Kaindl } 1140b435261bSBernhard Kaindl } 1141b435261bSBernhard Kaindl 11421da177e4SLinus Torvalds /* 11431da177e4SLinus Torvalds * Initialize a cardbus controller. Make sure we have a usable 11441da177e4SLinus Torvalds * interrupt, and that we can map the cardbus area. Fill in the 11451da177e4SLinus Torvalds * socket information structure.. 11461da177e4SLinus Torvalds */ 11471da177e4SLinus Torvalds static int __devinit yenta_probe(struct pci_dev *dev, const struct pci_device_id *id) 11481da177e4SLinus Torvalds { 11491da177e4SLinus Torvalds struct yenta_socket *socket; 11501da177e4SLinus Torvalds int ret; 11511da177e4SLinus Torvalds 1152c7fb0b35SIvan Kokshaysky /* 1153c7fb0b35SIvan Kokshaysky * If we failed to assign proper bus numbers for this cardbus 1154c7fb0b35SIvan Kokshaysky * controller during PCI probe, its subordinate pci_bus is NULL. 1155c7fb0b35SIvan Kokshaysky * Bail out if so. 1156c7fb0b35SIvan Kokshaysky */ 1157c7fb0b35SIvan Kokshaysky if (!dev->subordinate) { 1158dd797d81SDominik Brodowski dev_printk(KERN_ERR, &dev->dev, "no bus associated! " 1159dd797d81SDominik Brodowski "(try 'pci=assign-busses')\n"); 1160c7fb0b35SIvan Kokshaysky return -ENODEV; 1161c7fb0b35SIvan Kokshaysky } 1162c7fb0b35SIvan Kokshaysky 11638084b372SDominik Brodowski socket = kzalloc(sizeof(struct yenta_socket), GFP_KERNEL); 11641da177e4SLinus Torvalds if (!socket) 11651da177e4SLinus Torvalds return -ENOMEM; 11661da177e4SLinus Torvalds 11671da177e4SLinus Torvalds /* prepare pcmcia_socket */ 11681da177e4SLinus Torvalds socket->socket.ops = ¥ta_socket_operations; 11691da177e4SLinus Torvalds socket->socket.resource_ops = &pccard_nonstatic_ops; 117087373318SGreg Kroah-Hartman socket->socket.dev.parent = &dev->dev; 11711da177e4SLinus Torvalds socket->socket.driver_data = socket; 11721da177e4SLinus Torvalds socket->socket.owner = THIS_MODULE; 11735bc6b68aSRussell King socket->socket.features = SS_CAP_PAGE_REGS | SS_CAP_PCCARD; 11745bc6b68aSRussell King socket->socket.map_size = 0x1000; 11755bc6b68aSRussell King socket->socket.cb_dev = dev; 11761da177e4SLinus Torvalds 11771da177e4SLinus Torvalds /* prepare struct yenta_socket */ 11781da177e4SLinus Torvalds socket->dev = dev; 11791da177e4SLinus Torvalds pci_set_drvdata(dev, socket); 11801da177e4SLinus Torvalds 11811da177e4SLinus Torvalds /* 11821da177e4SLinus Torvalds * Do some basic sanity checking.. 11831da177e4SLinus Torvalds */ 11841da177e4SLinus Torvalds if (pci_enable_device(dev)) { 11851da177e4SLinus Torvalds ret = -EBUSY; 11861da177e4SLinus Torvalds goto free; 11871da177e4SLinus Torvalds } 11881da177e4SLinus Torvalds 11891da177e4SLinus Torvalds ret = pci_request_regions(dev, "yenta_socket"); 11901da177e4SLinus Torvalds if (ret) 11911da177e4SLinus Torvalds goto disable; 11921da177e4SLinus Torvalds 11931da177e4SLinus Torvalds if (!pci_resource_start(dev, 0)) { 1194dd797d81SDominik Brodowski dev_printk(KERN_ERR, &dev->dev, "No cardbus resource!\n"); 11951da177e4SLinus Torvalds ret = -ENODEV; 11961da177e4SLinus Torvalds goto release; 11971da177e4SLinus Torvalds } 11981da177e4SLinus Torvalds 11991da177e4SLinus Torvalds /* 12001da177e4SLinus Torvalds * Ok, start setup.. Map the cardbus registers, 12011da177e4SLinus Torvalds * and request the IRQ. 12021da177e4SLinus Torvalds */ 12031da177e4SLinus Torvalds socket->base = ioremap(pci_resource_start(dev, 0), 0x1000); 12041da177e4SLinus Torvalds if (!socket->base) { 12051da177e4SLinus Torvalds ret = -ENOMEM; 12061da177e4SLinus Torvalds goto release; 12071da177e4SLinus Torvalds } 12081da177e4SLinus Torvalds 12091da177e4SLinus Torvalds /* 12101da177e4SLinus Torvalds * report the subsystem vendor and device for help debugging 12111da177e4SLinus Torvalds * the irq stuff... 12121da177e4SLinus Torvalds */ 1213dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, "CardBus bridge found [%04x:%04x]\n", 1214dd797d81SDominik Brodowski dev->subsystem_vendor, dev->subsystem_device); 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds yenta_config_init(socket); 12171da177e4SLinus Torvalds 12181da177e4SLinus Torvalds /* Disable all events */ 12191da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0x0); 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds /* Set up the bridge regions.. */ 12221da177e4SLinus Torvalds yenta_allocate_resources(socket); 12231da177e4SLinus Torvalds 12241da177e4SLinus Torvalds socket->cb_irq = dev->irq; 12251da177e4SLinus Torvalds 12261da177e4SLinus Torvalds /* Do we have special options for the device? */ 12271da177e4SLinus Torvalds if (id->driver_data != CARDBUS_TYPE_DEFAULT && 12281da177e4SLinus Torvalds id->driver_data < ARRAY_SIZE(cardbus_type)) { 12291da177e4SLinus Torvalds socket->type = &cardbus_type[id->driver_data]; 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds ret = socket->type->override(socket); 12321da177e4SLinus Torvalds if (ret < 0) 12331da177e4SLinus Torvalds goto unmap; 12341da177e4SLinus Torvalds } 12351da177e4SLinus Torvalds 12361da177e4SLinus Torvalds /* We must finish initialization here */ 12371da177e4SLinus Torvalds 1238dace1453SThomas Gleixner if (!socket->cb_irq || request_irq(socket->cb_irq, yenta_interrupt, IRQF_SHARED, "yenta", socket)) { 12391da177e4SLinus Torvalds /* No IRQ or request_irq failed. Poll */ 12401da177e4SLinus Torvalds socket->cb_irq = 0; /* But zero is a valid IRQ number. */ 12411da177e4SLinus Torvalds init_timer(&socket->poll_timer); 12421da177e4SLinus Torvalds socket->poll_timer.function = yenta_interrupt_wrapper; 12431da177e4SLinus Torvalds socket->poll_timer.data = (unsigned long)socket; 12441da177e4SLinus Torvalds socket->poll_timer.expires = jiffies + HZ; 12451da177e4SLinus Torvalds add_timer(&socket->poll_timer); 1246dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1247dd797d81SDominik Brodowski "no PCI IRQ, CardBus support disabled for this " 1248dd797d81SDominik Brodowski "socket.\n"); 1249dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1250dd797d81SDominik Brodowski "check your BIOS CardBus, BIOS IRQ or ACPI " 1251dd797d81SDominik Brodowski "settings.\n"); 12525bc6b68aSRussell King } else { 12535bc6b68aSRussell King socket->socket.features |= SS_CAP_CARDBUS; 12541da177e4SLinus Torvalds } 12551da177e4SLinus Torvalds 12561da177e4SLinus Torvalds /* Figure out what the dang thing can do for the PCMCIA layer... */ 1257fa912bcbSDaniel Ritz yenta_interrogate(socket); 12581da177e4SLinus Torvalds yenta_get_socket_capabilities(socket, isa_interrupts); 1259dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1260dd797d81SDominik Brodowski "Socket status: %08x\n", cb_readl(socket, CB_SOCKET_STATE)); 12611da177e4SLinus Torvalds 1262b435261bSBernhard Kaindl yenta_fixup_parent_bridge(dev->subordinate); 1263b435261bSBernhard Kaindl 12641da177e4SLinus Torvalds /* Register it with the pcmcia layer.. */ 12651da177e4SLinus Torvalds ret = pcmcia_register_socket(&socket->socket); 1266030ee39cSLinus Torvalds if (ret == 0) { 1267030ee39cSLinus Torvalds /* Add the yenta register attributes */ 12684deb7c1eSJeff Garzik ret = device_create_file(&dev->dev, &dev_attr_yenta_registers); 12694deb7c1eSJeff Garzik if (ret == 0) 12701da177e4SLinus Torvalds goto out; 12714deb7c1eSJeff Garzik 12724deb7c1eSJeff Garzik /* error path... */ 12734deb7c1eSJeff Garzik pcmcia_unregister_socket(&socket->socket); 1274030ee39cSLinus Torvalds } 12751da177e4SLinus Torvalds 12761da177e4SLinus Torvalds unmap: 12771da177e4SLinus Torvalds iounmap(socket->base); 12781da177e4SLinus Torvalds release: 12791da177e4SLinus Torvalds pci_release_regions(dev); 12801da177e4SLinus Torvalds disable: 12811da177e4SLinus Torvalds pci_disable_device(dev); 12821da177e4SLinus Torvalds free: 12831da177e4SLinus Torvalds kfree(socket); 12841da177e4SLinus Torvalds out: 12851da177e4SLinus Torvalds return ret; 12861da177e4SLinus Torvalds } 12871da177e4SLinus Torvalds 1288f237de58SAlexey Dobriyan #ifdef CONFIG_PM 12890c570cdeSRafael J. Wysocki static int yenta_dev_suspend_noirq(struct device *dev) 12901da177e4SLinus Torvalds { 12910c570cdeSRafael J. Wysocki struct pci_dev *pdev = to_pci_dev(dev); 12920c570cdeSRafael J. Wysocki struct yenta_socket *socket = pci_get_drvdata(pdev); 12931da177e4SLinus Torvalds 12940c570cdeSRafael J. Wysocki if (!socket) 1295d7646f76SDominik Brodowski return 0; 12960c570cdeSRafael J. Wysocki 12971da177e4SLinus Torvalds if (socket->type && socket->type->save_state) 12981da177e4SLinus Torvalds socket->type->save_state(socket); 12991da177e4SLinus Torvalds 13000c570cdeSRafael J. Wysocki pci_save_state(pdev); 13010c570cdeSRafael J. Wysocki pci_read_config_dword(pdev, 16*4, &socket->saved_state[0]); 13020c570cdeSRafael J. Wysocki pci_read_config_dword(pdev, 17*4, &socket->saved_state[1]); 13030c570cdeSRafael J. Wysocki pci_disable_device(pdev); 13041da177e4SLinus Torvalds 13051da177e4SLinus Torvalds /* 13061da177e4SLinus Torvalds * Some laptops (IBM T22) do not like us putting the Cardbus 13071da177e4SLinus Torvalds * bridge into D3. At a guess, some other laptop will 13081da177e4SLinus Torvalds * probably require this, so leave it commented out for now. 13091da177e4SLinus Torvalds */ 13101da177e4SLinus Torvalds /* pci_set_power_state(dev, 3); */ 13111da177e4SLinus Torvalds 1312d7646f76SDominik Brodowski return 0; 13131da177e4SLinus Torvalds } 13141da177e4SLinus Torvalds 13150c570cdeSRafael J. Wysocki static int yenta_dev_resume_noirq(struct device *dev) 13161da177e4SLinus Torvalds { 13170c570cdeSRafael J. Wysocki struct pci_dev *pdev = to_pci_dev(dev); 13180c570cdeSRafael J. Wysocki struct yenta_socket *socket = pci_get_drvdata(pdev); 13190c570cdeSRafael J. Wysocki int ret; 13201da177e4SLinus Torvalds 13210c570cdeSRafael J. Wysocki if (!socket) 13220c570cdeSRafael J. Wysocki return 0; 13234deb7c1eSJeff Garzik 13240c570cdeSRafael J. Wysocki pci_write_config_dword(pdev, 16*4, socket->saved_state[0]); 13250c570cdeSRafael J. Wysocki pci_write_config_dword(pdev, 17*4, socket->saved_state[1]); 13264deb7c1eSJeff Garzik 13270c570cdeSRafael J. Wysocki ret = pci_enable_device(pdev); 13280c570cdeSRafael J. Wysocki if (ret) 13290c570cdeSRafael J. Wysocki return ret; 13304deb7c1eSJeff Garzik 13310c570cdeSRafael J. Wysocki pci_set_master(pdev); 13321da177e4SLinus Torvalds 13331da177e4SLinus Torvalds if (socket->type && socket->type->restore_state) 13341da177e4SLinus Torvalds socket->type->restore_state(socket); 13350c570cdeSRafael J. Wysocki 13369905d1b4SRafael J. Wysocki return 0; 13371da177e4SLinus Torvalds } 13381da177e4SLinus Torvalds 133947145210SAlexey Dobriyan static const struct dev_pm_ops yenta_pm_ops = { 13400c570cdeSRafael J. Wysocki .suspend_noirq = yenta_dev_suspend_noirq, 13410c570cdeSRafael J. Wysocki .resume_noirq = yenta_dev_resume_noirq, 13420c570cdeSRafael J. Wysocki .freeze_noirq = yenta_dev_suspend_noirq, 13430c570cdeSRafael J. Wysocki .thaw_noirq = yenta_dev_resume_noirq, 13440c570cdeSRafael J. Wysocki .poweroff_noirq = yenta_dev_suspend_noirq, 13450c570cdeSRafael J. Wysocki .restore_noirq = yenta_dev_resume_noirq, 13460c570cdeSRafael J. Wysocki }; 13470c570cdeSRafael J. Wysocki 13480c570cdeSRafael J. Wysocki #define YENTA_PM_OPS (¥ta_pm_ops) 13490c570cdeSRafael J. Wysocki #else 13500c570cdeSRafael J. Wysocki #define YENTA_PM_OPS NULL 1351f237de58SAlexey Dobriyan #endif 13521da177e4SLinus Torvalds 13531da177e4SLinus Torvalds #define CB_ID(vend, dev, type) \ 13541da177e4SLinus Torvalds { \ 13551da177e4SLinus Torvalds .vendor = vend, \ 13561da177e4SLinus Torvalds .device = dev, \ 13571da177e4SLinus Torvalds .subvendor = PCI_ANY_ID, \ 13581da177e4SLinus Torvalds .subdevice = PCI_ANY_ID, \ 13591da177e4SLinus Torvalds .class = PCI_CLASS_BRIDGE_CARDBUS << 8, \ 13601da177e4SLinus Torvalds .class_mask = ~0, \ 13611da177e4SLinus Torvalds .driver_data = CARDBUS_TYPE_##type, \ 13621da177e4SLinus Torvalds } 13631da177e4SLinus Torvalds 13641da177e4SLinus Torvalds static struct pci_device_id yenta_table[] = { 13651da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1031, TI), 13661da177e4SLinus Torvalds 13671da177e4SLinus Torvalds /* 13681da177e4SLinus Torvalds * TBD: Check if these TI variants can use more 13691da177e4SLinus Torvalds * advanced overrides instead. (I can't get the 13701da177e4SLinus Torvalds * data sheets for these devices. --rmk) 13711da177e4SLinus Torvalds */ 137263e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 13731da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1210, TI), 13741da177e4SLinus Torvalds 13751da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1130, TI113X), 13761da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1131, TI113X), 13771da177e4SLinus Torvalds 13781da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1211, TI12XX), 13791da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1220, TI12XX), 13801da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1221, TI12XX), 13811da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1225, TI12XX), 13821da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251A, TI12XX), 13831da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251B, TI12XX), 13841da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1420, TI12XX), 13851da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1450, TI12XX), 13861da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1451A, TI12XX), 13871da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1510, TI12XX), 13881da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1520, TI12XX), 13891da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1620, TI12XX), 13901da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4410, TI12XX), 13911da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4450, TI12XX), 13921da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4451, TI12XX), 13931da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4510, TI12XX), 13941da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4520, TI12XX), 13951da177e4SLinus Torvalds 13961da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1250, TI1250), 13971da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1410, TI1250), 13981da177e4SLinus Torvalds 13996c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11, TI12XX), 14006c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X515, TI12XX), 140159e35ba1SAlex Williamson CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12, TI12XX), 14026c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X420, TI12XX), 14036c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X620, TI12XX), 14046c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7410, TI12XX), 14056c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7510, TI12XX), 14066c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7610, TI12XX), 14076c1a10dbSDaniel Ritz 1408f3d4ae43SMichal Pecio CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_710, ENE), 1409f3d4ae43SMichal Pecio CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_712, ENE), 1410f3d4ae43SMichal Pecio CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_720, ENE), 1411f3d4ae43SMichal Pecio CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_722, ENE), 14128c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1211, ENE), 14138c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1225, ENE), 14148c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1410, ENE), 14158c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1420, ENE), 141663e7ebd0SDaniel Ritz #endif /* CONFIG_YENTA_TI */ 14171da177e4SLinus Torvalds 141863e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 14191da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C465, RICOH), 14201da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C466, RICOH), 14211da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C475, RICOH), 14221da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, RICOH), 14231da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C478, RICOH), 142463e7ebd0SDaniel Ritz #endif 14251da177e4SLinus Torvalds 142663e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 1427ea2f1590SDaniel Ritz CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC95, TOPIC95), 14281da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC97, TOPIC97), 14291da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC100, TOPIC97), 143063e7ebd0SDaniel Ritz #endif 14311da177e4SLinus Torvalds 143263e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 14331da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_O2, PCI_ANY_ID, O2MICRO), 143463e7ebd0SDaniel Ritz #endif 14351da177e4SLinus Torvalds 14361da177e4SLinus Torvalds /* match any cardbus bridge */ 14371da177e4SLinus Torvalds CB_ID(PCI_ANY_ID, PCI_ANY_ID, DEFAULT), 14381da177e4SLinus Torvalds { /* all zeroes */ } 14391da177e4SLinus Torvalds }; 14401da177e4SLinus Torvalds MODULE_DEVICE_TABLE(pci, yenta_table); 14411da177e4SLinus Torvalds 14421da177e4SLinus Torvalds 14431da177e4SLinus Torvalds static struct pci_driver yenta_cardbus_driver = { 14441da177e4SLinus Torvalds .name = "yenta_cardbus", 14451da177e4SLinus Torvalds .id_table = yenta_table, 14461da177e4SLinus Torvalds .probe = yenta_probe, 14471da177e4SLinus Torvalds .remove = __devexit_p(yenta_close), 14480c570cdeSRafael J. Wysocki .driver.pm = YENTA_PM_OPS, 14491da177e4SLinus Torvalds }; 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds static int __init yenta_socket_init(void) 14531da177e4SLinus Torvalds { 14541da177e4SLinus Torvalds return pci_register_driver(¥ta_cardbus_driver); 14551da177e4SLinus Torvalds } 14561da177e4SLinus Torvalds 14571da177e4SLinus Torvalds 14581da177e4SLinus Torvalds static void __exit yenta_socket_exit(void) 14591da177e4SLinus Torvalds { 14601da177e4SLinus Torvalds pci_unregister_driver(¥ta_cardbus_driver); 14611da177e4SLinus Torvalds } 14621da177e4SLinus Torvalds 14631da177e4SLinus Torvalds 14641da177e4SLinus Torvalds module_init(yenta_socket_init); 14651da177e4SLinus Torvalds module_exit(yenta_socket_exit); 14661da177e4SLinus Torvalds 14671da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 1468