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 40dd797d81SDominik Brodowski #define debug(x, s, args...) dev_dbg(&s->dev->dev, x, ##args) 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds /* Don't ask.. */ 431da177e4SLinus Torvalds #define to_cycles(ns) ((ns)/120) 441da177e4SLinus Torvalds #define to_ns(cycles) ((cycles)*120) 451da177e4SLinus Torvalds 4678187865SRandy Dunlap /* 4763e7ebd0SDaniel Ritz * yenta PCI irq probing. 4863e7ebd0SDaniel Ritz * currently only used in the TI/EnE initialization code 4963e7ebd0SDaniel Ritz */ 5063e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 511da177e4SLinus Torvalds static int yenta_probe_cb_irq(struct yenta_socket *socket); 5263e7ebd0SDaniel Ritz #endif 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds static unsigned int override_bios; 561da177e4SLinus Torvalds module_param(override_bios, uint, 0000); 571da177e4SLinus Torvalds MODULE_PARM_DESC(override_bios, "yenta ignore bios resource allocation"); 581da177e4SLinus Torvalds 591da177e4SLinus Torvalds /* 601da177e4SLinus Torvalds * Generate easy-to-use ways of reading a cardbus sockets 611da177e4SLinus Torvalds * regular memory space ("cb_xxx"), configuration space 621da177e4SLinus Torvalds * ("config_xxx") and compatibility space ("exca_xxxx") 631da177e4SLinus Torvalds */ 641da177e4SLinus Torvalds static inline u32 cb_readl(struct yenta_socket *socket, unsigned reg) 651da177e4SLinus Torvalds { 661da177e4SLinus Torvalds u32 val = readl(socket->base + reg); 67dd797d81SDominik Brodowski debug("%04x %08x\n", socket, reg, val); 681da177e4SLinus Torvalds return val; 691da177e4SLinus Torvalds } 701da177e4SLinus Torvalds 711da177e4SLinus Torvalds static inline void cb_writel(struct yenta_socket *socket, unsigned reg, u32 val) 721da177e4SLinus Torvalds { 73dd797d81SDominik Brodowski debug("%04x %08x\n", socket, reg, val); 741da177e4SLinus Torvalds writel(val, socket->base + reg); 75c8751e4cSDaniel Ritz readl(socket->base + reg); /* avoid problems with PCI write posting */ 761da177e4SLinus Torvalds } 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds static inline u8 config_readb(struct yenta_socket *socket, unsigned offset) 791da177e4SLinus Torvalds { 801da177e4SLinus Torvalds u8 val; 811da177e4SLinus Torvalds pci_read_config_byte(socket->dev, offset, &val); 82dd797d81SDominik Brodowski debug("%04x %02x\n", socket, offset, val); 831da177e4SLinus Torvalds return val; 841da177e4SLinus Torvalds } 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds static inline u16 config_readw(struct yenta_socket *socket, unsigned offset) 871da177e4SLinus Torvalds { 881da177e4SLinus Torvalds u16 val; 891da177e4SLinus Torvalds pci_read_config_word(socket->dev, offset, &val); 90dd797d81SDominik Brodowski debug("%04x %04x\n", socket, offset, val); 911da177e4SLinus Torvalds return val; 921da177e4SLinus Torvalds } 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds static inline u32 config_readl(struct yenta_socket *socket, unsigned offset) 951da177e4SLinus Torvalds { 961da177e4SLinus Torvalds u32 val; 971da177e4SLinus Torvalds pci_read_config_dword(socket->dev, offset, &val); 98dd797d81SDominik Brodowski debug("%04x %08x\n", socket, offset, val); 991da177e4SLinus Torvalds return val; 1001da177e4SLinus Torvalds } 1011da177e4SLinus Torvalds 1021da177e4SLinus Torvalds static inline void config_writeb(struct yenta_socket *socket, unsigned offset, u8 val) 1031da177e4SLinus Torvalds { 104dd797d81SDominik Brodowski debug("%04x %02x\n", socket, offset, val); 1051da177e4SLinus Torvalds pci_write_config_byte(socket->dev, offset, val); 1061da177e4SLinus Torvalds } 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds static inline void config_writew(struct yenta_socket *socket, unsigned offset, u16 val) 1091da177e4SLinus Torvalds { 110dd797d81SDominik Brodowski debug("%04x %04x\n", socket, offset, val); 1111da177e4SLinus Torvalds pci_write_config_word(socket->dev, offset, val); 1121da177e4SLinus Torvalds } 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds static inline void config_writel(struct yenta_socket *socket, unsigned offset, u32 val) 1151da177e4SLinus Torvalds { 116dd797d81SDominik Brodowski debug("%04x %08x\n", socket, offset, val); 1171da177e4SLinus Torvalds pci_write_config_dword(socket->dev, offset, val); 1181da177e4SLinus Torvalds } 1191da177e4SLinus Torvalds 1201da177e4SLinus Torvalds static inline u8 exca_readb(struct yenta_socket *socket, unsigned reg) 1211da177e4SLinus Torvalds { 1221da177e4SLinus Torvalds u8 val = readb(socket->base + 0x800 + reg); 123dd797d81SDominik Brodowski debug("%04x %02x\n", socket, reg, val); 1241da177e4SLinus Torvalds return val; 1251da177e4SLinus Torvalds } 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds static inline u8 exca_readw(struct yenta_socket *socket, unsigned reg) 1281da177e4SLinus Torvalds { 1291da177e4SLinus Torvalds u16 val; 1301da177e4SLinus Torvalds val = readb(socket->base + 0x800 + reg); 1311da177e4SLinus Torvalds val |= readb(socket->base + 0x800 + reg + 1) << 8; 132dd797d81SDominik Brodowski debug("%04x %04x\n", socket, reg, val); 1331da177e4SLinus Torvalds return val; 1341da177e4SLinus Torvalds } 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds static inline void exca_writeb(struct yenta_socket *socket, unsigned reg, u8 val) 1371da177e4SLinus Torvalds { 138dd797d81SDominik Brodowski debug("%04x %02x\n", socket, reg, val); 1391da177e4SLinus Torvalds writeb(val, socket->base + 0x800 + reg); 140c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg); /* PCI write posting... */ 1411da177e4SLinus Torvalds } 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds static void exca_writew(struct yenta_socket *socket, unsigned reg, u16 val) 1441da177e4SLinus Torvalds { 145dd797d81SDominik Brodowski debug("%04x %04x\n", socket, reg, val); 1461da177e4SLinus Torvalds writeb(val, socket->base + 0x800 + reg); 1471da177e4SLinus Torvalds writeb(val >> 8, socket->base + 0x800 + reg + 1); 148c8751e4cSDaniel Ritz 149c8751e4cSDaniel Ritz /* PCI write posting... */ 150c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg); 151c8751e4cSDaniel Ritz readb(socket->base + 0x800 + reg + 1); 1521da177e4SLinus Torvalds } 1531da177e4SLinus Torvalds 154030ee39cSLinus Torvalds static ssize_t show_yenta_registers(struct device *yentadev, struct device_attribute *attr, char *buf) 155030ee39cSLinus Torvalds { 156030ee39cSLinus Torvalds struct pci_dev *dev = to_pci_dev(yentadev); 157030ee39cSLinus Torvalds struct yenta_socket *socket = pci_get_drvdata(dev); 158030ee39cSLinus Torvalds int offset = 0, i; 159030ee39cSLinus Torvalds 160030ee39cSLinus Torvalds offset = snprintf(buf, PAGE_SIZE, "CB registers:"); 161030ee39cSLinus Torvalds for (i = 0; i < 0x24; i += 4) { 162030ee39cSLinus Torvalds unsigned val; 163030ee39cSLinus Torvalds if (!(i & 15)) 164030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i); 165030ee39cSLinus Torvalds val = cb_readl(socket, i); 166030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, " %08x", val); 167030ee39cSLinus Torvalds } 168030ee39cSLinus Torvalds 169030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n\nExCA registers:"); 170030ee39cSLinus Torvalds for (i = 0; i < 0x45; i++) { 171030ee39cSLinus Torvalds unsigned char val; 172030ee39cSLinus Torvalds if (!(i & 7)) { 173030ee39cSLinus Torvalds if (i & 8) { 174030ee39cSLinus Torvalds memcpy(buf + offset, " -", 2); 175030ee39cSLinus Torvalds offset += 2; 176030ee39cSLinus Torvalds } else 177030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, "\n%02x:", i); 178030ee39cSLinus Torvalds } 179030ee39cSLinus Torvalds val = exca_readb(socket, i); 180030ee39cSLinus Torvalds offset += snprintf(buf + offset, PAGE_SIZE - offset, " %02x", val); 181030ee39cSLinus Torvalds } 182030ee39cSLinus Torvalds buf[offset++] = '\n'; 183030ee39cSLinus Torvalds return offset; 184030ee39cSLinus Torvalds } 185030ee39cSLinus Torvalds 186030ee39cSLinus Torvalds static DEVICE_ATTR(yenta_registers, S_IRUSR, show_yenta_registers, NULL); 187030ee39cSLinus Torvalds 1881da177e4SLinus Torvalds /* 1891da177e4SLinus Torvalds * Ugh, mixed-mode cardbus and 16-bit pccard state: things depend 1901da177e4SLinus Torvalds * on what kind of card is inserted.. 1911da177e4SLinus Torvalds */ 1921da177e4SLinus Torvalds static int yenta_get_status(struct pcmcia_socket *sock, unsigned int *value) 1931da177e4SLinus Torvalds { 1941da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 1951da177e4SLinus Torvalds unsigned int val; 1961da177e4SLinus Torvalds u32 state = cb_readl(socket, CB_SOCKET_STATE); 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds val = (state & CB_3VCARD) ? SS_3VCARD : 0; 1991da177e4SLinus Torvalds val |= (state & CB_XVCARD) ? SS_XVCARD : 0; 200fa912bcbSDaniel Ritz val |= (state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) ? 0 : SS_PENDING; 201fa912bcbSDaniel Ritz val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? SS_PENDING : 0; 202fa912bcbSDaniel Ritz 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds if (state & CB_CBCARD) { 2051da177e4SLinus Torvalds val |= SS_CARDBUS; 2061da177e4SLinus Torvalds val |= (state & CB_CARDSTS) ? SS_STSCHG : 0; 2071da177e4SLinus Torvalds val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? 0 : SS_DETECT; 2081da177e4SLinus Torvalds val |= (state & CB_PWRCYCLE) ? SS_POWERON | SS_READY : 0; 209fa912bcbSDaniel Ritz } else if (state & CB_16BITCARD) { 2101da177e4SLinus Torvalds u8 status = exca_readb(socket, I365_STATUS); 2111da177e4SLinus Torvalds val |= ((status & I365_CS_DETECT) == I365_CS_DETECT) ? SS_DETECT : 0; 2121da177e4SLinus Torvalds if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { 2131da177e4SLinus Torvalds val |= (status & I365_CS_STSCHG) ? 0 : SS_STSCHG; 2141da177e4SLinus Torvalds } else { 2151da177e4SLinus Torvalds val |= (status & I365_CS_BVD1) ? 0 : SS_BATDEAD; 2161da177e4SLinus Torvalds val |= (status & I365_CS_BVD2) ? 0 : SS_BATWARN; 2171da177e4SLinus Torvalds } 2181da177e4SLinus Torvalds val |= (status & I365_CS_WRPROT) ? SS_WRPROT : 0; 2191da177e4SLinus Torvalds val |= (status & I365_CS_READY) ? SS_READY : 0; 2201da177e4SLinus Torvalds val |= (status & I365_CS_POWERON) ? SS_POWERON : 0; 2211da177e4SLinus Torvalds } 2221da177e4SLinus Torvalds 2231da177e4SLinus Torvalds *value = val; 2241da177e4SLinus Torvalds return 0; 2251da177e4SLinus Torvalds } 2261da177e4SLinus Torvalds 2271da177e4SLinus Torvalds static void yenta_set_power(struct yenta_socket *socket, socket_state_t *state) 2281da177e4SLinus Torvalds { 229ea2f1590SDaniel Ritz /* some birdges require to use the ExCA registers to power 16bit cards */ 230ea2f1590SDaniel Ritz if (!(cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) && 231ea2f1590SDaniel Ritz (socket->flags & YENTA_16BIT_POWER_EXCA)) { 232ea2f1590SDaniel Ritz u8 reg, old; 233ea2f1590SDaniel Ritz reg = old = exca_readb(socket, I365_POWER); 234ea2f1590SDaniel Ritz reg &= ~(I365_VCC_MASK | I365_VPP1_MASK | I365_VPP2_MASK); 235ea2f1590SDaniel Ritz 236ea2f1590SDaniel Ritz /* i82365SL-DF style */ 237ea2f1590SDaniel Ritz if (socket->flags & YENTA_16BIT_POWER_DF) { 238ea2f1590SDaniel Ritz switch (state->Vcc) { 2399fea84f4SDominik Brodowski case 33: 2409fea84f4SDominik Brodowski reg |= I365_VCC_3V; 2419fea84f4SDominik Brodowski break; 2429fea84f4SDominik Brodowski case 50: 2439fea84f4SDominik Brodowski reg |= I365_VCC_5V; 2449fea84f4SDominik Brodowski break; 2459fea84f4SDominik Brodowski default: 2469fea84f4SDominik Brodowski reg = 0; 2479fea84f4SDominik Brodowski break; 248ea2f1590SDaniel Ritz } 249ea2f1590SDaniel Ritz switch (state->Vpp) { 250ea2f1590SDaniel Ritz case 33: 2519fea84f4SDominik Brodowski case 50: 2529fea84f4SDominik Brodowski reg |= I365_VPP1_5V; 2539fea84f4SDominik Brodowski break; 2549fea84f4SDominik Brodowski case 120: 2559fea84f4SDominik Brodowski reg |= I365_VPP1_12V; 2569fea84f4SDominik Brodowski break; 257ea2f1590SDaniel Ritz } 258ea2f1590SDaniel Ritz } else { 259ea2f1590SDaniel Ritz /* i82365SL-B style */ 260ea2f1590SDaniel Ritz switch (state->Vcc) { 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) { 2699fea84f4SDominik Brodowski case 50: 2709fea84f4SDominik Brodowski reg |= I365_VPP1_5V | I365_VPP2_5V; 2719fea84f4SDominik Brodowski break; 2729fea84f4SDominik Brodowski case 120: 2739fea84f4SDominik Brodowski reg |= I365_VPP1_12V | I365_VPP2_12V; 2749fea84f4SDominik Brodowski break; 275ea2f1590SDaniel Ritz } 276ea2f1590SDaniel Ritz } 277ea2f1590SDaniel Ritz 278ea2f1590SDaniel Ritz if (reg != old) 279ea2f1590SDaniel Ritz exca_writeb(socket, I365_POWER, reg); 280ea2f1590SDaniel Ritz } else { 2811da177e4SLinus Torvalds u32 reg = 0; /* CB_SC_STPCLK? */ 2821da177e4SLinus Torvalds switch (state->Vcc) { 2839fea84f4SDominik Brodowski case 33: 2849fea84f4SDominik Brodowski reg = CB_SC_VCC_3V; 2859fea84f4SDominik Brodowski break; 2869fea84f4SDominik Brodowski case 50: 2879fea84f4SDominik Brodowski reg = CB_SC_VCC_5V; 2889fea84f4SDominik Brodowski break; 2899fea84f4SDominik Brodowski default: 2909fea84f4SDominik Brodowski reg = 0; 2919fea84f4SDominik Brodowski break; 2921da177e4SLinus Torvalds } 2931da177e4SLinus Torvalds switch (state->Vpp) { 2949fea84f4SDominik Brodowski case 33: 2959fea84f4SDominik Brodowski reg |= CB_SC_VPP_3V; 2969fea84f4SDominik Brodowski break; 2979fea84f4SDominik Brodowski case 50: 2989fea84f4SDominik Brodowski reg |= CB_SC_VPP_5V; 2999fea84f4SDominik Brodowski break; 3009fea84f4SDominik Brodowski case 120: 3019fea84f4SDominik Brodowski reg |= CB_SC_VPP_12V; 3029fea84f4SDominik Brodowski break; 3031da177e4SLinus Torvalds } 3041da177e4SLinus Torvalds if (reg != cb_readl(socket, CB_SOCKET_CONTROL)) 3051da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_CONTROL, reg); 3061da177e4SLinus Torvalds } 307ea2f1590SDaniel Ritz } 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds static int yenta_set_socket(struct pcmcia_socket *sock, socket_state_t *state) 3101da177e4SLinus Torvalds { 3111da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 3121da177e4SLinus Torvalds u16 bridge; 3131da177e4SLinus Torvalds 314d250a481SDaniel Ritz /* if powering down: do it immediately */ 315d250a481SDaniel Ritz if (state->Vcc == 0) 3161da177e4SLinus Torvalds yenta_set_power(socket, state); 317d250a481SDaniel Ritz 3181da177e4SLinus Torvalds socket->io_irq = state->io_irq; 3191da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL) & ~(CB_BRIDGE_CRST | CB_BRIDGE_INTR); 3201da177e4SLinus Torvalds if (cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) { 3211da177e4SLinus Torvalds u8 intr; 3221da177e4SLinus Torvalds bridge |= (state->flags & SS_RESET) ? CB_BRIDGE_CRST : 0; 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds /* ISA interrupt control? */ 3251da177e4SLinus Torvalds intr = exca_readb(socket, I365_INTCTL); 3261da177e4SLinus Torvalds intr = (intr & ~0xf); 3271da177e4SLinus Torvalds if (!socket->cb_irq) { 3281da177e4SLinus Torvalds intr |= state->io_irq; 3291da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 3301da177e4SLinus Torvalds } 3311da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, intr); 3321da177e4SLinus Torvalds } else { 3331da177e4SLinus Torvalds u8 reg; 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds reg = exca_readb(socket, I365_INTCTL) & (I365_RING_ENA | I365_INTR_ENA); 3361da177e4SLinus Torvalds reg |= (state->flags & SS_RESET) ? 0 : I365_PC_RESET; 3371da177e4SLinus Torvalds reg |= (state->flags & SS_IOCARD) ? I365_PC_IOCARD : 0; 3381da177e4SLinus Torvalds if (state->io_irq != socket->cb_irq) { 3391da177e4SLinus Torvalds reg |= state->io_irq; 3401da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 3411da177e4SLinus Torvalds } 3421da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, reg); 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds reg = exca_readb(socket, I365_POWER) & (I365_VCC_MASK|I365_VPP1_MASK); 3451da177e4SLinus Torvalds reg |= I365_PWR_NORESET; 3469fea84f4SDominik Brodowski if (state->flags & SS_PWR_AUTO) 3479fea84f4SDominik Brodowski reg |= I365_PWR_AUTO; 3489fea84f4SDominik Brodowski if (state->flags & SS_OUTPUT_ENA) 3499fea84f4SDominik Brodowski reg |= I365_PWR_OUT; 3501da177e4SLinus Torvalds if (exca_readb(socket, I365_POWER) != reg) 3511da177e4SLinus Torvalds exca_writeb(socket, I365_POWER, reg); 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds /* CSC interrupt: no ISA irq for CSC */ 3541da177e4SLinus Torvalds reg = I365_CSC_DETECT; 3551da177e4SLinus Torvalds if (state->flags & SS_IOCARD) { 3569fea84f4SDominik Brodowski if (state->csc_mask & SS_STSCHG) 3579fea84f4SDominik Brodowski reg |= I365_CSC_STSCHG; 3581da177e4SLinus Torvalds } else { 3599fea84f4SDominik Brodowski if (state->csc_mask & SS_BATDEAD) 3609fea84f4SDominik Brodowski reg |= I365_CSC_BVD1; 3619fea84f4SDominik Brodowski if (state->csc_mask & SS_BATWARN) 3629fea84f4SDominik Brodowski reg |= I365_CSC_BVD2; 3639fea84f4SDominik Brodowski if (state->csc_mask & SS_READY) 3649fea84f4SDominik Brodowski reg |= I365_CSC_READY; 3651da177e4SLinus Torvalds } 3661da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, reg); 3671da177e4SLinus Torvalds exca_readb(socket, I365_CSC); 3681da177e4SLinus Torvalds if (sock->zoom_video) 3691da177e4SLinus Torvalds sock->zoom_video(sock, state->flags & SS_ZVCARD); 3701da177e4SLinus Torvalds } 3711da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 3721da177e4SLinus Torvalds /* Socket event mask: get card insert/remove events.. */ 3731da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 3741da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK); 375d250a481SDaniel Ritz 376d250a481SDaniel Ritz /* if powering up: do it as the last step when the socket is configured */ 377d250a481SDaniel Ritz if (state->Vcc != 0) 378d250a481SDaniel Ritz yenta_set_power(socket, state); 3791da177e4SLinus Torvalds return 0; 3801da177e4SLinus Torvalds } 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds static int yenta_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io) 3831da177e4SLinus Torvalds { 3841da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 3851da177e4SLinus Torvalds int map; 3861da177e4SLinus Torvalds unsigned char ioctl, addr, enable; 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds map = io->map; 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds if (map > 1) 3911da177e4SLinus Torvalds return -EINVAL; 3921da177e4SLinus Torvalds 3931da177e4SLinus Torvalds enable = I365_ENA_IO(map); 3941da177e4SLinus Torvalds addr = exca_readb(socket, I365_ADDRWIN); 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds /* Disable the window before changing it.. */ 3971da177e4SLinus Torvalds if (addr & enable) { 3981da177e4SLinus Torvalds addr &= ~enable; 3991da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr); 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds exca_writew(socket, I365_IO(map)+I365_W_START, io->start); 4031da177e4SLinus Torvalds exca_writew(socket, I365_IO(map)+I365_W_STOP, io->stop); 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds ioctl = exca_readb(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map); 4069fea84f4SDominik Brodowski if (io->flags & MAP_0WS) 4079fea84f4SDominik Brodowski ioctl |= I365_IOCTL_0WS(map); 4089fea84f4SDominik Brodowski if (io->flags & MAP_16BIT) 4099fea84f4SDominik Brodowski ioctl |= I365_IOCTL_16BIT(map); 4109fea84f4SDominik Brodowski if (io->flags & MAP_AUTOSZ) 4119fea84f4SDominik Brodowski ioctl |= I365_IOCTL_IOCS16(map); 4121da177e4SLinus Torvalds exca_writeb(socket, I365_IOCTL, ioctl); 4131da177e4SLinus Torvalds 4141da177e4SLinus Torvalds if (io->flags & MAP_ACTIVE) 4151da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr | enable); 4161da177e4SLinus Torvalds return 0; 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds 4191da177e4SLinus Torvalds static int yenta_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem) 4201da177e4SLinus Torvalds { 4211da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 4221da177e4SLinus Torvalds struct pci_bus_region region; 4231da177e4SLinus Torvalds int map; 4241da177e4SLinus Torvalds unsigned char addr, enable; 4251da177e4SLinus Torvalds unsigned int start, stop, card_start; 4261da177e4SLinus Torvalds unsigned short word; 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds pcibios_resource_to_bus(socket->dev, ®ion, mem->res); 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds map = mem->map; 4311da177e4SLinus Torvalds start = region.start; 4321da177e4SLinus Torvalds stop = region.end; 4331da177e4SLinus Torvalds card_start = mem->card_start; 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds if (map > 4 || start > stop || ((start ^ stop) >> 24) || 4361da177e4SLinus Torvalds (card_start >> 26) || mem->speed > 1000) 4371da177e4SLinus Torvalds return -EINVAL; 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds enable = I365_ENA_MEM(map); 4401da177e4SLinus Torvalds addr = exca_readb(socket, I365_ADDRWIN); 4411da177e4SLinus Torvalds if (addr & enable) { 4421da177e4SLinus Torvalds addr &= ~enable; 4431da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr); 4441da177e4SLinus Torvalds } 4451da177e4SLinus Torvalds 4461da177e4SLinus Torvalds exca_writeb(socket, CB_MEM_PAGE(map), start >> 24); 4471da177e4SLinus Torvalds 4481da177e4SLinus Torvalds word = (start >> 12) & 0x0fff; 4491da177e4SLinus Torvalds if (mem->flags & MAP_16BIT) 4501da177e4SLinus Torvalds word |= I365_MEM_16BIT; 4511da177e4SLinus Torvalds if (mem->flags & MAP_0WS) 4521da177e4SLinus Torvalds word |= I365_MEM_0WS; 4531da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_START, word); 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds word = (stop >> 12) & 0x0fff; 4561da177e4SLinus Torvalds switch (to_cycles(mem->speed)) { 4579fea84f4SDominik Brodowski case 0: 4589fea84f4SDominik Brodowski break; 4599fea84f4SDominik Brodowski case 1: 4609fea84f4SDominik Brodowski word |= I365_MEM_WS0; 4619fea84f4SDominik Brodowski break; 4629fea84f4SDominik Brodowski case 2: 4639fea84f4SDominik Brodowski word |= I365_MEM_WS1; 4649fea84f4SDominik Brodowski break; 4659fea84f4SDominik Brodowski default: 4669fea84f4SDominik Brodowski word |= I365_MEM_WS1 | I365_MEM_WS0; 4679fea84f4SDominik Brodowski break; 4681da177e4SLinus Torvalds } 4691da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_STOP, word); 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds word = ((card_start - start) >> 12) & 0x3fff; 4721da177e4SLinus Torvalds if (mem->flags & MAP_WRPROT) 4731da177e4SLinus Torvalds word |= I365_MEM_WRPROT; 4741da177e4SLinus Torvalds if (mem->flags & MAP_ATTRIB) 4751da177e4SLinus Torvalds word |= I365_MEM_REG; 4761da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_OFF, word); 4771da177e4SLinus Torvalds 4781da177e4SLinus Torvalds if (mem->flags & MAP_ACTIVE) 4791da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr | enable); 4801da177e4SLinus Torvalds return 0; 4811da177e4SLinus Torvalds } 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds 484fa912bcbSDaniel Ritz 4857d12e780SDavid Howells static irqreturn_t yenta_interrupt(int irq, void *dev_id) 4861da177e4SLinus Torvalds { 487fa912bcbSDaniel Ritz unsigned int events; 488fa912bcbSDaniel Ritz struct yenta_socket *socket = (struct yenta_socket *) dev_id; 4891da177e4SLinus Torvalds u8 csc; 4901da177e4SLinus Torvalds u32 cb_event; 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds /* Clear interrupt status for the event */ 4931da177e4SLinus Torvalds cb_event = cb_readl(socket, CB_SOCKET_EVENT); 4941da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, cb_event); 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds csc = exca_readb(socket, I365_CSC); 4971da177e4SLinus Torvalds 498e4115805SDaniel Ritz if (!(cb_event || csc)) 499e4115805SDaniel Ritz return IRQ_NONE; 500e4115805SDaniel Ritz 5011da177e4SLinus Torvalds events = (cb_event & (CB_CD1EVENT | CB_CD2EVENT)) ? SS_DETECT : 0 ; 5021da177e4SLinus Torvalds events |= (csc & I365_CSC_DETECT) ? SS_DETECT : 0; 5031da177e4SLinus Torvalds if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { 5041da177e4SLinus Torvalds events |= (csc & I365_CSC_STSCHG) ? SS_STSCHG : 0; 5051da177e4SLinus Torvalds } else { 5061da177e4SLinus Torvalds events |= (csc & I365_CSC_BVD1) ? SS_BATDEAD : 0; 5071da177e4SLinus Torvalds events |= (csc & I365_CSC_BVD2) ? SS_BATWARN : 0; 5081da177e4SLinus Torvalds events |= (csc & I365_CSC_READY) ? SS_READY : 0; 5091da177e4SLinus Torvalds } 5101da177e4SLinus Torvalds 511fa912bcbSDaniel Ritz if (events) 5121da177e4SLinus Torvalds pcmcia_parse_events(&socket->socket, events); 513fa912bcbSDaniel Ritz 5141da177e4SLinus Torvalds return IRQ_HANDLED; 5151da177e4SLinus Torvalds } 5161da177e4SLinus Torvalds 5171da177e4SLinus Torvalds static void yenta_interrupt_wrapper(unsigned long data) 5181da177e4SLinus Torvalds { 5191da177e4SLinus Torvalds struct yenta_socket *socket = (struct yenta_socket *) data; 5201da177e4SLinus Torvalds 5217d12e780SDavid Howells yenta_interrupt(0, (void *)socket); 5221da177e4SLinus Torvalds socket->poll_timer.expires = jiffies + HZ; 5231da177e4SLinus Torvalds add_timer(&socket->poll_timer); 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds static void yenta_clear_maps(struct yenta_socket *socket) 5271da177e4SLinus Torvalds { 5281da177e4SLinus Torvalds int i; 5291da177e4SLinus Torvalds struct resource res = { .start = 0, .end = 0x0fff }; 5301da177e4SLinus Torvalds pccard_io_map io = { 0, 0, 0, 0, 1 }; 5311da177e4SLinus Torvalds pccard_mem_map mem = { .res = &res, }; 5321da177e4SLinus Torvalds 5331da177e4SLinus Torvalds yenta_set_socket(&socket->socket, &dead_socket); 5341da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 5351da177e4SLinus Torvalds io.map = i; 5361da177e4SLinus Torvalds yenta_set_io_map(&socket->socket, &io); 5371da177e4SLinus Torvalds } 5381da177e4SLinus Torvalds for (i = 0; i < 5; i++) { 5391da177e4SLinus Torvalds mem.map = i; 5401da177e4SLinus Torvalds yenta_set_mem_map(&socket->socket, &mem); 5411da177e4SLinus Torvalds } 5421da177e4SLinus Torvalds } 5431da177e4SLinus Torvalds 544fa912bcbSDaniel Ritz /* redoes voltage interrogation if required */ 545fa912bcbSDaniel Ritz static void yenta_interrogate(struct yenta_socket *socket) 546fa912bcbSDaniel Ritz { 547fa912bcbSDaniel Ritz u32 state; 548fa912bcbSDaniel Ritz 549fa912bcbSDaniel Ritz state = cb_readl(socket, CB_SOCKET_STATE); 550fa912bcbSDaniel Ritz if (!(state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) || 551fa912bcbSDaniel Ritz (state & (CB_CDETECT1 | CB_CDETECT2 | CB_NOTACARD | CB_BADVCCREQ)) || 552fa912bcbSDaniel Ritz ((state & (CB_16BITCARD | CB_CBCARD)) == (CB_16BITCARD | CB_CBCARD))) 553fa912bcbSDaniel Ritz cb_writel(socket, CB_SOCKET_FORCE, CB_CVSTEST); 554fa912bcbSDaniel Ritz } 555fa912bcbSDaniel Ritz 5561da177e4SLinus Torvalds /* Called at resume and initialization events */ 5571da177e4SLinus Torvalds static int yenta_sock_init(struct pcmcia_socket *sock) 5581da177e4SLinus Torvalds { 5591da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds exca_writeb(socket, I365_GBLCTL, 0x00); 5621da177e4SLinus Torvalds exca_writeb(socket, I365_GENCTL, 0x00); 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds /* Redo card voltage interrogation */ 565fa912bcbSDaniel Ritz yenta_interrogate(socket); 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds yenta_clear_maps(socket); 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds if (socket->type && socket->type->sock_init) 5701da177e4SLinus Torvalds socket->type->sock_init(socket); 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds /* Re-enable CSC interrupts */ 5731da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK); 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds return 0; 5761da177e4SLinus Torvalds } 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds static int yenta_sock_suspend(struct pcmcia_socket *sock) 5791da177e4SLinus Torvalds { 5801da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds /* Disable CSC interrupts */ 5831da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0x0); 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds return 0; 5861da177e4SLinus Torvalds } 5871da177e4SLinus Torvalds 5881da177e4SLinus Torvalds /* 5891da177e4SLinus Torvalds * Use an adaptive allocation for the memory resource, 5901da177e4SLinus Torvalds * sometimes the memory behind pci bridges is limited: 5911da177e4SLinus Torvalds * 1/8 of the size of the io window of the parent. 592eb0a90b4SDominik Brodowski * max 4 MB, min 16 kB. We try very hard to not get below 593eb0a90b4SDominik Brodowski * the "ACC" values, though. 5941da177e4SLinus Torvalds */ 5959fea84f4SDominik Brodowski #define BRIDGE_MEM_MAX (4*1024*1024) 5969fea84f4SDominik Brodowski #define BRIDGE_MEM_ACC (128*1024) 5979fea84f4SDominik Brodowski #define BRIDGE_MEM_MIN (16*1024) 5981da177e4SLinus Torvalds 599eb0a90b4SDominik Brodowski #define BRIDGE_IO_MAX 512 600eb0a90b4SDominik Brodowski #define BRIDGE_IO_ACC 256 6011da177e4SLinus Torvalds #define BRIDGE_IO_MIN 32 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds #ifndef PCIBIOS_MIN_CARDBUS_IO 6041da177e4SLinus Torvalds #define PCIBIOS_MIN_CARDBUS_IO PCIBIOS_MIN_IO 6051da177e4SLinus Torvalds #endif 6061da177e4SLinus Torvalds 607eb0a90b4SDominik Brodowski static int yenta_search_one_res(struct resource *root, struct resource *res, 608eb0a90b4SDominik Brodowski u32 min) 609eb0a90b4SDominik Brodowski { 610eb0a90b4SDominik Brodowski u32 align, size, start, end; 611eb0a90b4SDominik Brodowski 612eb0a90b4SDominik Brodowski if (res->flags & IORESOURCE_IO) { 613eb0a90b4SDominik Brodowski align = 1024; 614eb0a90b4SDominik Brodowski size = BRIDGE_IO_MAX; 615eb0a90b4SDominik Brodowski start = PCIBIOS_MIN_CARDBUS_IO; 616eb0a90b4SDominik Brodowski end = ~0U; 617eb0a90b4SDominik Brodowski } else { 618eb0a90b4SDominik Brodowski unsigned long avail = root->end - root->start; 619eb0a90b4SDominik Brodowski int i; 620eb0a90b4SDominik Brodowski size = BRIDGE_MEM_MAX; 621eb0a90b4SDominik Brodowski if (size > avail/8) { 622eb0a90b4SDominik Brodowski size = (avail+1)/8; 623eb0a90b4SDominik Brodowski /* round size down to next power of 2 */ 624eb0a90b4SDominik Brodowski i = 0; 625eb0a90b4SDominik Brodowski while ((size /= 2) != 0) 626eb0a90b4SDominik Brodowski i++; 627eb0a90b4SDominik Brodowski size = 1 << i; 628eb0a90b4SDominik Brodowski } 629eb0a90b4SDominik Brodowski if (size < min) 630eb0a90b4SDominik Brodowski size = min; 631eb0a90b4SDominik Brodowski align = size; 632eb0a90b4SDominik Brodowski start = PCIBIOS_MIN_MEM; 633eb0a90b4SDominik Brodowski end = ~0U; 634eb0a90b4SDominik Brodowski } 635eb0a90b4SDominik Brodowski 636eb0a90b4SDominik Brodowski do { 637eb0a90b4SDominik Brodowski if (allocate_resource(root, res, size, start, end, align, 638eb0a90b4SDominik Brodowski NULL, NULL) == 0) { 639eb0a90b4SDominik Brodowski return 1; 640eb0a90b4SDominik Brodowski } 641eb0a90b4SDominik Brodowski size = size/2; 642eb0a90b4SDominik Brodowski align = size; 643eb0a90b4SDominik Brodowski } while (size >= min); 644eb0a90b4SDominik Brodowski 645eb0a90b4SDominik Brodowski return 0; 646eb0a90b4SDominik Brodowski } 647eb0a90b4SDominik Brodowski 648eb0a90b4SDominik Brodowski 649eb0a90b4SDominik Brodowski static int yenta_search_res(struct yenta_socket *socket, struct resource *res, 650eb0a90b4SDominik Brodowski u32 min) 651eb0a90b4SDominik Brodowski { 65289a74eccSBjorn Helgaas struct resource *root; 653eb0a90b4SDominik Brodowski int i; 65489a74eccSBjorn Helgaas 65589a74eccSBjorn Helgaas pci_bus_for_each_resource(socket->dev->bus, root, i) { 656eb0a90b4SDominik Brodowski if (!root) 657eb0a90b4SDominik Brodowski continue; 658eb0a90b4SDominik Brodowski 659eb0a90b4SDominik Brodowski if ((res->flags ^ root->flags) & 660eb0a90b4SDominik Brodowski (IORESOURCE_IO | IORESOURCE_MEM | IORESOURCE_PREFETCH)) 661eb0a90b4SDominik Brodowski continue; /* Wrong type */ 662eb0a90b4SDominik Brodowski 663eb0a90b4SDominik Brodowski if (yenta_search_one_res(root, res, min)) 664eb0a90b4SDominik Brodowski return 1; 665eb0a90b4SDominik Brodowski } 666eb0a90b4SDominik Brodowski return 0; 667eb0a90b4SDominik Brodowski } 668eb0a90b4SDominik Brodowski 669b3743fa4SDominik Brodowski static int yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned type, int addr_start, int addr_end) 6701da177e4SLinus Torvalds { 671852710d9SMatthew Wilcox struct pci_dev *dev = socket->dev; 672852710d9SMatthew Wilcox struct resource *res; 67343c34735SDominik Brodowski struct pci_bus_region region; 6741da177e4SLinus Torvalds unsigned mask; 6751da177e4SLinus Torvalds 676852710d9SMatthew Wilcox res = dev->resource + PCI_BRIDGE_RESOURCES + nr; 6777925407aSIvan Kokshaysky /* Already allocated? */ 6787925407aSIvan Kokshaysky if (res->parent) 679b3743fa4SDominik Brodowski return 0; 6807925407aSIvan Kokshaysky 6811da177e4SLinus Torvalds /* The granularity of the memory limit is 4kB, on IO it's 4 bytes */ 6821da177e4SLinus Torvalds mask = ~0xfff; 6831da177e4SLinus Torvalds if (type & IORESOURCE_IO) 6841da177e4SLinus Torvalds mask = ~3; 6851da177e4SLinus Torvalds 686852710d9SMatthew Wilcox res->name = dev->subordinate->name; 6871da177e4SLinus Torvalds res->flags = type; 6881da177e4SLinus Torvalds 68943c34735SDominik Brodowski region.start = config_readl(socket, addr_start) & mask; 69043c34735SDominik Brodowski region.end = config_readl(socket, addr_end) | ~mask; 69143c34735SDominik Brodowski if (region.start && region.end > region.start && !override_bios) { 692852710d9SMatthew Wilcox pcibios_bus_to_resource(dev, res, ®ion); 693852710d9SMatthew Wilcox if (pci_claim_resource(dev, PCI_BRIDGE_RESOURCES + nr) == 0) 694b3743fa4SDominik Brodowski return 0; 695852710d9SMatthew Wilcox dev_printk(KERN_INFO, &dev->dev, 696dd797d81SDominik Brodowski "Preassigned resource %d busy or not available, " 697dd797d81SDominik Brodowski "reconfiguring...\n", 698dd797d81SDominik Brodowski nr); 6991da177e4SLinus Torvalds } 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds if (type & IORESOURCE_IO) { 702eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_IO_MAX)) || 703eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_IO_ACC)) || 704b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_IO_MIN))) 705b3743fa4SDominik Brodowski return 1; 706eb0a90b4SDominik Brodowski } else { 707eb0a90b4SDominik Brodowski if (type & IORESOURCE_PREFETCH) { 708eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) || 709eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) || 710b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_MIN))) 711b3743fa4SDominik Brodowski return 1; 712eb0a90b4SDominik Brodowski /* Approximating prefetchable by non-prefetchable */ 713eb0a90b4SDominik Brodowski res->flags = IORESOURCE_MEM; 714eb0a90b4SDominik Brodowski } 715eb0a90b4SDominik Brodowski if ((yenta_search_res(socket, res, BRIDGE_MEM_MAX)) || 716eb0a90b4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_ACC)) || 717b3743fa4SDominik Brodowski (yenta_search_res(socket, res, BRIDGE_MEM_MIN))) 718b3743fa4SDominik Brodowski return 1; 719eb0a90b4SDominik Brodowski } 720eb0a90b4SDominik Brodowski 721852710d9SMatthew Wilcox dev_printk(KERN_INFO, &dev->dev, 722dd797d81SDominik Brodowski "no resource of type %x available, trying to continue...\n", 723dd797d81SDominik Brodowski type); 724eb0a90b4SDominik Brodowski res->start = res->end = res->flags = 0; 725b3743fa4SDominik Brodowski return 0; 7261da177e4SLinus Torvalds } 7271da177e4SLinus Torvalds 7281da177e4SLinus Torvalds /* 7291da177e4SLinus Torvalds * Allocate the bridge mappings for the device.. 7301da177e4SLinus Torvalds */ 7311da177e4SLinus Torvalds static void yenta_allocate_resources(struct yenta_socket *socket) 7321da177e4SLinus Torvalds { 733b3743fa4SDominik Brodowski int program = 0; 734b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 0, IORESOURCE_IO, 73527879835SDominik Brodowski PCI_CB_IO_BASE_0, PCI_CB_IO_LIMIT_0); 736b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 1, IORESOURCE_IO, 73727879835SDominik Brodowski PCI_CB_IO_BASE_1, PCI_CB_IO_LIMIT_1); 738b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 2, IORESOURCE_MEM|IORESOURCE_PREFETCH, 73927879835SDominik Brodowski PCI_CB_MEMORY_BASE_0, PCI_CB_MEMORY_LIMIT_0); 740b3743fa4SDominik Brodowski program += yenta_allocate_res(socket, 3, IORESOURCE_MEM, 74127879835SDominik Brodowski PCI_CB_MEMORY_BASE_1, PCI_CB_MEMORY_LIMIT_1); 742b3743fa4SDominik Brodowski if (program) 743b3743fa4SDominik Brodowski pci_setup_cardbus(socket->dev->subordinate); 7441da177e4SLinus Torvalds } 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds 7471da177e4SLinus Torvalds /* 7481da177e4SLinus Torvalds * Free the bridge mappings for the device.. 7491da177e4SLinus Torvalds */ 7501da177e4SLinus Torvalds static void yenta_free_resources(struct yenta_socket *socket) 7511da177e4SLinus Torvalds { 7521da177e4SLinus Torvalds int i; 7531da177e4SLinus Torvalds for (i = 0; i < 4; i++) { 7541da177e4SLinus Torvalds struct resource *res; 7551da177e4SLinus Torvalds res = socket->dev->resource + PCI_BRIDGE_RESOURCES + i; 7561da177e4SLinus Torvalds if (res->start != 0 && res->end != 0) 7571da177e4SLinus Torvalds release_resource(res); 758b3743fa4SDominik Brodowski res->start = res->end = res->flags = 0; 7591da177e4SLinus Torvalds } 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds /* 7641da177e4SLinus Torvalds * Close it down - release our resources and go home.. 7651da177e4SLinus Torvalds */ 766734f3fa1SMike Frysinger static void __devexit yenta_close(struct pci_dev *dev) 7671da177e4SLinus Torvalds { 7681da177e4SLinus Torvalds struct yenta_socket *sock = pci_get_drvdata(dev); 7691da177e4SLinus Torvalds 770030ee39cSLinus Torvalds /* Remove the register attributes */ 771030ee39cSLinus Torvalds device_remove_file(&dev->dev, &dev_attr_yenta_registers); 772030ee39cSLinus Torvalds 7731da177e4SLinus Torvalds /* we don't want a dying socket registered */ 7741da177e4SLinus Torvalds pcmcia_unregister_socket(&sock->socket); 7751da177e4SLinus Torvalds 7761da177e4SLinus Torvalds /* Disable all events so we don't die in an IRQ storm */ 7771da177e4SLinus Torvalds cb_writel(sock, CB_SOCKET_MASK, 0x0); 7781da177e4SLinus Torvalds exca_writeb(sock, I365_CSCINT, 0); 7791da177e4SLinus Torvalds 7801da177e4SLinus Torvalds if (sock->cb_irq) 7811da177e4SLinus Torvalds free_irq(sock->cb_irq, sock); 7821da177e4SLinus Torvalds else 7831da177e4SLinus Torvalds del_timer_sync(&sock->poll_timer); 7841da177e4SLinus Torvalds 7851da177e4SLinus Torvalds if (sock->base) 7861da177e4SLinus Torvalds iounmap(sock->base); 7871da177e4SLinus Torvalds yenta_free_resources(sock); 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds pci_release_regions(dev); 7901da177e4SLinus Torvalds pci_disable_device(dev); 7911da177e4SLinus Torvalds pci_set_drvdata(dev, NULL); 7921da177e4SLinus Torvalds } 7931da177e4SLinus Torvalds 7941da177e4SLinus Torvalds 7951da177e4SLinus Torvalds static struct pccard_operations yenta_socket_operations = { 7961da177e4SLinus Torvalds .init = yenta_sock_init, 7971da177e4SLinus Torvalds .suspend = yenta_sock_suspend, 7981da177e4SLinus Torvalds .get_status = yenta_get_status, 7991da177e4SLinus Torvalds .set_socket = yenta_set_socket, 8001da177e4SLinus Torvalds .set_io_map = yenta_set_io_map, 8011da177e4SLinus Torvalds .set_mem_map = yenta_set_mem_map, 8021da177e4SLinus Torvalds }; 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds 80563e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 8061da177e4SLinus Torvalds #include "ti113x.h" 80763e7ebd0SDaniel Ritz #endif 80863e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 8091da177e4SLinus Torvalds #include "ricoh.h" 81063e7ebd0SDaniel Ritz #endif 81163e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 8121da177e4SLinus Torvalds #include "topic.h" 81363e7ebd0SDaniel Ritz #endif 81463e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 8151da177e4SLinus Torvalds #include "o2micro.h" 81663e7ebd0SDaniel Ritz #endif 8171da177e4SLinus Torvalds 8181da177e4SLinus Torvalds enum { 8191da177e4SLinus Torvalds CARDBUS_TYPE_DEFAULT = -1, 8201da177e4SLinus Torvalds CARDBUS_TYPE_TI, 8211da177e4SLinus Torvalds CARDBUS_TYPE_TI113X, 8221da177e4SLinus Torvalds CARDBUS_TYPE_TI12XX, 8231da177e4SLinus Torvalds CARDBUS_TYPE_TI1250, 8241da177e4SLinus Torvalds CARDBUS_TYPE_RICOH, 825ea2f1590SDaniel Ritz CARDBUS_TYPE_TOPIC95, 8261da177e4SLinus Torvalds CARDBUS_TYPE_TOPIC97, 8271da177e4SLinus Torvalds CARDBUS_TYPE_O2MICRO, 8288c3520d4SDaniel Ritz CARDBUS_TYPE_ENE, 8291da177e4SLinus Torvalds }; 8301da177e4SLinus Torvalds 8311da177e4SLinus Torvalds /* 8321da177e4SLinus Torvalds * Different cardbus controllers have slightly different 8331da177e4SLinus Torvalds * initialization sequences etc details. List them here.. 8341da177e4SLinus Torvalds */ 8351da177e4SLinus Torvalds static struct cardbus_type cardbus_type[] = { 83663e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 8371da177e4SLinus Torvalds [CARDBUS_TYPE_TI] = { 8381da177e4SLinus Torvalds .override = ti_override, 8391da177e4SLinus Torvalds .save_state = ti_save_state, 8401da177e4SLinus Torvalds .restore_state = ti_restore_state, 8411da177e4SLinus Torvalds .sock_init = ti_init, 8421da177e4SLinus Torvalds }, 8431da177e4SLinus Torvalds [CARDBUS_TYPE_TI113X] = { 8441da177e4SLinus Torvalds .override = ti113x_override, 8451da177e4SLinus Torvalds .save_state = ti_save_state, 8461da177e4SLinus Torvalds .restore_state = ti_restore_state, 8471da177e4SLinus Torvalds .sock_init = ti_init, 8481da177e4SLinus Torvalds }, 8491da177e4SLinus Torvalds [CARDBUS_TYPE_TI12XX] = { 8501da177e4SLinus Torvalds .override = ti12xx_override, 8511da177e4SLinus Torvalds .save_state = ti_save_state, 8521da177e4SLinus Torvalds .restore_state = ti_restore_state, 8531da177e4SLinus Torvalds .sock_init = ti_init, 8541da177e4SLinus Torvalds }, 8551da177e4SLinus Torvalds [CARDBUS_TYPE_TI1250] = { 8561da177e4SLinus Torvalds .override = ti1250_override, 8571da177e4SLinus Torvalds .save_state = ti_save_state, 8581da177e4SLinus Torvalds .restore_state = ti_restore_state, 8591da177e4SLinus Torvalds .sock_init = ti_init, 8601da177e4SLinus Torvalds }, 86163e7ebd0SDaniel Ritz #endif 86263e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 8631da177e4SLinus Torvalds [CARDBUS_TYPE_RICOH] = { 8641da177e4SLinus Torvalds .override = ricoh_override, 8651da177e4SLinus Torvalds .save_state = ricoh_save_state, 8661da177e4SLinus Torvalds .restore_state = ricoh_restore_state, 8671da177e4SLinus Torvalds }, 86863e7ebd0SDaniel Ritz #endif 86963e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 870ea2f1590SDaniel Ritz [CARDBUS_TYPE_TOPIC95] = { 871ea2f1590SDaniel Ritz .override = topic95_override, 872ea2f1590SDaniel Ritz }, 8731da177e4SLinus Torvalds [CARDBUS_TYPE_TOPIC97] = { 8741da177e4SLinus Torvalds .override = topic97_override, 8751da177e4SLinus Torvalds }, 87663e7ebd0SDaniel Ritz #endif 87763e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 8781da177e4SLinus Torvalds [CARDBUS_TYPE_O2MICRO] = { 8791da177e4SLinus Torvalds .override = o2micro_override, 8801da177e4SLinus Torvalds .restore_state = o2micro_restore_state, 8811da177e4SLinus Torvalds }, 88263e7ebd0SDaniel Ritz #endif 88363e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 8848c3520d4SDaniel Ritz [CARDBUS_TYPE_ENE] = { 8858c3520d4SDaniel Ritz .override = ene_override, 8868c3520d4SDaniel Ritz .save_state = ti_save_state, 8878c3520d4SDaniel Ritz .restore_state = ti_restore_state, 8888c3520d4SDaniel Ritz .sock_init = ti_init, 8898c3520d4SDaniel Ritz }, 89063e7ebd0SDaniel Ritz #endif 8911da177e4SLinus Torvalds }; 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds 8941da177e4SLinus Torvalds /* 8951da177e4SLinus Torvalds * Only probe "regular" interrupts, don't 8961da177e4SLinus Torvalds * touch dangerous spots like the mouse irq, 8971da177e4SLinus Torvalds * because there are mice that apparently 8981da177e4SLinus Torvalds * get really confused if they get fondled 8991da177e4SLinus Torvalds * too intimately. 9001da177e4SLinus Torvalds * 9011da177e4SLinus Torvalds * Default to 11, 10, 9, 7, 6, 5, 4, 3. 9021da177e4SLinus Torvalds */ 9031da177e4SLinus Torvalds static u32 isa_interrupts = 0x0ef8; 9041da177e4SLinus Torvalds 9051da177e4SLinus Torvalds static unsigned int yenta_probe_irq(struct yenta_socket *socket, u32 isa_irq_mask) 9061da177e4SLinus Torvalds { 9071da177e4SLinus Torvalds int i; 9081da177e4SLinus Torvalds unsigned long val; 9091da177e4SLinus Torvalds u32 mask; 9101da177e4SLinus Torvalds 9111da177e4SLinus Torvalds /* 9121da177e4SLinus Torvalds * Probe for usable interrupts using the force 9131da177e4SLinus Torvalds * register to generate bogus card status events. 9141da177e4SLinus Torvalds */ 9151da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9161da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK); 9171da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 9181da177e4SLinus Torvalds val = probe_irq_on() & isa_irq_mask; 9191da177e4SLinus Torvalds for (i = 1; i < 16; i++) { 9201da177e4SLinus Torvalds if (!((val >> i) & 1)) 9211da177e4SLinus Torvalds continue; 9221da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG | (i << 4)); 9231da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS); 9241da177e4SLinus Torvalds udelay(100); 9251da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9261da177e4SLinus Torvalds } 9271da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0); 9281da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 9291da177e4SLinus Torvalds 9301da177e4SLinus Torvalds mask = probe_irq_mask(val) & 0xffff; 9311da177e4SLinus Torvalds 9321da177e4SLinus Torvalds return mask; 9331da177e4SLinus Torvalds } 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds 93678187865SRandy Dunlap /* 93763e7ebd0SDaniel Ritz * yenta PCI irq probing. 93863e7ebd0SDaniel Ritz * currently only used in the TI/EnE initialization code 93963e7ebd0SDaniel Ritz */ 94063e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 94163e7ebd0SDaniel Ritz 9421da177e4SLinus Torvalds /* interrupt handler, only used during probing */ 9437d12e780SDavid Howells static irqreturn_t yenta_probe_handler(int irq, void *dev_id) 9441da177e4SLinus Torvalds { 9451da177e4SLinus Torvalds struct yenta_socket *socket = (struct yenta_socket *) dev_id; 9461da177e4SLinus Torvalds u8 csc; 9471da177e4SLinus Torvalds u32 cb_event; 9481da177e4SLinus Torvalds 9491da177e4SLinus Torvalds /* Clear interrupt status for the event */ 9501da177e4SLinus Torvalds cb_event = cb_readl(socket, CB_SOCKET_EVENT); 9511da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9521da177e4SLinus Torvalds csc = exca_readb(socket, I365_CSC); 9531da177e4SLinus Torvalds 9541da177e4SLinus Torvalds if (cb_event || csc) { 9551da177e4SLinus Torvalds socket->probe_status = 1; 9561da177e4SLinus Torvalds return IRQ_HANDLED; 9571da177e4SLinus Torvalds } 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds return IRQ_NONE; 9601da177e4SLinus Torvalds } 9611da177e4SLinus Torvalds 9621da177e4SLinus Torvalds /* probes the PCI interrupt, use only on override functions */ 9631da177e4SLinus Torvalds static int yenta_probe_cb_irq(struct yenta_socket *socket) 9641da177e4SLinus Torvalds { 9651da177e4SLinus Torvalds if (!socket->cb_irq) 9661da177e4SLinus Torvalds return -1; 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds socket->probe_status = 0; 9691da177e4SLinus Torvalds 970dace1453SThomas Gleixner if (request_irq(socket->cb_irq, yenta_probe_handler, IRQF_SHARED, "yenta", socket)) { 971dd797d81SDominik Brodowski dev_printk(KERN_WARNING, &socket->dev->dev, 972dd797d81SDominik Brodowski "request_irq() in yenta_probe_cb_irq() failed!\n"); 9731da177e4SLinus Torvalds return -1; 9741da177e4SLinus Torvalds } 9751da177e4SLinus Torvalds 9761da177e4SLinus Torvalds /* generate interrupt, wait */ 9771da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG); 9781da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9791da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK); 9801da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS); 9811da177e4SLinus Torvalds 9821da177e4SLinus Torvalds msleep(100); 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds /* disable interrupts */ 9851da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0); 9861da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 9871da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 9881da177e4SLinus Torvalds exca_readb(socket, I365_CSC); 9891da177e4SLinus Torvalds 9901da177e4SLinus Torvalds free_irq(socket->cb_irq, socket); 9911da177e4SLinus Torvalds 9921da177e4SLinus Torvalds return (int) socket->probe_status; 9931da177e4SLinus Torvalds } 9941da177e4SLinus Torvalds 99563e7ebd0SDaniel Ritz #endif /* CONFIG_YENTA_TI */ 9961da177e4SLinus Torvalds 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds /* 9991da177e4SLinus Torvalds * Set static data that doesn't need re-initializing.. 10001da177e4SLinus Torvalds */ 10011da177e4SLinus Torvalds static void yenta_get_socket_capabilities(struct yenta_socket *socket, u32 isa_irq_mask) 10021da177e4SLinus Torvalds { 10031da177e4SLinus Torvalds socket->socket.pci_irq = socket->cb_irq; 1004fa912bcbSDaniel Ritz if (isa_probe) 10051da177e4SLinus Torvalds socket->socket.irq_mask = yenta_probe_irq(socket, isa_irq_mask); 1006fa912bcbSDaniel Ritz else 1007fa912bcbSDaniel Ritz socket->socket.irq_mask = 0; 10081da177e4SLinus Torvalds 1009dd797d81SDominik Brodowski dev_printk(KERN_INFO, &socket->dev->dev, 1010dd797d81SDominik Brodowski "ISA IRQ mask 0x%04x, PCI irq %d\n", 10111da177e4SLinus Torvalds socket->socket.irq_mask, socket->cb_irq); 10121da177e4SLinus Torvalds } 10131da177e4SLinus Torvalds 10141da177e4SLinus Torvalds /* 10151da177e4SLinus Torvalds * Initialize the standard cardbus registers 10161da177e4SLinus Torvalds */ 10171da177e4SLinus Torvalds static void yenta_config_init(struct yenta_socket *socket) 10181da177e4SLinus Torvalds { 10191da177e4SLinus Torvalds u16 bridge; 10201da177e4SLinus Torvalds struct pci_dev *dev = socket->dev; 10218e5d17ebSDominik Brodowski struct pci_bus_region region; 10221da177e4SLinus Torvalds 10238e5d17ebSDominik Brodowski pcibios_resource_to_bus(socket->dev, ®ion, &dev->resource[0]); 10241da177e4SLinus Torvalds 10251da177e4SLinus Torvalds config_writel(socket, CB_LEGACY_MODE_BASE, 0); 10268e5d17ebSDominik Brodowski config_writel(socket, PCI_BASE_ADDRESS_0, region.start); 10271da177e4SLinus Torvalds config_writew(socket, PCI_COMMAND, 10281da177e4SLinus Torvalds PCI_COMMAND_IO | 10291da177e4SLinus Torvalds PCI_COMMAND_MEMORY | 10301da177e4SLinus Torvalds PCI_COMMAND_MASTER | 10311da177e4SLinus Torvalds PCI_COMMAND_WAIT); 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds /* MAGIC NUMBERS! Fixme */ 10341da177e4SLinus Torvalds config_writeb(socket, PCI_CACHE_LINE_SIZE, L1_CACHE_BYTES / 4); 10351da177e4SLinus Torvalds config_writeb(socket, PCI_LATENCY_TIMER, 168); 10361da177e4SLinus Torvalds config_writel(socket, PCI_PRIMARY_BUS, 10371da177e4SLinus Torvalds (176 << 24) | /* sec. latency timer */ 10381da177e4SLinus Torvalds (dev->subordinate->subordinate << 16) | /* subordinate bus */ 10391da177e4SLinus Torvalds (dev->subordinate->secondary << 8) | /* secondary bus */ 10401da177e4SLinus Torvalds dev->subordinate->primary); /* primary bus */ 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds /* 10431da177e4SLinus Torvalds * Set up the bridging state: 10441da177e4SLinus Torvalds * - enable write posting. 10451da177e4SLinus Torvalds * - memory window 0 prefetchable, window 1 non-prefetchable 10461da177e4SLinus Torvalds * - PCI interrupts enabled if a PCI interrupt exists.. 10471da177e4SLinus Torvalds */ 10481da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL); 1049a413c090SDaniel Ritz bridge &= ~(CB_BRIDGE_CRST | CB_BRIDGE_PREFETCH1 | CB_BRIDGE_ISAEN | CB_BRIDGE_VGAEN); 1050a413c090SDaniel Ritz bridge |= CB_BRIDGE_PREFETCH0 | CB_BRIDGE_POSTEN; 10511da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds 1054b435261bSBernhard Kaindl /** 105566005216SRandy Dunlap * yenta_fixup_parent_bridge - Fix subordinate bus# of the parent bridge 1056b435261bSBernhard Kaindl * @cardbus_bridge: The PCI bus which the CardBus bridge bridges to 1057b435261bSBernhard Kaindl * 1058b435261bSBernhard Kaindl * Checks if devices on the bus which the CardBus bridge bridges to would be 1059b435261bSBernhard Kaindl * invisible during PCI scans because of a misconfigured subordinate number 1060b435261bSBernhard Kaindl * of the parent brige - some BIOSes seem to be too lazy to set it right. 1061b435261bSBernhard Kaindl * Does the fixup carefully by checking how far it can go without conflicts. 106278187865SRandy Dunlap * See http\://bugzilla.kernel.org/show_bug.cgi?id=2944 for more information. 1063b435261bSBernhard Kaindl */ 1064b435261bSBernhard Kaindl static void yenta_fixup_parent_bridge(struct pci_bus *cardbus_bridge) 1065b435261bSBernhard Kaindl { 1066b435261bSBernhard Kaindl struct list_head *tmp; 1067b435261bSBernhard Kaindl unsigned char upper_limit; 1068b435261bSBernhard Kaindl /* 1069b435261bSBernhard Kaindl * We only check and fix the parent bridge: All systems which need 1070b435261bSBernhard Kaindl * this fixup that have been reviewed are laptops and the only bridge 1071b435261bSBernhard Kaindl * which needed fixing was the parent bridge of the CardBus bridge: 1072b435261bSBernhard Kaindl */ 1073b435261bSBernhard Kaindl struct pci_bus *bridge_to_fix = cardbus_bridge->parent; 1074b435261bSBernhard Kaindl 1075b435261bSBernhard Kaindl /* Check bus numbers are already set up correctly: */ 1076b435261bSBernhard Kaindl if (bridge_to_fix->subordinate >= cardbus_bridge->subordinate) 1077b435261bSBernhard Kaindl return; /* The subordinate number is ok, nothing to do */ 1078b435261bSBernhard Kaindl 1079b435261bSBernhard Kaindl if (!bridge_to_fix->parent) 1080b435261bSBernhard Kaindl return; /* Root bridges are ok */ 1081b435261bSBernhard Kaindl 1082b435261bSBernhard Kaindl /* stay within the limits of the bus range of the parent: */ 1083b435261bSBernhard Kaindl upper_limit = bridge_to_fix->parent->subordinate; 1084b435261bSBernhard Kaindl 1085b435261bSBernhard Kaindl /* check the bus ranges of all silbling bridges to prevent overlap */ 1086b435261bSBernhard Kaindl list_for_each(tmp, &bridge_to_fix->parent->children) { 1087b435261bSBernhard Kaindl struct pci_bus *silbling = pci_bus_b(tmp); 1088b435261bSBernhard Kaindl /* 1089b435261bSBernhard Kaindl * If the silbling has a higher secondary bus number 1090b435261bSBernhard Kaindl * and it's secondary is equal or smaller than our 1091b435261bSBernhard Kaindl * current upper limit, set the new upper limit to 1092b435261bSBernhard Kaindl * the bus number below the silbling's range: 1093b435261bSBernhard Kaindl */ 1094b435261bSBernhard Kaindl if (silbling->secondary > bridge_to_fix->subordinate 1095b435261bSBernhard Kaindl && silbling->secondary <= upper_limit) 1096b435261bSBernhard Kaindl upper_limit = silbling->secondary - 1; 1097b435261bSBernhard Kaindl } 1098b435261bSBernhard Kaindl 1099b435261bSBernhard Kaindl /* Show that the wanted subordinate number is not possible: */ 1100b435261bSBernhard Kaindl if (cardbus_bridge->subordinate > upper_limit) 1101dd797d81SDominik Brodowski dev_printk(KERN_WARNING, &cardbus_bridge->dev, 1102dd797d81SDominik Brodowski "Upper limit for fixing this " 1103b435261bSBernhard Kaindl "bridge's parent bridge: #%02x\n", upper_limit); 1104b435261bSBernhard Kaindl 1105b435261bSBernhard Kaindl /* If we have room to increase the bridge's subordinate number, */ 1106b435261bSBernhard Kaindl if (bridge_to_fix->subordinate < upper_limit) { 1107b435261bSBernhard Kaindl 1108b435261bSBernhard Kaindl /* use the highest number of the hidden bus, within limits */ 1109b435261bSBernhard Kaindl unsigned char subordinate_to_assign = 1110b435261bSBernhard Kaindl min(cardbus_bridge->subordinate, upper_limit); 1111b435261bSBernhard Kaindl 1112dd797d81SDominik Brodowski dev_printk(KERN_INFO, &bridge_to_fix->dev, 1113dd797d81SDominik Brodowski "Raising subordinate bus# of parent " 1114b435261bSBernhard Kaindl "bus (#%02x) from #%02x to #%02x\n", 1115b435261bSBernhard Kaindl bridge_to_fix->number, 1116b435261bSBernhard Kaindl bridge_to_fix->subordinate, subordinate_to_assign); 1117b435261bSBernhard Kaindl 1118b435261bSBernhard Kaindl /* Save the new subordinate in the bus struct of the bridge */ 1119b435261bSBernhard Kaindl bridge_to_fix->subordinate = subordinate_to_assign; 1120b435261bSBernhard Kaindl 1121b435261bSBernhard Kaindl /* and update the PCI config space with the new subordinate */ 1122b435261bSBernhard Kaindl pci_write_config_byte(bridge_to_fix->self, 1123b435261bSBernhard Kaindl PCI_SUBORDINATE_BUS, bridge_to_fix->subordinate); 1124b435261bSBernhard Kaindl } 1125b435261bSBernhard Kaindl } 1126b435261bSBernhard Kaindl 11271da177e4SLinus Torvalds /* 11281da177e4SLinus Torvalds * Initialize a cardbus controller. Make sure we have a usable 11291da177e4SLinus Torvalds * interrupt, and that we can map the cardbus area. Fill in the 11301da177e4SLinus Torvalds * socket information structure.. 11311da177e4SLinus Torvalds */ 11321da177e4SLinus Torvalds static int __devinit yenta_probe(struct pci_dev *dev, const struct pci_device_id *id) 11331da177e4SLinus Torvalds { 11341da177e4SLinus Torvalds struct yenta_socket *socket; 11351da177e4SLinus Torvalds int ret; 11361da177e4SLinus Torvalds 1137c7fb0b35SIvan Kokshaysky /* 1138c7fb0b35SIvan Kokshaysky * If we failed to assign proper bus numbers for this cardbus 1139c7fb0b35SIvan Kokshaysky * controller during PCI probe, its subordinate pci_bus is NULL. 1140c7fb0b35SIvan Kokshaysky * Bail out if so. 1141c7fb0b35SIvan Kokshaysky */ 1142c7fb0b35SIvan Kokshaysky if (!dev->subordinate) { 1143dd797d81SDominik Brodowski dev_printk(KERN_ERR, &dev->dev, "no bus associated! " 1144dd797d81SDominik Brodowski "(try 'pci=assign-busses')\n"); 1145c7fb0b35SIvan Kokshaysky return -ENODEV; 1146c7fb0b35SIvan Kokshaysky } 1147c7fb0b35SIvan Kokshaysky 11488084b372SDominik Brodowski socket = kzalloc(sizeof(struct yenta_socket), GFP_KERNEL); 11491da177e4SLinus Torvalds if (!socket) 11501da177e4SLinus Torvalds return -ENOMEM; 11511da177e4SLinus Torvalds 11521da177e4SLinus Torvalds /* prepare pcmcia_socket */ 11531da177e4SLinus Torvalds socket->socket.ops = ¥ta_socket_operations; 11541da177e4SLinus Torvalds socket->socket.resource_ops = &pccard_nonstatic_ops; 115587373318SGreg Kroah-Hartman socket->socket.dev.parent = &dev->dev; 11561da177e4SLinus Torvalds socket->socket.driver_data = socket; 11571da177e4SLinus Torvalds socket->socket.owner = THIS_MODULE; 11585bc6b68aSRussell King socket->socket.features = SS_CAP_PAGE_REGS | SS_CAP_PCCARD; 11595bc6b68aSRussell King socket->socket.map_size = 0x1000; 11605bc6b68aSRussell King socket->socket.cb_dev = dev; 11611da177e4SLinus Torvalds 11621da177e4SLinus Torvalds /* prepare struct yenta_socket */ 11631da177e4SLinus Torvalds socket->dev = dev; 11641da177e4SLinus Torvalds pci_set_drvdata(dev, socket); 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds /* 11671da177e4SLinus Torvalds * Do some basic sanity checking.. 11681da177e4SLinus Torvalds */ 11691da177e4SLinus Torvalds if (pci_enable_device(dev)) { 11701da177e4SLinus Torvalds ret = -EBUSY; 11711da177e4SLinus Torvalds goto free; 11721da177e4SLinus Torvalds } 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds ret = pci_request_regions(dev, "yenta_socket"); 11751da177e4SLinus Torvalds if (ret) 11761da177e4SLinus Torvalds goto disable; 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds if (!pci_resource_start(dev, 0)) { 1179dd797d81SDominik Brodowski dev_printk(KERN_ERR, &dev->dev, "No cardbus resource!\n"); 11801da177e4SLinus Torvalds ret = -ENODEV; 11811da177e4SLinus Torvalds goto release; 11821da177e4SLinus Torvalds } 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds /* 11851da177e4SLinus Torvalds * Ok, start setup.. Map the cardbus registers, 11861da177e4SLinus Torvalds * and request the IRQ. 11871da177e4SLinus Torvalds */ 11881da177e4SLinus Torvalds socket->base = ioremap(pci_resource_start(dev, 0), 0x1000); 11891da177e4SLinus Torvalds if (!socket->base) { 11901da177e4SLinus Torvalds ret = -ENOMEM; 11911da177e4SLinus Torvalds goto release; 11921da177e4SLinus Torvalds } 11931da177e4SLinus Torvalds 11941da177e4SLinus Torvalds /* 11951da177e4SLinus Torvalds * report the subsystem vendor and device for help debugging 11961da177e4SLinus Torvalds * the irq stuff... 11971da177e4SLinus Torvalds */ 1198dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, "CardBus bridge found [%04x:%04x]\n", 1199dd797d81SDominik Brodowski dev->subsystem_vendor, dev->subsystem_device); 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds yenta_config_init(socket); 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds /* Disable all events */ 12041da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0x0); 12051da177e4SLinus Torvalds 12061da177e4SLinus Torvalds /* Set up the bridge regions.. */ 12071da177e4SLinus Torvalds yenta_allocate_resources(socket); 12081da177e4SLinus Torvalds 12091da177e4SLinus Torvalds socket->cb_irq = dev->irq; 12101da177e4SLinus Torvalds 12111da177e4SLinus Torvalds /* Do we have special options for the device? */ 12121da177e4SLinus Torvalds if (id->driver_data != CARDBUS_TYPE_DEFAULT && 12131da177e4SLinus Torvalds id->driver_data < ARRAY_SIZE(cardbus_type)) { 12141da177e4SLinus Torvalds socket->type = &cardbus_type[id->driver_data]; 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds ret = socket->type->override(socket); 12171da177e4SLinus Torvalds if (ret < 0) 12181da177e4SLinus Torvalds goto unmap; 12191da177e4SLinus Torvalds } 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds /* We must finish initialization here */ 12221da177e4SLinus Torvalds 1223dace1453SThomas Gleixner if (!socket->cb_irq || request_irq(socket->cb_irq, yenta_interrupt, IRQF_SHARED, "yenta", socket)) { 12241da177e4SLinus Torvalds /* No IRQ or request_irq failed. Poll */ 12251da177e4SLinus Torvalds socket->cb_irq = 0; /* But zero is a valid IRQ number. */ 12261da177e4SLinus Torvalds init_timer(&socket->poll_timer); 12271da177e4SLinus Torvalds socket->poll_timer.function = yenta_interrupt_wrapper; 12281da177e4SLinus Torvalds socket->poll_timer.data = (unsigned long)socket; 12291da177e4SLinus Torvalds socket->poll_timer.expires = jiffies + HZ; 12301da177e4SLinus Torvalds add_timer(&socket->poll_timer); 1231dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1232dd797d81SDominik Brodowski "no PCI IRQ, CardBus support disabled for this " 1233dd797d81SDominik Brodowski "socket.\n"); 1234dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1235dd797d81SDominik Brodowski "check your BIOS CardBus, BIOS IRQ or ACPI " 1236dd797d81SDominik Brodowski "settings.\n"); 12375bc6b68aSRussell King } else { 12385bc6b68aSRussell King socket->socket.features |= SS_CAP_CARDBUS; 12391da177e4SLinus Torvalds } 12401da177e4SLinus Torvalds 12411da177e4SLinus Torvalds /* Figure out what the dang thing can do for the PCMCIA layer... */ 1242fa912bcbSDaniel Ritz yenta_interrogate(socket); 12431da177e4SLinus Torvalds yenta_get_socket_capabilities(socket, isa_interrupts); 1244dd797d81SDominik Brodowski dev_printk(KERN_INFO, &dev->dev, 1245dd797d81SDominik Brodowski "Socket status: %08x\n", cb_readl(socket, CB_SOCKET_STATE)); 12461da177e4SLinus Torvalds 1247b435261bSBernhard Kaindl yenta_fixup_parent_bridge(dev->subordinate); 1248b435261bSBernhard Kaindl 12491da177e4SLinus Torvalds /* Register it with the pcmcia layer.. */ 12501da177e4SLinus Torvalds ret = pcmcia_register_socket(&socket->socket); 1251030ee39cSLinus Torvalds if (ret == 0) { 1252030ee39cSLinus Torvalds /* Add the yenta register attributes */ 12534deb7c1eSJeff Garzik ret = device_create_file(&dev->dev, &dev_attr_yenta_registers); 12544deb7c1eSJeff Garzik if (ret == 0) 12551da177e4SLinus Torvalds goto out; 12564deb7c1eSJeff Garzik 12574deb7c1eSJeff Garzik /* error path... */ 12584deb7c1eSJeff Garzik pcmcia_unregister_socket(&socket->socket); 1259030ee39cSLinus Torvalds } 12601da177e4SLinus Torvalds 12611da177e4SLinus Torvalds unmap: 12621da177e4SLinus Torvalds iounmap(socket->base); 12631da177e4SLinus Torvalds release: 12641da177e4SLinus Torvalds pci_release_regions(dev); 12651da177e4SLinus Torvalds disable: 12661da177e4SLinus Torvalds pci_disable_device(dev); 12671da177e4SLinus Torvalds free: 12681da177e4SLinus Torvalds kfree(socket); 12691da177e4SLinus Torvalds out: 12701da177e4SLinus Torvalds return ret; 12711da177e4SLinus Torvalds } 12721da177e4SLinus Torvalds 1273f237de58SAlexey Dobriyan #ifdef CONFIG_PM 12740c570cdeSRafael J. Wysocki static int yenta_dev_suspend_noirq(struct device *dev) 12751da177e4SLinus Torvalds { 12760c570cdeSRafael J. Wysocki struct pci_dev *pdev = to_pci_dev(dev); 12770c570cdeSRafael J. Wysocki struct yenta_socket *socket = pci_get_drvdata(pdev); 12781da177e4SLinus Torvalds int ret; 12791da177e4SLinus Torvalds 12800c570cdeSRafael J. Wysocki ret = pcmcia_socket_dev_suspend(dev); 12811da177e4SLinus Torvalds 12820c570cdeSRafael J. Wysocki if (!socket) 12830c570cdeSRafael J. Wysocki return ret; 12840c570cdeSRafael J. Wysocki 12851da177e4SLinus Torvalds if (socket->type && socket->type->save_state) 12861da177e4SLinus Torvalds socket->type->save_state(socket); 12871da177e4SLinus Torvalds 12880c570cdeSRafael J. Wysocki pci_save_state(pdev); 12890c570cdeSRafael J. Wysocki pci_read_config_dword(pdev, 16*4, &socket->saved_state[0]); 12900c570cdeSRafael J. Wysocki pci_read_config_dword(pdev, 17*4, &socket->saved_state[1]); 12910c570cdeSRafael J. Wysocki pci_disable_device(pdev); 12921da177e4SLinus Torvalds 12931da177e4SLinus Torvalds /* 12941da177e4SLinus Torvalds * Some laptops (IBM T22) do not like us putting the Cardbus 12951da177e4SLinus Torvalds * bridge into D3. At a guess, some other laptop will 12961da177e4SLinus Torvalds * probably require this, so leave it commented out for now. 12971da177e4SLinus Torvalds */ 12981da177e4SLinus Torvalds /* pci_set_power_state(dev, 3); */ 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds return ret; 13011da177e4SLinus Torvalds } 13021da177e4SLinus Torvalds 13030c570cdeSRafael J. Wysocki static int yenta_dev_resume_noirq(struct device *dev) 13041da177e4SLinus Torvalds { 13050c570cdeSRafael J. Wysocki struct pci_dev *pdev = to_pci_dev(dev); 13060c570cdeSRafael J. Wysocki struct yenta_socket *socket = pci_get_drvdata(pdev); 13070c570cdeSRafael J. Wysocki int ret; 13081da177e4SLinus Torvalds 13090c570cdeSRafael J. Wysocki if (!socket) 13100c570cdeSRafael J. Wysocki return 0; 13114deb7c1eSJeff Garzik 13120c570cdeSRafael J. Wysocki pci_write_config_dword(pdev, 16*4, socket->saved_state[0]); 13130c570cdeSRafael J. Wysocki pci_write_config_dword(pdev, 17*4, socket->saved_state[1]); 13144deb7c1eSJeff Garzik 13150c570cdeSRafael J. Wysocki ret = pci_enable_device(pdev); 13160c570cdeSRafael J. Wysocki if (ret) 13170c570cdeSRafael J. Wysocki return ret; 13184deb7c1eSJeff Garzik 13190c570cdeSRafael J. Wysocki pci_set_master(pdev); 13201da177e4SLinus Torvalds 13211da177e4SLinus Torvalds if (socket->type && socket->type->restore_state) 13221da177e4SLinus Torvalds socket->type->restore_state(socket); 13230c570cdeSRafael J. Wysocki 13249905d1b4SRafael J. Wysocki pcmcia_socket_dev_early_resume(dev); 13259905d1b4SRafael J. Wysocki return 0; 13269905d1b4SRafael J. Wysocki } 13279905d1b4SRafael J. Wysocki 13289905d1b4SRafael J. Wysocki static int yenta_dev_resume(struct device *dev) 13299905d1b4SRafael J. Wysocki { 13309905d1b4SRafael J. Wysocki pcmcia_socket_dev_late_resume(dev); 13319905d1b4SRafael J. Wysocki return 0; 13321da177e4SLinus Torvalds } 13331da177e4SLinus Torvalds 133447145210SAlexey Dobriyan static const struct dev_pm_ops yenta_pm_ops = { 13350c570cdeSRafael J. Wysocki .suspend_noirq = yenta_dev_suspend_noirq, 13360c570cdeSRafael J. Wysocki .resume_noirq = yenta_dev_resume_noirq, 13379905d1b4SRafael J. Wysocki .resume = yenta_dev_resume, 13380c570cdeSRafael J. Wysocki .freeze_noirq = yenta_dev_suspend_noirq, 13390c570cdeSRafael J. Wysocki .thaw_noirq = yenta_dev_resume_noirq, 13409905d1b4SRafael J. Wysocki .thaw = yenta_dev_resume, 13410c570cdeSRafael J. Wysocki .poweroff_noirq = yenta_dev_suspend_noirq, 13420c570cdeSRafael J. Wysocki .restore_noirq = yenta_dev_resume_noirq, 13439905d1b4SRafael J. Wysocki .restore = yenta_dev_resume, 13440c570cdeSRafael J. Wysocki }; 13450c570cdeSRafael J. Wysocki 13460c570cdeSRafael J. Wysocki #define YENTA_PM_OPS (¥ta_pm_ops) 13470c570cdeSRafael J. Wysocki #else 13480c570cdeSRafael J. Wysocki #define YENTA_PM_OPS NULL 1349f237de58SAlexey Dobriyan #endif 13501da177e4SLinus Torvalds 13511da177e4SLinus Torvalds #define CB_ID(vend, dev, type) \ 13521da177e4SLinus Torvalds { \ 13531da177e4SLinus Torvalds .vendor = vend, \ 13541da177e4SLinus Torvalds .device = dev, \ 13551da177e4SLinus Torvalds .subvendor = PCI_ANY_ID, \ 13561da177e4SLinus Torvalds .subdevice = PCI_ANY_ID, \ 13571da177e4SLinus Torvalds .class = PCI_CLASS_BRIDGE_CARDBUS << 8, \ 13581da177e4SLinus Torvalds .class_mask = ~0, \ 13591da177e4SLinus Torvalds .driver_data = CARDBUS_TYPE_##type, \ 13601da177e4SLinus Torvalds } 13611da177e4SLinus Torvalds 13621da177e4SLinus Torvalds static struct pci_device_id yenta_table[] = { 13631da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1031, TI), 13641da177e4SLinus Torvalds 13651da177e4SLinus Torvalds /* 13661da177e4SLinus Torvalds * TBD: Check if these TI variants can use more 13671da177e4SLinus Torvalds * advanced overrides instead. (I can't get the 13681da177e4SLinus Torvalds * data sheets for these devices. --rmk) 13691da177e4SLinus Torvalds */ 137063e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TI 13711da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1210, TI), 13721da177e4SLinus Torvalds 13731da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1130, TI113X), 13741da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1131, TI113X), 13751da177e4SLinus Torvalds 13761da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1211, TI12XX), 13771da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1220, TI12XX), 13781da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1221, TI12XX), 13791da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1225, TI12XX), 13801da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251A, TI12XX), 13811da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251B, TI12XX), 13821da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1420, TI12XX), 13831da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1450, TI12XX), 13841da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1451A, TI12XX), 13851da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1510, TI12XX), 13861da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1520, TI12XX), 13871da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1620, TI12XX), 13881da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4410, TI12XX), 13891da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4450, TI12XX), 13901da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4451, TI12XX), 13911da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4510, TI12XX), 13921da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4520, TI12XX), 13931da177e4SLinus Torvalds 13941da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1250, TI1250), 13951da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1410, TI1250), 13961da177e4SLinus Torvalds 13976c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX21_XX11, TI12XX), 13986c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X515, TI12XX), 139959e35ba1SAlex Williamson CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_XX12, TI12XX), 14006c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X420, TI12XX), 14016c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_X620, TI12XX), 14026c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7410, TI12XX), 14036c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7510, TI12XX), 14046c1a10dbSDaniel Ritz CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_7610, TI12XX), 14056c1a10dbSDaniel Ritz 1406f9cb8b71SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_710, TI12XX), 1407f9cb8b71SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_712, TI12XX), 1408f9cb8b71SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_720, TI12XX), 1409f9cb8b71SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_722, TI12XX), 14108c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1211, ENE), 14118c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1225, ENE), 14128c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1410, ENE), 14138c3520d4SDaniel Ritz CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1420, ENE), 141463e7ebd0SDaniel Ritz #endif /* CONFIG_YENTA_TI */ 14151da177e4SLinus Torvalds 141663e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_RICOH 14171da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C465, RICOH), 14181da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C466, RICOH), 14191da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C475, RICOH), 14201da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, RICOH), 14211da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C478, RICOH), 142263e7ebd0SDaniel Ritz #endif 14231da177e4SLinus Torvalds 142463e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_TOSHIBA 1425ea2f1590SDaniel Ritz CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC95, TOPIC95), 14261da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC97, TOPIC97), 14271da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC100, TOPIC97), 142863e7ebd0SDaniel Ritz #endif 14291da177e4SLinus Torvalds 143063e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_O2 14311da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_O2, PCI_ANY_ID, O2MICRO), 143263e7ebd0SDaniel Ritz #endif 14331da177e4SLinus Torvalds 14341da177e4SLinus Torvalds /* match any cardbus bridge */ 14351da177e4SLinus Torvalds CB_ID(PCI_ANY_ID, PCI_ANY_ID, DEFAULT), 14361da177e4SLinus Torvalds { /* all zeroes */ } 14371da177e4SLinus Torvalds }; 14381da177e4SLinus Torvalds MODULE_DEVICE_TABLE(pci, yenta_table); 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds 14411da177e4SLinus Torvalds static struct pci_driver yenta_cardbus_driver = { 14421da177e4SLinus Torvalds .name = "yenta_cardbus", 14431da177e4SLinus Torvalds .id_table = yenta_table, 14441da177e4SLinus Torvalds .probe = yenta_probe, 14451da177e4SLinus Torvalds .remove = __devexit_p(yenta_close), 14460c570cdeSRafael J. Wysocki .driver.pm = YENTA_PM_OPS, 14471da177e4SLinus Torvalds }; 14481da177e4SLinus Torvalds 14491da177e4SLinus Torvalds 14501da177e4SLinus Torvalds static int __init yenta_socket_init(void) 14511da177e4SLinus Torvalds { 14521da177e4SLinus Torvalds return pci_register_driver(¥ta_cardbus_driver); 14531da177e4SLinus Torvalds } 14541da177e4SLinus Torvalds 14551da177e4SLinus Torvalds 14561da177e4SLinus Torvalds static void __exit yenta_socket_exit(void) 14571da177e4SLinus Torvalds { 14581da177e4SLinus Torvalds pci_unregister_driver(¥ta_cardbus_driver); 14591da177e4SLinus Torvalds } 14601da177e4SLinus Torvalds 14611da177e4SLinus Torvalds 14621da177e4SLinus Torvalds module_init(yenta_socket_init); 14631da177e4SLinus Torvalds module_exit(yenta_socket_exit); 14641da177e4SLinus Torvalds 14651da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 1466