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> 205a0e3ad6STejun Heo #include <linux/slab.h> 211da177e4SLinus Torvalds 221da177e4SLinus Torvalds #include <pcmcia/ss.h> 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds #include "yenta_socket.h" 251da177e4SLinus Torvalds #include "i82365.h" 261da177e4SLinus Torvalds 2790ab5ee9SRusty Russell static bool disable_clkrun; 281da177e4SLinus Torvalds module_param(disable_clkrun, bool, 0444); 291da177e4SLinus Torvalds MODULE_PARM_DESC(disable_clkrun, "If PC card doesn't function properly, please try this option"); 301da177e4SLinus Torvalds 3190ab5ee9SRusty Russell static bool isa_probe = 1; 32fa912bcbSDaniel Ritz module_param(isa_probe, bool, 0444); 33fa912bcbSDaniel Ritz MODULE_PARM_DESC(isa_probe, "If set ISA interrupts are probed (default). Set to N to disable probing"); 34fa912bcbSDaniel Ritz 3590ab5ee9SRusty Russell static bool pwr_irqs_off; 36fa912bcbSDaniel Ritz module_param(pwr_irqs_off, bool, 0644); 37fa912bcbSDaniel Ritz MODULE_PARM_DESC(pwr_irqs_off, "Force IRQs off during power-on of slot. Use only when seeing IRQ storms!"); 38fa912bcbSDaniel Ritz 3935169529SWolfram Sang static char o2_speedup[] = "default"; 4035169529SWolfram Sang module_param_string(o2_speedup, o2_speedup, sizeof(o2_speedup), 0444); 4135169529SWolfram Sang MODULE_PARM_DESC(o2_speedup, "Use prefetch/burst for O2-bridges: 'on', 'off' " 4235169529SWolfram Sang "or 'default' (uses recommended behaviour for the detected bridge)"); 4335169529SWolfram Sang 440d3a940dSJens Künzer /* 450d3a940dSJens Künzer * Only probe "regular" interrupts, don't 460d3a940dSJens Künzer * touch dangerous spots like the mouse irq, 470d3a940dSJens Künzer * because there are mice that apparently 480d3a940dSJens Künzer * get really confused if they get fondled 490d3a940dSJens Künzer * too intimately. 500d3a940dSJens Künzer * 510d3a940dSJens Künzer * Default to 11, 10, 9, 7, 6, 5, 4, 3. 520d3a940dSJens Künzer */ 530d3a940dSJens Künzer static u32 isa_interrupts = 0x0ef8; 540d3a940dSJens Künzer 550d3a940dSJens Künzer 56dd797d81SDominik Brodowski #define debug(x, s, args...) dev_dbg(&s->dev->dev, x, ##args) 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds /* Don't ask.. */ 591da177e4SLinus Torvalds #define to_cycles(ns) ((ns)/120) 601da177e4SLinus Torvalds #define to_ns(cycles) ((cycles)*120) 611da177e4SLinus Torvalds 6278187865SRandy Dunlap /* 6363e7ebd0SDaniel Ritz * yenta PCI irq probing. 6463e7ebd0SDaniel Ritz * currently only used in the TI/EnE initialization code 6563e7ebd0SDaniel Ritz */ 6663e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 671da177e4SLinus Torvalds static int yenta_probe_cb_irq(struct yenta_socket *socket); 680d3a940dSJens Künzer static unsigned int yenta_probe_irq(struct yenta_socket *socket, 690d3a940dSJens Künzer u32 isa_irq_mask); 7063e7ebd0SDaniel Ritz #endif 711da177e4SLinus Torvalds 721da177e4SLinus Torvalds 731da177e4SLinus Torvalds static unsigned int override_bios; 741da177e4SLinus Torvalds module_param(override_bios, uint, 0000); 751da177e4SLinus Torvalds MODULE_PARM_DESC(override_bios, "yenta ignore bios resource allocation"); 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds /* 781da177e4SLinus Torvalds * Generate easy-to-use ways of reading a cardbus sockets 791da177e4SLinus Torvalds * regular memory space ("cb_xxx"), configuration space 801da177e4SLinus Torvalds * ("config_xxx") and compatibility space ("exca_xxxx") 811da177e4SLinus Torvalds */ 821da177e4SLinus Torvalds static inline u32 cb_readl(struct yenta_socket *socket, unsigned reg) 831da177e4SLinus Torvalds { 841da177e4SLinus Torvalds u32 val = readl(socket->base + reg); 85dd797d81SDominik Brodowski debug("%04x %08x\n", socket, reg, val); 861da177e4SLinus Torvalds return val; 871da177e4SLinus Torvalds } 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds static inline void cb_writel(struct yenta_socket *socket, unsigned reg, u32 val) 901da177e4SLinus Torvalds { 91dd797d81SDominik Brodowski debug("%04x %08x\n", socket, reg, val); 921da177e4SLinus Torvalds writel(val, socket->base + reg); 93c8751e4cSDaniel Ritz readl(socket->base + reg); /* avoid problems with PCI write posting */ 941da177e4SLinus Torvalds } 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds static inline u8 config_readb(struct yenta_socket *socket, unsigned offset) 971da177e4SLinus Torvalds { 981da177e4SLinus Torvalds u8 val; 991da177e4SLinus Torvalds pci_read_config_byte(socket->dev, offset, &val); 100dd797d81SDominik Brodowski debug("%04x %02x\n", socket, offset, val); 1011da177e4SLinus Torvalds return val; 1021da177e4SLinus Torvalds } 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds static inline u16 config_readw(struct yenta_socket *socket, unsigned offset) 1051da177e4SLinus Torvalds { 1061da177e4SLinus Torvalds u16 val; 1071da177e4SLinus Torvalds pci_read_config_word(socket->dev, offset, &val); 108dd797d81SDominik Brodowski debug("%04x %04x\n", socket, offset, val); 1091da177e4SLinus Torvalds return val; 1101da177e4SLinus Torvalds } 1111da177e4SLinus Torvalds 1121da177e4SLinus Torvalds static inline u32 config_readl(struct yenta_socket *socket, unsigned offset) 1131da177e4SLinus Torvalds { 1141da177e4SLinus Torvalds u32 val; 1151da177e4SLinus Torvalds pci_read_config_dword(socket->dev, offset, &val); 116dd797d81SDominik Brodowski debug("%04x %08x\n", socket, offset, val); 1171da177e4SLinus Torvalds return val; 1181da177e4SLinus Torvalds } 1191da177e4SLinus Torvalds 1201da177e4SLinus Torvalds static inline void config_writeb(struct yenta_socket *socket, unsigned offset, u8 val) 1211da177e4SLinus Torvalds { 122dd797d81SDominik Brodowski debug("%04x %02x\n", socket, offset, val); 1231da177e4SLinus Torvalds pci_write_config_byte(socket->dev, offset, val); 1241da177e4SLinus Torvalds } 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds static inline void config_writew(struct yenta_socket *socket, unsigned offset, u16 val) 1271da177e4SLinus Torvalds { 128dd797d81SDominik Brodowski debug("%04x %04x\n", socket, offset, val); 1291da177e4SLinus Torvalds pci_write_config_word(socket->dev, offset, val); 1301da177e4SLinus Torvalds } 1311da177e4SLinus Torvalds 1321da177e4SLinus Torvalds static inline void config_writel(struct yenta_socket *socket, unsigned offset, u32 val) 1331da177e4SLinus Torvalds { 134dd797d81SDominik Brodowski debug("%04x %08x\n", socket, offset, val); 1351da177e4SLinus Torvalds pci_write_config_dword(socket->dev, offset, val); 1361da177e4SLinus Torvalds } 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds static inline u8 exca_readb(struct yenta_socket *socket, unsigned reg) 1391da177e4SLinus Torvalds { 1401da177e4SLinus Torvalds u8 val = readb(socket->base + 0x800 + reg); 141dd797d81SDominik Brodowski debug("%04x %02x\n", socket, reg, val); 1421da177e4SLinus Torvalds return val; 1431da177e4SLinus Torvalds } 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds static inline u8 exca_readw(struct yenta_socket *socket, unsigned reg) 1461da177e4SLinus Torvalds { 1471da177e4SLinus Torvalds u16 val; 1481da177e4SLinus Torvalds val = readb(socket->base + 0x800 + reg); 1491da177e4SLinus Torvalds val |= readb(socket->base + 0x800 + reg + 1) << 8; 150dd797d81SDominik Brodowski debug("%04x %04x\n", socket, reg, val); 1511da177e4SLinus Torvalds return val; 1521da177e4SLinus Torvalds } 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds static inline void exca_writeb(struct yenta_socket *socket, unsigned reg, u8 val) 1551da177e4SLinus Torvalds { 156dd797d81SDominik Brodowski debug("%04x %02x\n", socket, reg, val); 1571da177e4SLinus Torvalds writeb(val, socket->base + 0x800 + reg); 158c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg); /* PCI write posting... */ 1591da177e4SLinus Torvalds } 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds static void exca_writew(struct yenta_socket *socket, unsigned reg, u16 val) 1621da177e4SLinus Torvalds { 163dd797d81SDominik Brodowski debug("%04x %04x\n", socket, reg, val); 1641da177e4SLinus Torvalds writeb(val, socket->base + 0x800 + reg); 1651da177e4SLinus Torvalds writeb(val >> 8, socket->base + 0x800 + reg + 1); 166c8751e4cSDaniel Ritz 167c8751e4cSDaniel Ritz /* PCI write posting... */ 168c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg); 169c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg + 1); 1701da177e4SLinus Torvalds } 1711da177e4SLinus Torvalds 172030ee39cSLinus Torvalds static ssize_t show_yenta_registers(struct device *yentadev, struct device_attribute *attr, char *buf) 173030ee39cSLinus Torvalds { 174030ee39cSLinus Torvalds struct pci_dev *dev = to_pci_dev(yentadev); 175030ee39cSLinus Torvalds struct yenta_socket *socket = pci_get_drvdata(dev); 176030ee39cSLinus Torvalds int offset = 0, i; 177030ee39cSLinus Torvalds 178030ee39cSLinus Torvalds offset = snprintf(buf, PAGE_SIZE, "CB registers:"); 179030ee39cSLinus Torvalds for (i = 0; i < 0x24; i += 4) { 180030ee39cSLinus Torvalds unsigned val; 181030ee39cSLinus Torvalds if (!(i & 15)) 182030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i); 183030ee39cSLinus Torvalds val = cb_readl(socket, i); 184030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, " %08x", val); 185030ee39cSLinus Torvalds } 186030ee39cSLinus Torvalds 187030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n\nExCA registers:"); 188030ee39cSLinus Torvalds for (i = 0; i < 0x45; i++) { 189030ee39cSLinus Torvalds unsigned char val; 190030ee39cSLinus Torvalds if (!(i & 7)) { 191030ee39cSLinus Torvalds if (i & 8) { 192030ee39cSLinus Torvalds memcpy(buf + offset, " -", 2); 193030ee39cSLinus Torvalds offset += 2; 194030ee39cSLinus Torvalds } else 195030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i); 196030ee39cSLinus Torvalds } 197030ee39cSLinus Torvalds val = exca_readb(socket, i); 198030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, " %02x", val); 199030ee39cSLinus Torvalds } 200030ee39cSLinus Torvalds buf[offset++] = '\n'; 201030ee39cSLinus Torvalds return offset; 202030ee39cSLinus Torvalds } 203030ee39cSLinus Torvalds 204030ee39cSLinus Torvalds static DEVICE_ATTR(yenta_registers, S_IRUSR, show_yenta_registers, NULL); 205030ee39cSLinus Torvalds 2061da177e4SLinus Torvalds /* 2071da177e4SLinus Torvalds * Ugh, mixed-mode cardbus and 16-bit pccard state: things depend 2081da177e4SLinus Torvalds * on what kind of card is inserted.. 2091da177e4SLinus Torvalds */ 2101da177e4SLinus Torvalds static int yenta_get_status(struct pcmcia_socket *sock, unsigned int *value) 2111da177e4SLinus Torvalds { 2121da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 2131da177e4SLinus Torvalds unsigned int val; 2141da177e4SLinus Torvalds u32 state = cb_readl(socket, CB_SOCKET_STATE); 2151da177e4SLinus Torvalds 2161da177e4SLinus Torvalds val = (state & CB_3VCARD) ? SS_3VCARD : 0; 2171da177e4SLinus Torvalds val |= (state & CB_XVCARD) ? SS_XVCARD : 0; 218fa912bcbSDaniel Ritz val |= (state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) ? 0 : SS_PENDING; 219fa912bcbSDaniel Ritz val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? SS_PENDING : 0; 220fa912bcbSDaniel Ritz 2211da177e4SLinus Torvalds 2221da177e4SLinus Torvalds if (state & CB_CBCARD) { 2231da177e4SLinus Torvalds val |= SS_CARDBUS; 2241da177e4SLinus Torvalds val |= (state & CB_CARDSTS) ? SS_STSCHG : 0; 2251da177e4SLinus Torvalds val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? 0 : SS_DETECT; 2261da177e4SLinus Torvalds val |= (state & CB_PWRCYCLE) ? SS_POWERON | SS_READY : 0; 227fa912bcbSDaniel Ritz } else if (state & CB_16BITCARD) { 2281da177e4SLinus Torvalds u8 status = exca_readb(socket, I365_STATUS); 2291da177e4SLinus Torvalds val |= ((status & I365_CS_DETECT) == I365_CS_DETECT) ? SS_DETECT : 0; 2301da177e4SLinus Torvalds if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { 2311da177e4SLinus Torvalds val |= (status & I365_CS_STSCHG) ? 0 : SS_STSCHG; 2321da177e4SLinus Torvalds } else { 2331da177e4SLinus Torvalds val |= (status & I365_CS_BVD1) ? 0 : SS_BATDEAD; 2341da177e4SLinus Torvalds val |= (status & I365_CS_BVD2) ? 0 : SS_BATWARN; 2351da177e4SLinus Torvalds } 2361da177e4SLinus Torvalds val |= (status & I365_CS_WRPROT) ? SS_WRPROT : 0; 2371da177e4SLinus Torvalds val |= (status & I365_CS_READY) ? SS_READY : 0; 2381da177e4SLinus Torvalds val |= (status & I365_CS_POWERON) ? SS_POWERON : 0; 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds *value = val; 2421da177e4SLinus Torvalds return 0; 2431da177e4SLinus Torvalds } 2441da177e4SLinus Torvalds 2451da177e4SLinus Torvalds static void yenta_set_power(struct yenta_socket *socket, socket_state_t *state) 2461da177e4SLinus Torvalds { 247ea2f1590SDaniel Ritz /* some birdges require to use the ExCA registers to power 16bit cards */ 248ea2f1590SDaniel Ritz if (!(cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) && 249ea2f1590SDaniel Ritz (socket->flags & YENTA_16BIT_POWER_EXCA)) { 250ea2f1590SDaniel Ritz u8 reg, old; 251ea2f1590SDaniel Ritz reg = old = exca_readb(socket, I365_POWER); 252ea2f1590SDaniel Ritz reg &= ~(I365_VCC_MASK | I365_VPP1_MASK | I365_VPP2_MASK); 253ea2f1590SDaniel Ritz 254ea2f1590SDaniel Ritz /* i82365SL-DF style */ 255ea2f1590SDaniel Ritz if (socket->flags & YENTA_16BIT_POWER_DF) { 256ea2f1590SDaniel Ritz switch (state->Vcc) { 2579fea84f4SDominik Brodowski case 33: 2589fea84f4SDominik Brodowski reg |= I365_VCC_3V; 2599fea84f4SDominik Brodowski break; 2609fea84f4SDominik Brodowski case 50: 2619fea84f4SDominik Brodowski reg |= I365_VCC_5V; 2629fea84f4SDominik Brodowski break; 2639fea84f4SDominik Brodowski default: 2649fea84f4SDominik Brodowski reg = 0; 2659fea84f4SDominik Brodowski break; 266ea2f1590SDaniel Ritz } 267ea2f1590SDaniel Ritz switch (state->Vpp) { 268ea2f1590SDaniel Ritz case 33: 2699fea84f4SDominik Brodowski case 50: 2709fea84f4SDominik Brodowski reg |= I365_VPP1_5V; 2719fea84f4SDominik Brodowski break; 2729fea84f4SDominik Brodowski case 120: 2739fea84f4SDominik Brodowski reg |= I365_VPP1_12V; 2749fea84f4SDominik Brodowski break; 275ea2f1590SDaniel Ritz } 276ea2f1590SDaniel Ritz } else { 277ea2f1590SDaniel Ritz /* i82365SL-B style */ 278ea2f1590SDaniel Ritz switch (state->Vcc) { 2799fea84f4SDominik Brodowski case 50: 2809fea84f4SDominik Brodowski reg |= I365_VCC_5V; 2819fea84f4SDominik Brodowski break; 2829fea84f4SDominik Brodowski default: 2839fea84f4SDominik Brodowski reg = 0; 2849fea84f4SDominik Brodowski break; 285ea2f1590SDaniel Ritz } 286ea2f1590SDaniel Ritz switch (state->Vpp) { 2879fea84f4SDominik Brodowski case 50: 2889fea84f4SDominik Brodowski reg |= I365_VPP1_5V | I365_VPP2_5V; 2899fea84f4SDominik Brodowski break; 2909fea84f4SDominik Brodowski case 120: 2919fea84f4SDominik Brodowski reg |= I365_VPP1_12V | I365_VPP2_12V; 2929fea84f4SDominik Brodowski break; 293ea2f1590SDaniel Ritz } 294ea2f1590SDaniel Ritz } 295ea2f1590SDaniel Ritz 296ea2f1590SDaniel Ritz if (reg != old) 297ea2f1590SDaniel Ritz exca_writeb(socket, I365_POWER, reg); 298ea2f1590SDaniel Ritz } else { 2991da177e4SLinus Torvalds u32 reg = 0; /* CB_SC_STPCLK? */ 3001da177e4SLinus Torvalds switch (state->Vcc) { 3019fea84f4SDominik Brodowski case 33: 3029fea84f4SDominik Brodowski reg = CB_SC_VCC_3V; 3039fea84f4SDominik Brodowski break; 3049fea84f4SDominik Brodowski case 50: 3059fea84f4SDominik Brodowski reg = CB_SC_VCC_5V; 3069fea84f4SDominik Brodowski break; 3079fea84f4SDominik Brodowski default: 3089fea84f4SDominik Brodowski reg = 0; 3099fea84f4SDominik Brodowski break; 3101da177e4SLinus Torvalds } 3111da177e4SLinus Torvalds switch (state->Vpp) { 3129fea84f4SDominik Brodowski case 33: 3139fea84f4SDominik Brodowski reg |= CB_SC_VPP_3V; 3149fea84f4SDominik Brodowski break; 3159fea84f4SDominik Brodowski case 50: 3169fea84f4SDominik Brodowski reg |= CB_SC_VPP_5V; 3179fea84f4SDominik Brodowski break; 3189fea84f4SDominik Brodowski case 120: 3199fea84f4SDominik Brodowski reg |= CB_SC_VPP_12V; 3209fea84f4SDominik Brodowski break; 3211da177e4SLinus Torvalds } 3221da177e4SLinus Torvalds if (reg != cb_readl(socket, CB_SOCKET_CONTROL)) 3231da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_CONTROL, reg); 3241da177e4SLinus Torvalds } 325ea2f1590SDaniel Ritz } 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds static int yenta_set_socket(struct pcmcia_socket *sock, socket_state_t *state) 3281da177e4SLinus Torvalds { 3291da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 3301da177e4SLinus Torvalds u16 bridge; 3311da177e4SLinus Torvalds 332d250a481SDaniel Ritz /* if powering down: do it immediately */ 333d250a481SDaniel Ritz if (state->Vcc == 0) 3341da177e4SLinus Torvalds yenta_set_power(socket, state); 335d250a481SDaniel Ritz 3361da177e4SLinus Torvalds socket->io_irq = state->io_irq; 3371da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL) & ~(CB_BRIDGE_CRST | CB_BRIDGE_INTR); 3381da177e4SLinus Torvalds if (cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) { 3391da177e4SLinus Torvalds u8 intr; 3401da177e4SLinus Torvalds bridge |= (state->flags & SS_RESET) ? CB_BRIDGE_CRST : 0; 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds /* ISA interrupt control? */ 3431da177e4SLinus Torvalds intr = exca_readb(socket, I365_INTCTL); 3441da177e4SLinus Torvalds intr = (intr & ~0xf); 345ba8819e9SJens Künzer if (!socket->dev->irq) { 346ba8819e9SJens Künzer intr |= socket->cb_irq ? socket->cb_irq : state->io_irq; 3471da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 3481da177e4SLinus Torvalds } 3491da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, intr); 3501da177e4SLinus Torvalds } else { 3511da177e4SLinus Torvalds u8 reg; 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds reg = exca_readb(socket, I365_INTCTL) & (I365_RING_ENA | I365_INTR_ENA); 3541da177e4SLinus Torvalds reg |= (state->flags & SS_RESET) ? 0 : I365_PC_RESET; 3551da177e4SLinus Torvalds reg |= (state->flags & SS_IOCARD) ? I365_PC_IOCARD : 0; 356ba8819e9SJens Künzer if (state->io_irq != socket->dev->irq) { 3571da177e4SLinus Torvalds reg |= state->io_irq; 3581da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 3591da177e4SLinus Torvalds } 3601da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, reg); 3611da177e4SLinus Torvalds 3621da177e4SLinus Torvalds reg = exca_readb(socket, I365_POWER) & (I365_VCC_MASK|I365_VPP1_MASK); 3631da177e4SLinus Torvalds reg |= I365_PWR_NORESET; 3649fea84f4SDominik Brodowski if (state->flags & SS_PWR_AUTO) 3659fea84f4SDominik Brodowski reg |= I365_PWR_AUTO; 3669fea84f4SDominik Brodowski if (state->flags & SS_OUTPUT_ENA) 3679fea84f4SDominik Brodowski reg |= I365_PWR_OUT; 3681da177e4SLinus Torvalds if (exca_readb(socket, I365_POWER) != reg) 3691da177e4SLinus Torvalds exca_writeb(socket, I365_POWER, reg); 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds /* CSC interrupt: no ISA irq for CSC */ 37228ca8dd7SJens Künzer reg = exca_readb(socket, I365_CSCINT); 37328ca8dd7SJens Künzer reg &= I365_CSC_IRQ_MASK; 37428ca8dd7SJens Künzer reg |= I365_CSC_DETECT; 3751da177e4SLinus Torvalds if (state->flags & SS_IOCARD) { 3769fea84f4SDominik Brodowski if (state->csc_mask & SS_STSCHG) 3779fea84f4SDominik Brodowski reg |= I365_CSC_STSCHG; 3781da177e4SLinus Torvalds } else { 3799fea84f4SDominik Brodowski if (state->csc_mask & SS_BATDEAD) 3809fea84f4SDominik Brodowski reg |= I365_CSC_BVD1; 3819fea84f4SDominik Brodowski if (state->csc_mask & SS_BATWARN) 3829fea84f4SDominik Brodowski reg |= I365_CSC_BVD2; 3839fea84f4SDominik Brodowski if (state->csc_mask & SS_READY) 3849fea84f4SDominik Brodowski reg |= I365_CSC_READY; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, reg); 3871da177e4SLinus Torvalds exca_readb(socket, I365_CSC); 3881da177e4SLinus Torvalds if (sock->zoom_video) 3891da177e4SLinus Torvalds sock->zoom_video(sock, state->flags & SS_ZVCARD); 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 3921da177e4SLinus Torvalds /* Socket event mask: get card insert/remove events.. */ 3931da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 3941da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK); 395d250a481SDaniel Ritz 396d250a481SDaniel Ritz /* if powering up: do it as the last step when the socket is configured */ 397d250a481SDaniel Ritz if (state->Vcc != 0) 398d250a481SDaniel Ritz yenta_set_power(socket, state); 3991da177e4SLinus Torvalds return 0; 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds static int yenta_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io) 4031da177e4SLinus Torvalds { 4041da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 4051da177e4SLinus Torvalds int map; 4061da177e4SLinus Torvalds unsigned char ioctl, addr, enable; 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds map = io->map; 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds if (map > 1) 4111da177e4SLinus Torvalds return -EINVAL; 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds enable = I365_ENA_IO(map); 4141da177e4SLinus Torvalds addr = exca_readb(socket, I365_ADDRWIN); 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds /* Disable the window before changing it.. */ 4171da177e4SLinus Torvalds if (addr & enable) { 4181da177e4SLinus Torvalds addr &= ~enable; 4191da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr); 4201da177e4SLinus Torvalds } 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds exca_writew(socket, I365_IO(map)+I365_W_START, io->start); 4231da177e4SLinus Torvalds exca_writew(socket, I365_IO(map)+I365_W_STOP, io->stop); 4241da177e4SLinus Torvalds 4251da177e4SLinus Torvalds ioctl = exca_readb(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map); 4269fea84f4SDominik Brodowski if (io->flags & MAP_0WS) 4279fea84f4SDominik Brodowski ioctl |= I365_IOCTL_0WS(map); 4289fea84f4SDominik Brodowski if (io->flags & MAP_16BIT) 4299fea84f4SDominik Brodowski ioctl |= I365_IOCTL_16BIT(map); 4309fea84f4SDominik Brodowski if (io->flags & MAP_AUTOSZ) 4319fea84f4SDominik Brodowski ioctl |= I365_IOCTL_IOCS16(map); 4321da177e4SLinus Torvalds exca_writeb(socket, I365_IOCTL, ioctl); 4331da177e4SLinus Torvalds 4341da177e4SLinus Torvalds if (io->flags & MAP_ACTIVE) 4351da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr | enable); 4361da177e4SLinus Torvalds return 0; 4371da177e4SLinus Torvalds } 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds static int yenta_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem) 4401da177e4SLinus Torvalds { 4411da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 4421da177e4SLinus Torvalds struct pci_bus_region region; 4431da177e4SLinus Torvalds int map; 4441da177e4SLinus Torvalds unsigned char addr, enable; 4451da177e4SLinus Torvalds unsigned int start, stop, card_start; 4461da177e4SLinus Torvalds unsigned short word; 4471da177e4SLinus Torvalds 4481da177e4SLinus Torvalds pcibios_resource_to_bus(socket->dev, ®ion, mem->res); 4491da177e4SLinus Torvalds 4501da177e4SLinus Torvalds map = mem->map; 4511da177e4SLinus Torvalds start = region.start; 4521da177e4SLinus Torvalds stop = region.end; 4531da177e4SLinus Torvalds card_start = mem->card_start; 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds if (map > 4 || start > stop || ((start ^ stop) >> 24) || 4561da177e4SLinus Torvalds (card_start >> 26) || mem->speed > 1000) 4571da177e4SLinus Torvalds return -EINVAL; 4581da177e4SLinus Torvalds 4591da177e4SLinus Torvalds enable = I365_ENA_MEM(map); 4601da177e4SLinus Torvalds addr = exca_readb(socket, I365_ADDRWIN); 4611da177e4SLinus Torvalds if (addr & enable) { 4621da177e4SLinus Torvalds addr &= ~enable; 4631da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr); 4641da177e4SLinus Torvalds } 4651da177e4SLinus Torvalds 4661da177e4SLinus Torvalds exca_writeb(socket, CB_MEM_PAGE(map), start >> 24); 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds word = (start >> 12) & 0x0fff; 4691da177e4SLinus Torvalds if (mem->flags & MAP_16BIT) 4701da177e4SLinus Torvalds word |= I365_MEM_16BIT; 4711da177e4SLinus Torvalds if (mem->flags & MAP_0WS) 4721da177e4SLinus Torvalds word |= I365_MEM_0WS; 4731da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_START, word); 4741da177e4SLinus Torvalds 4751da177e4SLinus Torvalds word = (stop >> 12) & 0x0fff; 4761da177e4SLinus Torvalds switch (to_cycles(mem->speed)) { 4779fea84f4SDominik Brodowski case 0: 4789fea84f4SDominik Brodowski break; 4799fea84f4SDominik Brodowski case 1: 4809fea84f4SDominik Brodowski word |= I365_MEM_WS0; 4819fea84f4SDominik Brodowski break; 4829fea84f4SDominik Brodowski case 2: 4839fea84f4SDominik Brodowski word |= I365_MEM_WS1; 4849fea84f4SDominik Brodowski break; 4859fea84f4SDominik Brodowski default: 4869fea84f4SDominik Brodowski word |= I365_MEM_WS1 | I365_MEM_WS0; 4879fea84f4SDominik Brodowski break; 4881da177e4SLinus Torvalds } 4891da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_STOP, word); 4901da177e4SLinus Torvalds 4911da177e4SLinus Torvalds word = ((card_start - start) >> 12) & 0x3fff; 4921da177e4SLinus Torvalds if (mem->flags & MAP_WRPROT) 4931da177e4SLinus Torvalds word |= I365_MEM_WRPROT; 4941da177e4SLinus Torvalds if (mem->flags & MAP_ATTRIB) 4951da177e4SLinus Torvalds word |= I365_MEM_REG; 4961da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_OFF, word); 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds if (mem->flags & MAP_ACTIVE) 4991da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr | enable); 5001da177e4SLinus Torvalds return 0; 5011da177e4SLinus Torvalds } 5021da177e4SLinus Torvalds 5031da177e4SLinus Torvalds 504fa912bcbSDaniel Ritz 5057d12e780SDavid Howells static irqreturn_t yenta_interrupt(int irq, void *dev_id) 5061da177e4SLinus Torvalds { 507fa912bcbSDaniel Ritz unsigned int events; 508fa912bcbSDaniel Ritz struct yenta_socket *socket = (struct yenta_socket *) dev_id; 5091da177e4SLinus Torvalds u8 csc; 5101da177e4SLinus Torvalds u32 cb_event; 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds /* Clear interrupt status for the event */ 5131da177e4SLinus Torvalds cb_event = cb_readl(socket, CB_SOCKET_EVENT); 5141da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, cb_event); 5151da177e4SLinus Torvalds 5161da177e4SLinus Torvalds csc = exca_readb(socket, I365_CSC); 5171da177e4SLinus Torvalds 518e4115805SDaniel Ritz if (!(cb_event || csc)) 519e4115805SDaniel Ritz return IRQ_NONE; 520e4115805SDaniel Ritz 5211da177e4SLinus Torvalds events = (cb_event & (CB_CD1EVENT | CB_CD2EVENT)) ? SS_DETECT : 0 ; 5221da177e4SLinus Torvalds events |= (csc & I365_CSC_DETECT) ? SS_DETECT : 0; 5231da177e4SLinus Torvalds if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { 5241da177e4SLinus Torvalds events |= (csc & I365_CSC_STSCHG) ? SS_STSCHG : 0; 5251da177e4SLinus Torvalds } else { 5261da177e4SLinus Torvalds events |= (csc & I365_CSC_BVD1) ? SS_BATDEAD : 0; 5271da177e4SLinus Torvalds events |= (csc & I365_CSC_BVD2) ? SS_BATWARN : 0; 5281da177e4SLinus Torvalds events |= (csc & I365_CSC_READY) ? SS_READY : 0; 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds 531fa912bcbSDaniel Ritz if (events) 5321da177e4SLinus Torvalds pcmcia_parse_events(&socket->socket, events); 533fa912bcbSDaniel Ritz 5341da177e4SLinus Torvalds return IRQ_HANDLED; 5351da177e4SLinus Torvalds } 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds static void yenta_interrupt_wrapper(unsigned long data) 5381da177e4SLinus Torvalds { 5391da177e4SLinus Torvalds struct yenta_socket *socket = (struct yenta_socket *) data; 5401da177e4SLinus Torvalds 5417d12e780SDavid Howells yenta_interrupt(0, (void *)socket); 5421da177e4SLinus Torvalds socket->poll_timer.expires = jiffies + HZ; 5431da177e4SLinus Torvalds add_timer(&socket->poll_timer); 5441da177e4SLinus Torvalds } 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds static void yenta_clear_maps(struct yenta_socket *socket) 5471da177e4SLinus Torvalds { 5481da177e4SLinus Torvalds int i; 5491da177e4SLinus Torvalds struct resource res = { .start = 0, .end = 0x0fff }; 5501da177e4SLinus Torvalds pccard_io_map io = { 0, 0, 0, 0, 1 }; 5511da177e4SLinus Torvalds pccard_mem_map mem = { .res = &res, }; 5521da177e4SLinus Torvalds 5531da177e4SLinus Torvalds yenta_set_socket(&socket->socket, &dead_socket); 5541da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 5551da177e4SLinus Torvalds io.map = i; 5561da177e4SLinus Torvalds yenta_set_io_map(&socket->socket, &io); 5571da177e4SLinus Torvalds } 5581da177e4SLinus Torvalds for (i = 0; i < 5; i++) { 5591da177e4SLinus Torvalds mem.map = i; 5601da177e4SLinus Torvalds yenta_set_mem_map(&socket->socket, &mem); 5611da177e4SLinus Torvalds } 5621da177e4SLinus Torvalds } 5631da177e4SLinus Torvalds 564fa912bcbSDaniel Ritz /* redoes voltage interrogation if required */ 565fa912bcbSDaniel Ritz static void yenta_interrogate(struct yenta_socket *socket) 566fa912bcbSDaniel Ritz { 567fa912bcbSDaniel Ritz u32 state; 568fa912bcbSDaniel Ritz 569fa912bcbSDaniel Ritz state = cb_readl(socket, CB_SOCKET_STATE); 570fa912bcbSDaniel Ritz if (!(state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) || 571fa912bcbSDaniel Ritz (state & (CB_CDETECT1 | CB_CDETECT2 | CB_NOTACARD | CB_BADVCCREQ)) || 572fa912bcbSDaniel Ritz ((state & (CB_16BITCARD | CB_CBCARD)) == (CB_16BITCARD | CB_CBCARD))) 573fa912bcbSDaniel Ritz cb_writel(socket, CB_SOCKET_FORCE, CB_CVSTEST); 574fa912bcbSDaniel Ritz } 575fa912bcbSDaniel Ritz 5761da177e4SLinus Torvalds /* Called at resume and initialization events */ 5771da177e4SLinus Torvalds static int yenta_sock_init(struct pcmcia_socket *sock) 5781da177e4SLinus Torvalds { 5791da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds exca_writeb(socket, I365_GBLCTL, 0x00); 5821da177e4SLinus Torvalds exca_writeb(socket, I365_GENCTL, 0x00); 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds /* Redo card voltage interrogation */ 585fa912bcbSDaniel Ritz yenta_interrogate(socket); 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds yenta_clear_maps(socket); 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds if (socket->type && socket->type->sock_init) 5901da177e4SLinus Torvalds socket->type->sock_init(socket); 5911da177e4SLinus Torvalds 5921da177e4SLinus Torvalds /* Re-enable CSC interrupts */ 5931da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK); 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds return 0; 5961da177e4SLinus Torvalds } 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds static int yenta_sock_suspend(struct pcmcia_socket *sock) 5991da177e4SLinus Torvalds { 6001da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds /* Disable CSC interrupts */ 6031da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0x0); 6041da177e4SLinus Torvalds 6051da177e4SLinus Torvalds return 0; 6061da177e4SLinus Torvalds } 6071da177e4SLinus Torvalds 6081da177e4SLinus Torvalds /* 6091da177e4SLinus Torvalds * Use an adaptive allocation for the memory resource, 6101da177e4SLinus Torvalds * sometimes the memory behind pci bridges is limited: 6111da177e4SLinus Torvalds * 1/8 of the size of the io window of the parent. 612eb0a90b4SDominik Brodowski * max 4 MB, min 16 kB. We try very hard to not get below 613eb0a90b4SDominik Brodowski * the "ACC" values, though. 6141da177e4SLinus Torvalds */ 6159fea84f4SDominik Brodowski #define BRIDGE_MEM_MAX (4*1024*1024) 6169fea84f4SDominik Brodowski #define BRIDGE_MEM_ACC (128*1024) 6179fea84f4SDominik Brodowski #define BRIDGE_MEM_MIN (16*1024) 6181da177e4SLinus Torvalds 619eb0a90b4SDominik Brodowski #define BRIDGE_IO_MAX 512 620eb0a90b4SDominik Brodowski #define BRIDGE_IO_ACC 256 6211da177e4SLinus Torvalds #define BRIDGE_IO_MIN 32 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds #ifndef PCIBIOS_MIN_CARDBUS_IO 6241da177e4SLinus Torvalds #define PCIBIOS_MIN_CARDBUS_IO PCIBIOS_MIN_IO 6251da177e4SLinus Torvalds #endif 6261da177e4SLinus Torvalds 627eb0a90b4SDominik Brodowski static int yenta_search_one_res(struct resource *root, struct resource *res, 628eb0a90b4SDominik Brodowski u32 min) 629eb0a90b4SDominik Brodowski { 630eb0a90b4SDominik Brodowski u32 align, size, start, end; 631eb0a90b4SDominik Brodowski 632eb0a90b4SDominik Brodowski if (res->flags & IORESOURCE_IO) { 633eb0a90b4SDominik Brodowski align = 1024; 634eb0a90b4SDominik Brodowski size = BRIDGE_IO_MAX; 635eb0a90b4SDominik Brodowski start = PCIBIOS_MIN_CARDBUS_IO; 636eb0a90b4SDominik Brodowski end = ~0U; 637eb0a90b4SDominik Brodowski } else { 638eb0a90b4SDominik Brodowski unsigned long avail = root->end - root->start; 639eb0a90b4SDominik Brodowski int i; 640eb0a90b4SDominik Brodowski size = BRIDGE_MEM_MAX; 641eb0a90b4SDominik Brodowski if (size > avail/8) { 642eb0a90b4SDominik Brodowski size = (avail+1)/8; 643eb0a90b4SDominik Brodowski /* round size down to next power of 2 */ 644eb0a90b4SDominik Brodowski i = 0; 645eb0a90b4SDominik Brodowski while ((size /= 2) != 0) 646eb0a90b4SDominik Brodowski i++; 647eb0a90b4SDominik Brodowski size = 1 << i; 648eb0a90b4SDominik Brodowski } 649eb0a90b4SDominik Brodowski if (size < min) 650eb0a90b4SDominik Brodowski size = min; 651eb0a90b4SDominik Brodowski align = size; 652eb0a90b4SDominik Brodowski start = PCIBIOS_MIN_MEM; 653eb0a90b4SDominik Brodowski end = ~0U; 654eb0a90b4SDominik Brodowski } 655eb0a90b4SDominik Brodowski 656eb0a90b4SDominik Brodowski do { 657eb0a90b4SDominik Brodowski if (allocate_resource(root, res, size, start, end, align, 658eb0a90b4SDominik Brodowski NULL, NULL) == 0) { 659eb0a90b4SDominik Brodowski return 1; 660eb0a90b4SDominik Brodowski } 661eb0a90b4SDominik Brodowski size = size/2; 662eb0a90b4SDominik Brodowski align = size; 663eb0a90b4SDominik Brodowski } while (size >= min); 664eb0a90b4SDominik Brodowski 665eb0a90b4SDominik Brodowski return 0; 666eb0a90b4SDominik Brodowski } 667eb0a90b4SDominik Brodowski 668eb0a90b4SDominik Brodowski 669eb0a90b4SDominik Brodowski static int yenta_search_res(struct yenta_socket *socket, struct resource *res, 670eb0a90b4SDominik Brodowski u32 min) 671eb0a90b4SDominik Brodowski { 67289a74eccSBjorn Helgaas struct resource *root; 673eb0a90b4SDominik Brodowski int i; 67489a74eccSBjorn Helgaas 67589a74eccSBjorn Helgaas pci_bus_for_each_resource(socket->dev->bus, root, i) { 676eb0a90b4SDominik Brodowski if (!root) 677eb0a90b4SDominik Brodowski continue; 678eb0a90b4SDominik Brodowski 679eb0a90b4SDominik Brodowski if ((res->flags ^ root->flags) & 680eb0a90b4SDominik Brodowski (IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH)) 681eb0a90b4SDominik Brodowski continue; /* Wrong type */ 682eb0a90b4SDominik Brodowski 683eb0a90b4SDominik Brodowski if (yenta_search_one_res(root, res, min)) 684eb0a90b4SDominik Brodowski return 1; 685eb0a90b4SDominik Brodowski } 686eb0a90b4SDominik Brodowski return 0; 687eb0a90b4SDominik Brodowski } 688eb0a90b4SDominik Brodowski 689b3743fa4SDominik Brodowski static int yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned type, int addr_start, int addr_end) 6901da177e4SLinus Torvalds { 691852710d9SMatthew Wilcox struct pci_dev *dev = socket->dev; 692852710d9SMatthew Wilcox struct resource *res; 69343c34735SDominik Brodowski struct pci_bus_region region; 6941da177e4SLinus Torvalds unsigned mask; 6951da177e4SLinus Torvalds 696852710d9SMatthew Wilcox res = dev->resource + PCI_BRIDGE_RESOURCES + nr; 6977925407aSIvan Kokshaysky /* Already allocated? */ 6987925407aSIvan Kokshaysky if (res->parent) 699b3743fa4SDominik Brodowski return 0; 7007925407aSIvan Kokshaysky 7011da177e4SLinus Torvalds /* The granularity of the memory limit is 4kB, on IO it's 4 bytes */ 7021da177e4SLinus Torvalds mask = ~0xfff; 7031da177e4SLinus Torvalds if (type & IORESOURCE_IO) 7041da177e4SLinus Torvalds mask = ~3; 7051da177e4SLinus Torvalds 706852710d9SMatthew Wilcox res->name = dev->subordinate->name; 7071da177e4SLinus Torvalds res->flags = type; 7081da177e4SLinus Torvalds 70943c34735SDominik Brodowski region.start = config_readl(socket, addr_start) & mask; 71043c34735SDominik Brodowski region.end = config_readl(socket, addr_end) | ~mask; 71143c34735SDominik Brodowski if (region.start && region.end > region.start && !override_bios) { 712852710d9SMatthew Wilcox pcibios_bus_to_resource(dev, res, ®ion); 713852710d9SMatthew Wilcox if (pci_claim_resource(dev, PCI_BRIDGE_RESOURCES + nr) == 0) 714b3743fa4SDominik Brodowski return 0; 715852710d9SMatthew Wilcox dev_printk(KERN_INFO, &dev->dev, 716dd797d81SDominik Brodowski "Preassigned resource %d busy or not available, " 717dd797d81SDominik Brodowski "reconfiguring...\n", 718dd797d81SDominik Brodowski nr); 7191da177e4SLinus Torvalds } 7201da177e4SLinus Torvalds 7211da177e4SLinus Torvalds if (type & IORESOURCE_IO) { 722eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_IO_MAX)) || 723eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_IO_ACC)) || 724b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_IO_MIN))) 725b3743fa4SDominik Brodowski return 1; 726eb0a90b4SDominik Brodowski } else { 727eb0a90b4SDominik Brodowski if (type & IORESOURCE_PREFETCH) { 728eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) || 729eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) || 730b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_MIN))) 731b3743fa4SDominik Brodowski return 1; 732eb0a90b4SDominik Brodowski /* Approximating prefetchable by non-prefetchable */ 733eb0a90b4SDominik Brodowski res->flags = IORESOURCE_MEM; 734eb0a90b4SDominik Brodowski } 735eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) || 736eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) || 737b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_MIN))) 738b3743fa4SDominik Brodowski return 1; 739eb0a90b4SDominik Brodowski } 740eb0a90b4SDominik Brodowski 741852710d9SMatthew Wilcox dev_printk(KERN_INFO, &dev->dev, 742dd797d81SDominik Brodowski "no resource of type %x available, trying to continue...\n", 743dd797d81SDominik Brodowski type); 744eb0a90b4SDominik Brodowski res->start = res->end = res->flags = 0; 745b3743fa4SDominik Brodowski return 0; 7461da177e4SLinus Torvalds } 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds /* 7491da177e4SLinus Torvalds * Allocate the bridge mappings for the device.. 7501da177e4SLinus Torvalds */ 7511da177e4SLinus Torvalds static void yenta_allocate_resources(struct yenta_socket *socket) 7521da177e4SLinus Torvalds { 753b3743fa4SDominik Brodowski int program = 0; 754b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 0, IORESOURCE_IO, 75527879835SDominik Brodowski PCI_CB_IO_BASE_0, PCI_CB_IO_LIMIT_0); 756b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 1, IORESOURCE_IO, 75727879835SDominik Brodowski PCI_CB_IO_BASE_1, PCI_CB_IO_LIMIT_1); 758b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 2, IORESOURCE_MEM|IORESOURCE_PREFETCH, 75927879835SDominik Brodowski PCI_CB_MEMORY_BASE_0, PCI_CB_MEMORY_LIMIT_0); 760b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 3, IORESOURCE_MEM, 76127879835SDominik Brodowski PCI_CB_MEMORY_BASE_1, PCI_CB_MEMORY_LIMIT_1); 762b3743fa4SDominik Brodowski if (program) 763b3743fa4SDominik Brodowski pci_setup_cardbus(socket->dev->subordinate); 7641da177e4SLinus Torvalds } 7651da177e4SLinus Torvalds 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds /* 7681da177e4SLinus Torvalds * Free the bridge mappings for the device.. 7691da177e4SLinus Torvalds */ 7701da177e4SLinus Torvalds static void yenta_free_resources(struct yenta_socket *socket) 7711da177e4SLinus Torvalds { 7721da177e4SLinus Torvalds int i; 7731da177e4SLinus Torvalds for (i = 0; i < 4; i++) { 7741da177e4SLinus Torvalds struct resource *res; 7751da177e4SLinus Torvalds res = socket->dev->resource + PCI_BRIDGE_RESOURCES + i; 7761da177e4SLinus Torvalds if (res->start != 0 && res->end != 0) 7771da177e4SLinus Torvalds release_resource(res); 778b3743fa4SDominik Brodowski res->start = res->end = res->flags = 0; 7791da177e4SLinus Torvalds } 7801da177e4SLinus Torvalds } 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds 7831da177e4SLinus Torvalds /* 7841da177e4SLinus Torvalds * Close it down - release our resources and go home.. 7851da177e4SLinus Torvalds */ 786734f3fa1SMike Frysinger static void __devexit yenta_close(struct pci_dev *dev) 7871da177e4SLinus Torvalds { 7881da177e4SLinus Torvalds struct yenta_socket *sock = pci_get_drvdata(dev); 7891da177e4SLinus Torvalds 790030ee39cSLinus Torvalds /* Remove the register attributes */ 791030ee39cSLinus Torvalds device_remove_file(&dev->dev, &dev_attr_yenta_registers); 792030ee39cSLinus Torvalds 7931da177e4SLinus Torvalds /* we don't want a dying socket registered */ 7941da177e4SLinus Torvalds pcmcia_unregister_socket(&sock->socket); 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds /* Disable all events so we don't die in an IRQ storm */ 7971da177e4SLinus Torvalds cb_writel(sock, CB_SOCKET_MASK, 0x0); 7981da177e4SLinus Torvalds exca_writeb(sock, I365_CSCINT, 0); 7991da177e4SLinus Torvalds 8001da177e4SLinus Torvalds if (sock->cb_irq) 8011da177e4SLinus Torvalds free_irq(sock->cb_irq, sock); 8021da177e4SLinus Torvalds else 8031da177e4SLinus Torvalds del_timer_sync(&sock->poll_timer); 8041da177e4SLinus Torvalds 8051da177e4SLinus Torvalds if (sock->base) 8061da177e4SLinus Torvalds iounmap(sock->base); 8071da177e4SLinus Torvalds yenta_free_resources(sock); 8081da177e4SLinus Torvalds 8091da177e4SLinus Torvalds pci_release_regions(dev); 8101da177e4SLinus Torvalds pci_disable_device(dev); 8111da177e4SLinus Torvalds pci_set_drvdata(dev, NULL); 8121da177e4SLinus Torvalds } 8131da177e4SLinus Torvalds 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds static struct pccard_operations yenta_socket_operations = { 8161da177e4SLinus Torvalds .init = yenta_sock_init, 8171da177e4SLinus Torvalds .suspend = yenta_sock_suspend, 8181da177e4SLinus Torvalds .get_status = yenta_get_status, 8191da177e4SLinus Torvalds .set_socket = yenta_set_socket, 8201da177e4SLinus Torvalds .set_io_map = yenta_set_io_map, 8211da177e4SLinus Torvalds .set_mem_map = yenta_set_mem_map, 8221da177e4SLinus Torvalds }; 8231da177e4SLinus Torvalds 8241da177e4SLinus Torvalds 82563e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 8261da177e4SLinus Torvalds #include "ti113x.h" 82763e7ebd0SDaniel Ritz #endif 82863e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 8291da177e4SLinus Torvalds #include "ricoh.h" 83063e7ebd0SDaniel Ritz #endif 83163e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 8321da177e4SLinus Torvalds #include "topic.h" 83363e7ebd0SDaniel Ritz #endif 83463e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 8351da177e4SLinus Torvalds #include "o2micro.h" 83663e7ebd0SDaniel Ritz #endif 8371da177e4SLinus Torvalds 8381da177e4SLinus Torvalds enum { 8391da177e4SLinus Torvalds CARDBUS_TYPE_DEFAULT = -1, 8401da177e4SLinus Torvalds CARDBUS_TYPE_TI, 8411da177e4SLinus Torvalds CARDBUS_TYPE_TI113X, 8421da177e4SLinus Torvalds CARDBUS_TYPE_TI12XX, 8431da177e4SLinus Torvalds CARDBUS_TYPE_TI1250, 8441da177e4SLinus Torvalds CARDBUS_TYPE_RICOH, 845ea2f1590SDaniel Ritz CARDBUS_TYPE_TOPIC95, 8461da177e4SLinus Torvalds CARDBUS_TYPE_TOPIC97, 8471da177e4SLinus Torvalds CARDBUS_TYPE_O2MICRO, 8488c3520d4SDaniel Ritz CARDBUS_TYPE_ENE, 8491da177e4SLinus Torvalds }; 8501da177e4SLinus Torvalds 8511da177e4SLinus Torvalds /* 8521da177e4SLinus Torvalds * Different cardbus controllers have slightly different 8531da177e4SLinus Torvalds * initialization sequences etc details. List them here.. 8541da177e4SLinus Torvalds */ 8551da177e4SLinus Torvalds static struct cardbus_type cardbus_type[] = { 85663e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 8571da177e4SLinus Torvalds [CARDBUS_TYPE_TI] = { 8581da177e4SLinus Torvalds .override = ti_override, 8591da177e4SLinus Torvalds .save_state = ti_save_state, 8601da177e4SLinus Torvalds .restore_state = ti_restore_state, 8611da177e4SLinus Torvalds .sock_init = ti_init, 8621da177e4SLinus Torvalds }, 8631da177e4SLinus Torvalds [CARDBUS_TYPE_TI113X] = { 8641da177e4SLinus Torvalds .override = ti113x_override, 8651da177e4SLinus Torvalds .save_state = ti_save_state, 8661da177e4SLinus Torvalds .restore_state = ti_restore_state, 8671da177e4SLinus Torvalds .sock_init = ti_init, 8681da177e4SLinus Torvalds }, 8691da177e4SLinus Torvalds [CARDBUS_TYPE_TI12XX] = { 8701da177e4SLinus Torvalds .override = ti12xx_override, 8711da177e4SLinus Torvalds .save_state = ti_save_state, 8721da177e4SLinus Torvalds .restore_state = ti_restore_state, 8731da177e4SLinus Torvalds .sock_init = ti_init, 8741da177e4SLinus Torvalds }, 8751da177e4SLinus Torvalds [CARDBUS_TYPE_TI1250] = { 8761da177e4SLinus Torvalds .override = ti1250_override, 8771da177e4SLinus Torvalds .save_state = ti_save_state, 8781da177e4SLinus Torvalds .restore_state = ti_restore_state, 8791da177e4SLinus Torvalds .sock_init = ti_init, 8801da177e4SLinus Torvalds }, 8814f2d364bSJustin P. Mattock [CARDBUS_TYPE_ENE] = { 8824f2d364bSJustin P. Mattock .override = ene_override, 8834f2d364bSJustin P. Mattock .save_state = ti_save_state, 8844f2d364bSJustin P. Mattock .restore_state = ti_restore_state, 8854f2d364bSJustin P. Mattock .sock_init = ti_init, 8864f2d364bSJustin P. Mattock }, 88763e7ebd0SDaniel Ritz #endif 88863e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 8891da177e4SLinus Torvalds [CARDBUS_TYPE_RICOH] = { 8901da177e4SLinus Torvalds .override = ricoh_override, 8911da177e4SLinus Torvalds .save_state = ricoh_save_state, 8921da177e4SLinus Torvalds .restore_state = ricoh_restore_state, 8931da177e4SLinus Torvalds }, 89463e7ebd0SDaniel Ritz #endif 89563e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 896ea2f1590SDaniel Ritz [CARDBUS_TYPE_TOPIC95] = { 897ea2f1590SDaniel Ritz .override = topic95_override, 898ea2f1590SDaniel Ritz }, 8991da177e4SLinus Torvalds [CARDBUS_TYPE_TOPIC97] = { 9001da177e4SLinus Torvalds .override = topic97_override, 9011da177e4SLinus Torvalds }, 90263e7ebd0SDaniel Ritz #endif 90363e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 9041da177e4SLinus Torvalds [CARDBUS_TYPE_O2MICRO] = { 9051da177e4SLinus Torvalds .override = o2micro_override, 9061da177e4SLinus Torvalds .restore_state = o2micro_restore_state, 9071da177e4SLinus Torvalds }, 90863e7ebd0SDaniel Ritz #endif 9091da177e4SLinus Torvalds }; 9101da177e4SLinus Torvalds 9111da177e4SLinus Torvalds 9121da177e4SLinus Torvalds static unsigned int yenta_probe_irq(struct yenta_socket *socket, u32 isa_irq_mask) 9131da177e4SLinus Torvalds { 9141da177e4SLinus Torvalds int i; 9151da177e4SLinus Torvalds unsigned long val; 9161da177e4SLinus Torvalds u32 mask; 91728ca8dd7SJens Künzer u8 reg; 9181da177e4SLinus Torvalds 9191da177e4SLinus Torvalds /* 9201da177e4SLinus Torvalds * Probe for usable interrupts using the force 9211da177e4SLinus Torvalds * register to generate bogus card status events. 9221da177e4SLinus Torvalds */ 9231da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9241da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK); 92528ca8dd7SJens Künzer reg = exca_readb(socket, I365_CSCINT); 9261da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 9271da177e4SLinus Torvalds val = probe_irq_on() & isa_irq_mask; 9281da177e4SLinus Torvalds for (i = 1; i < 16; i++) { 9291da177e4SLinus Torvalds if (!((val >> i) & 1)) 9301da177e4SLinus Torvalds continue; 9311da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG | (i << 4)); 9321da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS); 9331da177e4SLinus Torvalds udelay(100); 9341da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9351da177e4SLinus Torvalds } 9361da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0); 93728ca8dd7SJens Künzer exca_writeb(socket, I365_CSCINT, reg); 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds mask = probe_irq_mask(val) & 0xffff; 9401da177e4SLinus Torvalds 9411da177e4SLinus Torvalds return mask; 9421da177e4SLinus Torvalds } 9431da177e4SLinus Torvalds 9441da177e4SLinus Torvalds 94578187865SRandy Dunlap /* 94663e7ebd0SDaniel Ritz * yenta PCI irq probing. 94763e7ebd0SDaniel Ritz * currently only used in the TI/EnE initialization code 94863e7ebd0SDaniel Ritz */ 94963e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 95063e7ebd0SDaniel Ritz 9511da177e4SLinus Torvalds /* interrupt handler, only used during probing */ 9527d12e780SDavid Howells static irqreturn_t yenta_probe_handler(int irq, void *dev_id) 9531da177e4SLinus Torvalds { 9541da177e4SLinus Torvalds struct yenta_socket *socket = (struct yenta_socket *) dev_id; 9551da177e4SLinus Torvalds u8 csc; 9561da177e4SLinus Torvalds u32 cb_event; 9571da177e4SLinus Torvalds 9581da177e4SLinus Torvalds /* Clear interrupt status for the event */ 9591da177e4SLinus Torvalds cb_event = cb_readl(socket, CB_SOCKET_EVENT); 9601da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9611da177e4SLinus Torvalds csc = exca_readb(socket, I365_CSC); 9621da177e4SLinus Torvalds 9631da177e4SLinus Torvalds if (cb_event || csc) { 9641da177e4SLinus Torvalds socket->probe_status = 1; 9651da177e4SLinus Torvalds return IRQ_HANDLED; 9661da177e4SLinus Torvalds } 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds return IRQ_NONE; 9691da177e4SLinus Torvalds } 9701da177e4SLinus Torvalds 9711da177e4SLinus Torvalds /* probes the PCI interrupt, use only on override functions */ 9721da177e4SLinus Torvalds static int yenta_probe_cb_irq(struct yenta_socket *socket) 9731da177e4SLinus Torvalds { 97402caa56eSDominik Brodowski u8 reg = 0; 97528ca8dd7SJens Künzer 9761da177e4SLinus Torvalds if (!socket->cb_irq) 9771da177e4SLinus Torvalds return -1; 9781da177e4SLinus Torvalds 9791da177e4SLinus Torvalds socket->probe_status = 0; 9801da177e4SLinus Torvalds 981dace1453SThomas Gleixner if (request_irq(socket->cb_irq, yenta_probe_handler, IRQF_SHARED, "yenta", socket)) { 982dd797d81SDominik Brodowski dev_printk(KERN_WARNING, &socket->dev->dev, 983dd797d81SDominik Brodowski "request_irq() in yenta_probe_cb_irq() failed!\n"); 9841da177e4SLinus Torvalds return -1; 9851da177e4SLinus Torvalds } 9861da177e4SLinus Torvalds 9871da177e4SLinus Torvalds /* generate interrupt, wait */ 98802caa56eSDominik Brodowski if (!socket->dev->irq) 98928ca8dd7SJens Künzer reg = exca_readb(socket, I365_CSCINT); 99028ca8dd7SJens Künzer exca_writeb(socket, I365_CSCINT, reg | I365_CSC_STSCHG); 9911da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9921da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK); 9931da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS); 9941da177e4SLinus Torvalds 9951da177e4SLinus Torvalds msleep(100); 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds /* disable interrupts */ 9981da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0); 99928ca8dd7SJens Künzer exca_writeb(socket, I365_CSCINT, reg); 10001da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 10011da177e4SLinus Torvalds exca_readb(socket, I365_CSC); 10021da177e4SLinus Torvalds 10031da177e4SLinus Torvalds free_irq(socket->cb_irq, socket); 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvalds return (int) socket->probe_status; 10061da177e4SLinus Torvalds } 10071da177e4SLinus Torvalds 100863e7ebd0SDaniel Ritz #endif /* CONFIG_YENTA_TI */ 10091da177e4SLinus Torvalds 10101da177e4SLinus Torvalds 10111da177e4SLinus Torvalds /* 10121da177e4SLinus Torvalds * Set static data that doesn't need re-initializing.. 10131da177e4SLinus Torvalds */ 10141da177e4SLinus Torvalds static void yenta_get_socket_capabilities(struct yenta_socket *socket, u32 isa_irq_mask) 10151da177e4SLinus Torvalds { 10161da177e4SLinus Torvalds socket->socket.pci_irq = socket->cb_irq; 1017fa912bcbSDaniel Ritz if (isa_probe) 10181da177e4SLinus Torvalds socket->socket.irq_mask = yenta_probe_irq(socket, isa_irq_mask); 1019fa912bcbSDaniel Ritz else 1020fa912bcbSDaniel Ritz socket->socket.irq_mask = 0; 10211da177e4SLinus Torvalds 1022dd797d81SDominik Brodowski dev_printk(KERN_INFO, &socket->dev->dev, 1023dd797d81SDominik Brodowski "ISA IRQ mask 0x%04x, PCI irq %d\n", 10241da177e4SLinus Torvalds socket->socket.irq_mask, socket->cb_irq); 10251da177e4SLinus Torvalds } 10261da177e4SLinus Torvalds 10271da177e4SLinus Torvalds /* 10281da177e4SLinus Torvalds * Initialize the standard cardbus registers 10291da177e4SLinus Torvalds */ 10301da177e4SLinus Torvalds static void yenta_config_init(struct yenta_socket *socket) 10311da177e4SLinus Torvalds { 10321da177e4SLinus Torvalds u16 bridge; 10331da177e4SLinus Torvalds struct pci_dev *dev = socket->dev; 10348e5d17ebSDominik Brodowski struct pci_bus_region region; 10351da177e4SLinus Torvalds 10368e5d17ebSDominik Brodowski pcibios_resource_to_bus(socket->dev, ®ion, &dev->resource[0]); 10371da177e4SLinus Torvalds 10381da177e4SLinus Torvalds config_writel(socket, CB_LEGACY_MODE_BASE, 0); 10398e5d17ebSDominik Brodowski config_writel(socket, PCI_BASE_ADDRESS_0, region.start); 10401da177e4SLinus Torvalds config_writew(socket, PCI_COMMAND, 10411da177e4SLinus Torvalds PCI_COMMAND_IO | 10421da177e4SLinus Torvalds PCI_COMMAND_MEMORY | 10431da177e4SLinus Torvalds PCI_COMMAND_MASTER | 10441da177e4SLinus Torvalds PCI_COMMAND_WAIT); 10451da177e4SLinus Torvalds 10461da177e4SLinus Torvalds /* MAGIC NUMBERS! Fixme */ 10471da177e4SLinus Torvalds config_writeb(socket, PCI_CACHE_LINE_SIZE, L1_CACHE_BYTES / 4); 10481da177e4SLinus Torvalds config_writeb(socket, PCI_LATENCY_TIMER, 168); 10491da177e4SLinus Torvalds config_writel(socket, PCI_PRIMARY_BUS, 10501da177e4SLinus Torvalds (176 << 24) | /* sec. latency timer */ 1051b918c62eSYinghai Lu ((unsigned int)dev->subordinate->busn_res.end << 16) | /* subordinate bus */ 1052b918c62eSYinghai Lu ((unsigned int)dev->subordinate->busn_res.start << 8) | /* secondary bus */ 10531da177e4SLinus Torvalds dev->subordinate->primary); /* primary bus */ 10541da177e4SLinus Torvalds 10551da177e4SLinus Torvalds /* 10561da177e4SLinus Torvalds * Set up the bridging state: 10571da177e4SLinus Torvalds * - enable write posting. 10581da177e4SLinus Torvalds * - memory window 0 prefetchable, window 1 non-prefetchable 10591da177e4SLinus Torvalds * - PCI interrupts enabled if a PCI interrupt exists.. 10601da177e4SLinus Torvalds */ 10611da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL); 1062a413c090SDaniel Ritz bridge &= ~(CB_BRIDGE_CRST | CB_BRIDGE_PREFETCH1 | CB_BRIDGE_ISAEN | CB_BRIDGE_VGAEN); 1063a413c090SDaniel Ritz bridge |= CB_BRIDGE_PREFETCH0 | CB_BRIDGE_POSTEN; 10641da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 10651da177e4SLinus Torvalds } 10661da177e4SLinus Torvalds 1067b435261bSBernhard Kaindl /** 106866005216SRandy Dunlap * yenta_fixup_parent_bridge - Fix subordinate bus# of the parent bridge 1069b435261bSBernhard Kaindl * @cardbus_bridge: The PCI bus which the CardBus bridge bridges to 1070b435261bSBernhard Kaindl * 1071b435261bSBernhard Kaindl * Checks if devices on the bus which the CardBus bridge bridges to would be 1072b435261bSBernhard Kaindl * invisible during PCI scans because of a misconfigured subordinate number 1073b435261bSBernhard Kaindl * of the parent brige - some BIOSes seem to be too lazy to set it right. 1074b435261bSBernhard Kaindl * Does the fixup carefully by checking how far it can go without conflicts. 1075631dd1a8SJustin P. Mattock * See http://bugzilla.kernel.org/show_bug.cgi?id=2944 for more information. 1076b435261bSBernhard Kaindl */ 1077b435261bSBernhard Kaindl static void yenta_fixup_parent_bridge(struct pci_bus *cardbus_bridge) 1078b435261bSBernhard Kaindl { 1079b435261bSBernhard Kaindl struct list_head *tmp; 1080b435261bSBernhard Kaindl unsigned char upper_limit; 1081b435261bSBernhard Kaindl /* 1082b435261bSBernhard Kaindl * We only check and fix the parent bridge: All systems which need 1083b435261bSBernhard Kaindl * this fixup that have been reviewed are laptops and the only bridge 1084b435261bSBernhard Kaindl * which needed fixing was the parent bridge of the CardBus bridge: 1085b435261bSBernhard Kaindl */ 1086b435261bSBernhard Kaindl struct pci_bus *bridge_to_fix = cardbus_bridge->parent; 1087b435261bSBernhard Kaindl 1088b435261bSBernhard Kaindl /* Check bus numbers are already set up correctly: */ 1089b918c62eSYinghai Lu if (bridge_to_fix->busn_res.end >= cardbus_bridge->busn_res.end) 1090b435261bSBernhard Kaindl return; /* The subordinate number is ok, nothing to do */ 1091b435261bSBernhard Kaindl 1092b435261bSBernhard Kaindl if (!bridge_to_fix->parent) 1093b435261bSBernhard Kaindl return; /* Root bridges are ok */ 1094b435261bSBernhard Kaindl 1095b435261bSBernhard Kaindl /* stay within the limits of the bus range of the parent: */ 1096b918c62eSYinghai Lu upper_limit = bridge_to_fix->parent->busn_res.end; 1097b435261bSBernhard Kaindl 1098b435261bSBernhard Kaindl /* check the bus ranges of all silbling bridges to prevent overlap */ 1099b435261bSBernhard Kaindl list_for_each(tmp, &bridge_to_fix->parent->children) { 1100b435261bSBernhard Kaindl struct pci_bus *silbling = pci_bus_b(tmp); 1101b435261bSBernhard Kaindl /* 1102b435261bSBernhard Kaindl * If the silbling has a higher secondary bus number 1103b435261bSBernhard Kaindl * and it's secondary is equal or smaller than our 1104b435261bSBernhard Kaindl * current upper limit, set the new upper limit to 1105b435261bSBernhard Kaindl * the bus number below the silbling's range: 1106b435261bSBernhard Kaindl */ 1107b918c62eSYinghai Lu if (silbling->busn_res.start > bridge_to_fix->busn_res.end 1108b918c62eSYinghai Lu && silbling->busn_res.start <= upper_limit) 1109b918c62eSYinghai Lu upper_limit = silbling->busn_res.start - 1; 1110b435261bSBernhard Kaindl } 1111b435261bSBernhard Kaindl 1112b435261bSBernhard Kaindl /* Show that the wanted subordinate number is not possible: */ 1113b918c62eSYinghai Lu if (cardbus_bridge->busn_res.end > upper_limit) 1114dd797d81SDominik Brodowski dev_printk(KERN_WARNING, &cardbus_bridge->dev, 1115dd797d81SDominik Brodowski "Upper limit for fixing this " 1116b435261bSBernhard Kaindl "bridge's parent bridge: #%02x\n", upper_limit); 1117b435261bSBernhard Kaindl 1118b435261bSBernhard Kaindl /* If we have room to increase the bridge's subordinate number, */ 1119b918c62eSYinghai Lu if (bridge_to_fix->busn_res.end < upper_limit) { 1120b435261bSBernhard Kaindl 1121b435261bSBernhard Kaindl /* use the highest number of the hidden bus, within limits */ 1122b435261bSBernhard Kaindl unsigned char subordinate_to_assign = 1123b918c62eSYinghai Lu min_t(int, cardbus_bridge->busn_res.end, upper_limit); 1124b435261bSBernhard Kaindl 1125dd797d81SDominik Brodowski dev_printk(KERN_INFO, &bridge_to_fix->dev, 1126dd797d81SDominik Brodowski "Raising subordinate bus# of parent " 1127b435261bSBernhard Kaindl "bus (#%02x) from #%02x to #%02x\n", 1128b435261bSBernhard Kaindl bridge_to_fix->number, 1129b918c62eSYinghai Lu (int)bridge_to_fix->busn_res.end, subordinate_to_assign); 1130b435261bSBernhard Kaindl 1131b435261bSBernhard Kaindl /* Save the new subordinate in the bus struct of the bridge */ 1132b918c62eSYinghai Lu bridge_to_fix->busn_res.end = subordinate_to_assign; 1133b435261bSBernhard Kaindl 1134b435261bSBernhard Kaindl /* and update the PCI config space with the new subordinate */ 1135b435261bSBernhard Kaindl pci_write_config_byte(bridge_to_fix->self, 1136b918c62eSYinghai Lu PCI_SUBORDINATE_BUS, bridge_to_fix->busn_res.end); 1137b435261bSBernhard Kaindl } 1138b435261bSBernhard Kaindl } 1139b435261bSBernhard Kaindl 11401da177e4SLinus Torvalds /* 11411da177e4SLinus Torvalds * Initialize a cardbus controller. Make sure we have a usable 11421da177e4SLinus Torvalds * interrupt, and that we can map the cardbus area. Fill in the 11431da177e4SLinus Torvalds * socket information structure.. 11441da177e4SLinus Torvalds */ 11451da177e4SLinus Torvalds static int __devinit yenta_probe(struct pci_dev *dev, const struct pci_device_id *id) 11461da177e4SLinus Torvalds { 11471da177e4SLinus Torvalds struct yenta_socket *socket; 11481da177e4SLinus Torvalds int ret; 11491da177e4SLinus Torvalds 1150c7fb0b35SIvan Kokshaysky /* 1151c7fb0b35SIvan Kokshaysky * If we failed to assign proper bus numbers for this cardbus 1152c7fb0b35SIvan Kokshaysky * controller during PCI probe, its subordinate pci_bus is NULL. 1153c7fb0b35SIvan Kokshaysky * Bail out if so. 1154c7fb0b35SIvan Kokshaysky */ 1155c7fb0b35SIvan Kokshaysky if (!dev->subordinate) { 1156dd797d81SDominik Brodowski dev_printk(KERN_ERR, &dev->dev, "no bus associated! " 1157dd797d81SDominik Brodowski "(try 'pci=assign-busses')\n"); 1158c7fb0b35SIvan Kokshaysky return -ENODEV; 1159c7fb0b35SIvan Kokshaysky } 1160c7fb0b35SIvan Kokshaysky 11618084b372SDominik Brodowski socket = kzalloc(sizeof(struct yenta_socket), GFP_KERNEL); 11621da177e4SLinus Torvalds if (!socket) 11631da177e4SLinus Torvalds return -ENOMEM; 11641da177e4SLinus Torvalds 11651da177e4SLinus Torvalds /* prepare pcmcia_socket */ 11661da177e4SLinus Torvalds socket->socket.ops = ¥ta_socket_operations; 11671da177e4SLinus Torvalds socket->socket.resource_ops = &pccard_nonstatic_ops; 116887373318SGreg Kroah-Hartman socket->socket.dev.parent = &dev->dev; 11691da177e4SLinus Torvalds socket->socket.driver_data = socket; 11701da177e4SLinus Torvalds socket->socket.owner = THIS_MODULE; 11715bc6b68aSRussell King socket->socket.features = SS_CAP_PAGE_REGS | SS_CAP_PCCARD; 11725bc6b68aSRussell King socket->socket.map_size = 0x1000; 11735bc6b68aSRussell King socket->socket.cb_dev = dev; 11741da177e4SLinus Torvalds 11751da177e4SLinus Torvalds /* prepare struct yenta_socket */ 11761da177e4SLinus Torvalds socket->dev = dev; 11771da177e4SLinus Torvalds pci_set_drvdata(dev, socket); 11781da177e4SLinus Torvalds 11791da177e4SLinus Torvalds /* 11801da177e4SLinus Torvalds * Do some basic sanity checking.. 11811da177e4SLinus Torvalds */ 11821da177e4SLinus Torvalds if (pci_enable_device(dev)) { 11831da177e4SLinus Torvalds ret = -EBUSY; 11841da177e4SLinus Torvalds goto free; 11851da177e4SLinus Torvalds } 11861da177e4SLinus Torvalds 11871da177e4SLinus Torvalds ret = pci_request_regions(dev, "yenta_socket"); 11881da177e4SLinus Torvalds if (ret) 11891da177e4SLinus Torvalds goto disable; 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds if (!pci_resource_start(dev, 0)) { 1192dd797d81SDominik Brodowski dev_printk(KERN_ERR, &dev->dev, "No cardbus resource!\n"); 11931da177e4SLinus Torvalds ret = -ENODEV; 11941da177e4SLinus Torvalds goto release; 11951da177e4SLinus Torvalds } 11961da177e4SLinus Torvalds 11971da177e4SLinus Torvalds /* 11981da177e4SLinus Torvalds * Ok, start setup.. Map the cardbus registers, 11991da177e4SLinus Torvalds * and request the IRQ. 12001da177e4SLinus Torvalds */ 12011da177e4SLinus Torvalds socket->base = ioremap(pci_resource_start(dev, 0), 0x1000); 12021da177e4SLinus Torvalds if (!socket->base) { 12031da177e4SLinus Torvalds ret = -ENOMEM; 12041da177e4SLinus Torvalds goto release; 12051da177e4SLinus Torvalds } 12061da177e4SLinus Torvalds 12071da177e4SLinus Torvalds /* 12081da177e4SLinus Torvalds * report the subsystem vendor and device for help debugging 12091da177e4SLinus Torvalds * the irq stuff... 12101da177e4SLinus Torvalds */ 1211dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, "CardBus bridge found [%04x:%04x]\n", 1212dd797d81SDominik Brodowski dev->subsystem_vendor, dev->subsystem_device); 12131da177e4SLinus Torvalds 12141da177e4SLinus Torvalds yenta_config_init(socket); 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds /* Disable all events */ 12171da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0x0); 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds /* Set up the bridge regions.. */ 12201da177e4SLinus Torvalds yenta_allocate_resources(socket); 12211da177e4SLinus Torvalds 12221da177e4SLinus Torvalds socket->cb_irq = dev->irq; 12231da177e4SLinus Torvalds 12241da177e4SLinus Torvalds /* Do we have special options for the device? */ 12251da177e4SLinus Torvalds if (id->driver_data != CARDBUS_TYPE_DEFAULT && 12261da177e4SLinus Torvalds id->driver_data < ARRAY_SIZE(cardbus_type)) { 12271da177e4SLinus Torvalds socket->type = &cardbus_type[id->driver_data]; 12281da177e4SLinus Torvalds 12291da177e4SLinus Torvalds ret = socket->type->override(socket); 12301da177e4SLinus Torvalds if (ret < 0) 12311da177e4SLinus Torvalds goto unmap; 12321da177e4SLinus Torvalds } 12331da177e4SLinus Torvalds 12341da177e4SLinus Torvalds /* We must finish initialization here */ 12351da177e4SLinus Torvalds 1236dace1453SThomas Gleixner if (!socket->cb_irq || request_irq(socket->cb_irq, yenta_interrupt, IRQF_SHARED, "yenta", socket)) { 12371da177e4SLinus Torvalds /* No IRQ or request_irq failed. Poll */ 12381da177e4SLinus Torvalds socket->cb_irq = 0; /* But zero is a valid IRQ number. */ 12391da177e4SLinus Torvalds init_timer(&socket->poll_timer); 12401da177e4SLinus Torvalds socket->poll_timer.function = yenta_interrupt_wrapper; 12411da177e4SLinus Torvalds socket->poll_timer.data = (unsigned long)socket; 12421da177e4SLinus Torvalds socket->poll_timer.expires = jiffies + HZ; 12431da177e4SLinus Torvalds add_timer(&socket->poll_timer); 1244dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1245dd797d81SDominik Brodowski "no PCI IRQ, CardBus support disabled for this " 1246dd797d81SDominik Brodowski "socket.\n"); 1247dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1248dd797d81SDominik Brodowski "check your BIOS CardBus, BIOS IRQ or ACPI " 1249dd797d81SDominik Brodowski "settings.\n"); 12505bc6b68aSRussell King } else { 12515bc6b68aSRussell King socket->socket.features |= SS_CAP_CARDBUS; 12521da177e4SLinus Torvalds } 12531da177e4SLinus Torvalds 12541da177e4SLinus Torvalds /* Figure out what the dang thing can do for the PCMCIA layer... */ 1255fa912bcbSDaniel Ritz yenta_interrogate(socket); 12561da177e4SLinus Torvalds yenta_get_socket_capabilities(socket, isa_interrupts); 1257dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1258dd797d81SDominik Brodowski "Socket status: %08x\n", cb_readl(socket, CB_SOCKET_STATE)); 12591da177e4SLinus Torvalds 1260b435261bSBernhard Kaindl yenta_fixup_parent_bridge(dev->subordinate); 1261b435261bSBernhard Kaindl 12621da177e4SLinus Torvalds /* Register it with the pcmcia layer.. */ 12631da177e4SLinus Torvalds ret = pcmcia_register_socket(&socket->socket); 1264030ee39cSLinus Torvalds if (ret == 0) { 1265030ee39cSLinus Torvalds /* Add the yenta register attributes */ 12664deb7c1eSJeff Garzik ret = device_create_file(&dev->dev, &dev_attr_yenta_registers); 12674deb7c1eSJeff Garzik if (ret == 0) 12681da177e4SLinus Torvalds goto out; 12694deb7c1eSJeff Garzik 12704deb7c1eSJeff Garzik /* error path... */ 12714deb7c1eSJeff Garzik pcmcia_unregister_socket(&socket->socket); 1272030ee39cSLinus Torvalds } 12731da177e4SLinus Torvalds 12741da177e4SLinus Torvalds unmap: 12751da177e4SLinus Torvalds iounmap(socket->base); 12761da177e4SLinus Torvalds release: 12771da177e4SLinus Torvalds pci_release_regions(dev); 12781da177e4SLinus Torvalds disable: 12791da177e4SLinus Torvalds pci_disable_device(dev); 12801da177e4SLinus Torvalds free: 12811da177e4SLinus Torvalds kfree(socket); 12821da177e4SLinus Torvalds out: 12831da177e4SLinus Torvalds return ret; 12841da177e4SLinus Torvalds } 12851da177e4SLinus Torvalds 1286f237de58SAlexey Dobriyan #ifdef CONFIG_PM 12870c570cdeSRafael J. Wysocki static int yenta_dev_suspend_noirq(struct device *dev) 12881da177e4SLinus Torvalds { 12890c570cdeSRafael J. Wysocki struct pci_dev *pdev = to_pci_dev(dev); 12900c570cdeSRafael J. Wysocki struct yenta_socket *socket = pci_get_drvdata(pdev); 12911da177e4SLinus Torvalds 12920c570cdeSRafael J. Wysocki if (!socket) 1293d7646f76SDominik Brodowski return 0; 12940c570cdeSRafael J. Wysocki 12951da177e4SLinus Torvalds if (socket->type && socket->type->save_state) 12961da177e4SLinus Torvalds socket->type->save_state(socket); 12971da177e4SLinus Torvalds 12980c570cdeSRafael J. Wysocki pci_save_state(pdev); 12990c570cdeSRafael J. Wysocki pci_read_config_dword(pdev, 16*4, &socket->saved_state[0]); 13000c570cdeSRafael J. Wysocki pci_read_config_dword(pdev, 17*4, &socket->saved_state[1]); 13010c570cdeSRafael J. Wysocki pci_disable_device(pdev); 13021da177e4SLinus Torvalds 1303d7646f76SDominik Brodowski return 0; 13041da177e4SLinus Torvalds } 13051da177e4SLinus Torvalds 13060c570cdeSRafael J. Wysocki static int yenta_dev_resume_noirq(struct device *dev) 13071da177e4SLinus Torvalds { 13080c570cdeSRafael J. Wysocki struct pci_dev *pdev = to_pci_dev(dev); 13090c570cdeSRafael J. Wysocki struct yenta_socket *socket = pci_get_drvdata(pdev); 13100c570cdeSRafael J. Wysocki int ret; 13111da177e4SLinus Torvalds 13120c570cdeSRafael J. Wysocki if (!socket) 13130c570cdeSRafael J. Wysocki return 0; 13144deb7c1eSJeff Garzik 13150c570cdeSRafael J. Wysocki pci_write_config_dword(pdev, 16*4, socket->saved_state[0]); 13160c570cdeSRafael J. Wysocki pci_write_config_dword(pdev, 17*4, socket->saved_state[1]); 13174deb7c1eSJeff Garzik 13180c570cdeSRafael J. Wysocki ret = pci_enable_device(pdev); 13190c570cdeSRafael J. Wysocki if (ret) 13200c570cdeSRafael J. Wysocki return ret; 13214deb7c1eSJeff Garzik 13220c570cdeSRafael J. Wysocki pci_set_master(pdev); 13231da177e4SLinus Torvalds 13241da177e4SLinus Torvalds if (socket->type && socket->type->restore_state) 13251da177e4SLinus Torvalds socket->type->restore_state(socket); 13260c570cdeSRafael J. Wysocki 13279905d1b4SRafael J. Wysocki return 0; 13281da177e4SLinus Torvalds } 13291da177e4SLinus Torvalds 133047145210SAlexey Dobriyan static const struct dev_pm_ops yenta_pm_ops = { 13310c570cdeSRafael J. Wysocki .suspend_noirq = yenta_dev_suspend_noirq, 13320c570cdeSRafael J. Wysocki .resume_noirq = yenta_dev_resume_noirq, 13330c570cdeSRafael J. Wysocki .freeze_noirq = yenta_dev_suspend_noirq, 13340c570cdeSRafael J. Wysocki .thaw_noirq = yenta_dev_resume_noirq, 13350c570cdeSRafael J. Wysocki .poweroff_noirq = yenta_dev_suspend_noirq, 13360c570cdeSRafael J. Wysocki .restore_noirq = yenta_dev_resume_noirq, 13370c570cdeSRafael J. Wysocki }; 13380c570cdeSRafael J. Wysocki 13390c570cdeSRafael J. Wysocki #define YENTA_PM_OPS (¥ta_pm_ops) 13400c570cdeSRafael J. Wysocki #else 13410c570cdeSRafael J. Wysocki #define YENTA_PM_OPS NULL 1342f237de58SAlexey Dobriyan #endif 13431da177e4SLinus Torvalds 13441da177e4SLinus Torvalds #define CB_ID(vend, dev, type) \ 13451da177e4SLinus Torvalds { \ 13461da177e4SLinus Torvalds .vendor = vend, \ 13471da177e4SLinus Torvalds .device = dev, \ 13481da177e4SLinus Torvalds .subvendor = PCI_ANY_ID, \ 13491da177e4SLinus Torvalds .subdevice = PCI_ANY_ID, \ 13501da177e4SLinus Torvalds .class = PCI_CLASS_BRIDGE_CARDBUS << 8, \ 13511da177e4SLinus Torvalds .class_mask = ~0, \ 13521da177e4SLinus Torvalds .driver_data = CARDBUS_TYPE_##type, \ 13531da177e4SLinus Torvalds } 13541da177e4SLinus Torvalds 13552b2c5d8cSAxel Lin static DEFINE_PCI_DEVICE_TABLE(yenta_table) = { 13561da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1031, TI), 13571da177e4SLinus Torvalds 13581da177e4SLinus Torvalds /* 13591da177e4SLinus Torvalds * TBD: Check if these TI variants can use more 13601da177e4SLinus Torvalds * advanced overrides instead. (I can't get the 13611da177e4SLinus Torvalds * data sheets for these devices. --rmk) 13621da177e4SLinus Torvalds */ 136363e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 13641da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1210, TI), 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1130, TI113X), 13671da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1131, TI113X), 13681da177e4SLinus Torvalds 13691da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1211, TI12XX), 13701da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1220, TI12XX), 13711da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1221, TI12XX), 13721da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1225, TI12XX), 13731da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251A, TI12XX), 13741da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251B, TI12XX), 13751da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1420, TI12XX), 13761da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1450, TI12XX), 13771da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1451A, TI12XX), 13781da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1510, TI12XX), 13791da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1520, TI12XX), 13801da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1620, TI12XX), 13811da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4410, TI12XX), 13821da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4450, TI12XX), 13831da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4451, TI12XX), 13841da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4510, TI12XX), 13851da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4520, TI12XX), 13861da177e4SLinus Torvalds 13871da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1250, TI1250), 13881da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1410, TI1250), 13891da177e4SLinus Torvalds 13906c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11, TI12XX), 13916c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X515, TI12XX), 139259e35ba1SAlex Williamson CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12, TI12XX), 13936c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X420, TI12XX), 13946c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X620, TI12XX), 13956c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7410, TI12XX), 13966c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7510, TI12XX), 13976c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7610, TI12XX), 13986c1a10dbSDaniel Ritz 1399f3d4ae43SMichal Pecio CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_710, ENE), 1400f3d4ae43SMichal Pecio CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_712, ENE), 1401f3d4ae43SMichal Pecio CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_720, ENE), 1402f3d4ae43SMichal Pecio CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_722, ENE), 14038c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1211, ENE), 14048c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1225, ENE), 14058c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1410, ENE), 14068c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1420, ENE), 140763e7ebd0SDaniel Ritz #endif /* CONFIG_YENTA_TI */ 14081da177e4SLinus Torvalds 140963e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 14101da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C465, RICOH), 14111da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C466, RICOH), 14121da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C475, RICOH), 14131da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, RICOH), 14141da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C478, RICOH), 141563e7ebd0SDaniel Ritz #endif 14161da177e4SLinus Torvalds 141763e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 1418ea2f1590SDaniel Ritz CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC95, TOPIC95), 14191da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC97, TOPIC97), 14201da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC100, TOPIC97), 142163e7ebd0SDaniel Ritz #endif 14221da177e4SLinus Torvalds 142363e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 14241da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_O2, PCI_ANY_ID, O2MICRO), 142563e7ebd0SDaniel Ritz #endif 14261da177e4SLinus Torvalds 14271da177e4SLinus Torvalds /* match any cardbus bridge */ 14281da177e4SLinus Torvalds CB_ID(PCI_ANY_ID, PCI_ANY_ID, DEFAULT), 14291da177e4SLinus Torvalds { /* all zeroes */ } 14301da177e4SLinus Torvalds }; 14311da177e4SLinus Torvalds MODULE_DEVICE_TABLE(pci, yenta_table); 14321da177e4SLinus Torvalds 14331da177e4SLinus Torvalds 14341da177e4SLinus Torvalds static struct pci_driver yenta_cardbus_driver = { 14351da177e4SLinus Torvalds .name = "yenta_cardbus", 14361da177e4SLinus Torvalds .id_table = yenta_table, 14371da177e4SLinus Torvalds .probe = yenta_probe, 1438*96364e3aSBill Pemberton .remove = yenta_close, 14390c570cdeSRafael J. Wysocki .driver.pm = YENTA_PM_OPS, 14401da177e4SLinus Torvalds }; 14411da177e4SLinus Torvalds 14421da177e4SLinus Torvalds 14431da177e4SLinus Torvalds static int __init yenta_socket_init(void) 14441da177e4SLinus Torvalds { 14451da177e4SLinus Torvalds return pci_register_driver(¥ta_cardbus_driver); 14461da177e4SLinus Torvalds } 14471da177e4SLinus Torvalds 14481da177e4SLinus Torvalds 14491da177e4SLinus Torvalds static void __exit yenta_socket_exit(void) 14501da177e4SLinus Torvalds { 14511da177e4SLinus Torvalds pci_unregister_driver(¥ta_cardbus_driver); 14521da177e4SLinus Torvalds } 14531da177e4SLinus Torvalds 14541da177e4SLinus Torvalds 14551da177e4SLinus Torvalds module_init(yenta_socket_init); 14561da177e4SLinus Torvalds module_exit(yenta_socket_exit); 14571da177e4SLinus Torvalds 14581da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 1459