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/sched.h> 161da177e4SLinus Torvalds #include <linux/workqueue.h> 171da177e4SLinus Torvalds #include <linux/interrupt.h> 181da177e4SLinus Torvalds #include <linux/delay.h> 191da177e4SLinus Torvalds #include <linux/module.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 <asm/io.h> 261da177e4SLinus Torvalds 271da177e4SLinus Torvalds #include "yenta_socket.h" 281da177e4SLinus Torvalds #include "i82365.h" 291da177e4SLinus Torvalds 301da177e4SLinus Torvalds static int disable_clkrun; 311da177e4SLinus Torvalds module_param(disable_clkrun, bool, 0444); 321da177e4SLinus Torvalds MODULE_PARM_DESC(disable_clkrun, "If PC card doesn't function properly, please try this option"); 331da177e4SLinus Torvalds 34fa912bcbSDaniel Ritz static int isa_probe = 1; 35fa912bcbSDaniel Ritz module_param(isa_probe, bool, 0444); 36fa912bcbSDaniel Ritz MODULE_PARM_DESC(isa_probe, "If set ISA interrupts are probed (default). Set to N to disable probing"); 37fa912bcbSDaniel Ritz 38fa912bcbSDaniel Ritz static int pwr_irqs_off; 39fa912bcbSDaniel Ritz module_param(pwr_irqs_off, bool, 0644); 40fa912bcbSDaniel Ritz MODULE_PARM_DESC(pwr_irqs_off, "Force IRQs off during power-on of slot. Use only when seeing IRQ storms!"); 41fa912bcbSDaniel Ritz 421da177e4SLinus Torvalds #if 0 431da177e4SLinus Torvalds #define debug(x,args...) printk(KERN_DEBUG "%s: " x, __func__ , ##args) 441da177e4SLinus Torvalds #else 451da177e4SLinus Torvalds #define debug(x,args...) 461da177e4SLinus Torvalds #endif 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds /* Don't ask.. */ 491da177e4SLinus Torvalds #define to_cycles(ns) ((ns)/120) 501da177e4SLinus Torvalds #define to_ns(cycles) ((cycles)*120) 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds static int yenta_probe_cb_irq(struct yenta_socket *socket); 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); 671da177e4SLinus Torvalds debug("%p %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 { 731da177e4SLinus Torvalds debug("%p %04x %08x\n", socket, reg, val); 741da177e4SLinus Torvalds writel(val, socket->base + reg); 751da177e4SLinus Torvalds } 761da177e4SLinus Torvalds 771da177e4SLinus Torvalds static inline u8 config_readb(struct yenta_socket *socket, unsigned offset) 781da177e4SLinus Torvalds { 791da177e4SLinus Torvalds u8 val; 801da177e4SLinus Torvalds pci_read_config_byte(socket->dev, offset, &val); 811da177e4SLinus Torvalds debug("%p %04x %02x\n", socket, offset, val); 821da177e4SLinus Torvalds return val; 831da177e4SLinus Torvalds } 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds static inline u16 config_readw(struct yenta_socket *socket, unsigned offset) 861da177e4SLinus Torvalds { 871da177e4SLinus Torvalds u16 val; 881da177e4SLinus Torvalds pci_read_config_word(socket->dev, offset, &val); 891da177e4SLinus Torvalds debug("%p %04x %04x\n", socket, offset, val); 901da177e4SLinus Torvalds return val; 911da177e4SLinus Torvalds } 921da177e4SLinus Torvalds 931da177e4SLinus Torvalds static inline u32 config_readl(struct yenta_socket *socket, unsigned offset) 941da177e4SLinus Torvalds { 951da177e4SLinus Torvalds u32 val; 961da177e4SLinus Torvalds pci_read_config_dword(socket->dev, offset, &val); 971da177e4SLinus Torvalds debug("%p %04x %08x\n", socket, offset, val); 981da177e4SLinus Torvalds return val; 991da177e4SLinus Torvalds } 1001da177e4SLinus Torvalds 1011da177e4SLinus Torvalds static inline void config_writeb(struct yenta_socket *socket, unsigned offset, u8 val) 1021da177e4SLinus Torvalds { 1031da177e4SLinus Torvalds debug("%p %04x %02x\n", socket, offset, val); 1041da177e4SLinus Torvalds pci_write_config_byte(socket->dev, offset, val); 1051da177e4SLinus Torvalds } 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds static inline void config_writew(struct yenta_socket *socket, unsigned offset, u16 val) 1081da177e4SLinus Torvalds { 1091da177e4SLinus Torvalds debug("%p %04x %04x\n", socket, offset, val); 1101da177e4SLinus Torvalds pci_write_config_word(socket->dev, offset, val); 1111da177e4SLinus Torvalds } 1121da177e4SLinus Torvalds 1131da177e4SLinus Torvalds static inline void config_writel(struct yenta_socket *socket, unsigned offset, u32 val) 1141da177e4SLinus Torvalds { 1151da177e4SLinus Torvalds debug("%p %04x %08x\n", socket, offset, val); 1161da177e4SLinus Torvalds pci_write_config_dword(socket->dev, offset, val); 1171da177e4SLinus Torvalds } 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds static inline u8 exca_readb(struct yenta_socket *socket, unsigned reg) 1201da177e4SLinus Torvalds { 1211da177e4SLinus Torvalds u8 val = readb(socket->base + 0x800 + reg); 1221da177e4SLinus Torvalds debug("%p %04x %02x\n", socket, reg, val); 1231da177e4SLinus Torvalds return val; 1241da177e4SLinus Torvalds } 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds static inline u8 exca_readw(struct yenta_socket *socket, unsigned reg) 1271da177e4SLinus Torvalds { 1281da177e4SLinus Torvalds u16 val; 1291da177e4SLinus Torvalds val = readb(socket->base + 0x800 + reg); 1301da177e4SLinus Torvalds val |= readb(socket->base + 0x800 + reg + 1) << 8; 1311da177e4SLinus Torvalds debug("%p %04x %04x\n", socket, reg, val); 1321da177e4SLinus Torvalds return val; 1331da177e4SLinus Torvalds } 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds static inline void exca_writeb(struct yenta_socket *socket, unsigned reg, u8 val) 1361da177e4SLinus Torvalds { 1371da177e4SLinus Torvalds debug("%p %04x %02x\n", socket, reg, val); 1381da177e4SLinus Torvalds writeb(val, socket->base + 0x800 + reg); 1391da177e4SLinus Torvalds } 1401da177e4SLinus Torvalds 1411da177e4SLinus Torvalds static void exca_writew(struct yenta_socket *socket, unsigned reg, u16 val) 1421da177e4SLinus Torvalds { 1431da177e4SLinus Torvalds debug("%p %04x %04x\n", socket, reg, val); 1441da177e4SLinus Torvalds writeb(val, socket->base + 0x800 + reg); 1451da177e4SLinus Torvalds writeb(val >> 8, socket->base + 0x800 + reg + 1); 1461da177e4SLinus Torvalds } 1471da177e4SLinus Torvalds 1481da177e4SLinus Torvalds /* 1491da177e4SLinus Torvalds * Ugh, mixed-mode cardbus and 16-bit pccard state: things depend 1501da177e4SLinus Torvalds * on what kind of card is inserted.. 1511da177e4SLinus Torvalds */ 1521da177e4SLinus Torvalds static int yenta_get_status(struct pcmcia_socket *sock, unsigned int *value) 1531da177e4SLinus Torvalds { 1541da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 1551da177e4SLinus Torvalds unsigned int val; 1561da177e4SLinus Torvalds u32 state = cb_readl(socket, CB_SOCKET_STATE); 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds val = (state & CB_3VCARD) ? SS_3VCARD : 0; 1591da177e4SLinus Torvalds val |= (state & CB_XVCARD) ? SS_XVCARD : 0; 160fa912bcbSDaniel Ritz val |= (state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) ? 0 : SS_PENDING; 161fa912bcbSDaniel Ritz val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? SS_PENDING : 0; 162fa912bcbSDaniel Ritz 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds if (state & CB_CBCARD) { 1651da177e4SLinus Torvalds val |= SS_CARDBUS; 1661da177e4SLinus Torvalds val |= (state & CB_CARDSTS) ? SS_STSCHG : 0; 1671da177e4SLinus Torvalds val |= (state & (CB_CDETECT1 | CB_CDETECT2)) ? 0 : SS_DETECT; 1681da177e4SLinus Torvalds val |= (state & CB_PWRCYCLE) ? SS_POWERON | SS_READY : 0; 169fa912bcbSDaniel Ritz } else if (state & CB_16BITCARD) { 1701da177e4SLinus Torvalds u8 status = exca_readb(socket, I365_STATUS); 1711da177e4SLinus Torvalds val |= ((status & I365_CS_DETECT) == I365_CS_DETECT) ? SS_DETECT : 0; 1721da177e4SLinus Torvalds if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { 1731da177e4SLinus Torvalds val |= (status & I365_CS_STSCHG) ? 0 : SS_STSCHG; 1741da177e4SLinus Torvalds } else { 1751da177e4SLinus Torvalds val |= (status & I365_CS_BVD1) ? 0 : SS_BATDEAD; 1761da177e4SLinus Torvalds val |= (status & I365_CS_BVD2) ? 0 : SS_BATWARN; 1771da177e4SLinus Torvalds } 1781da177e4SLinus Torvalds val |= (status & I365_CS_WRPROT) ? SS_WRPROT : 0; 1791da177e4SLinus Torvalds val |= (status & I365_CS_READY) ? SS_READY : 0; 1801da177e4SLinus Torvalds val |= (status & I365_CS_POWERON) ? SS_POWERON : 0; 1811da177e4SLinus Torvalds } 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds *value = val; 1841da177e4SLinus Torvalds return 0; 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds static int yenta_Vcc_power(u32 control) 1881da177e4SLinus Torvalds { 1891da177e4SLinus Torvalds switch (control & CB_SC_VCC_MASK) { 1901da177e4SLinus Torvalds case CB_SC_VCC_5V: return 50; 1911da177e4SLinus Torvalds case CB_SC_VCC_3V: return 33; 1921da177e4SLinus Torvalds default: return 0; 1931da177e4SLinus Torvalds } 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds static int yenta_Vpp_power(u32 control) 1971da177e4SLinus Torvalds { 1981da177e4SLinus Torvalds switch (control & CB_SC_VPP_MASK) { 1991da177e4SLinus Torvalds case CB_SC_VPP_12V: return 120; 2001da177e4SLinus Torvalds case CB_SC_VPP_5V: return 50; 2011da177e4SLinus Torvalds case CB_SC_VPP_3V: return 33; 2021da177e4SLinus Torvalds default: return 0; 2031da177e4SLinus Torvalds } 2041da177e4SLinus Torvalds } 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds static int yenta_get_socket(struct pcmcia_socket *sock, socket_state_t *state) 2071da177e4SLinus Torvalds { 2081da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 2091da177e4SLinus Torvalds u8 reg; 2101da177e4SLinus Torvalds u32 control; 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds control = cb_readl(socket, CB_SOCKET_CONTROL); 2131da177e4SLinus Torvalds 2141da177e4SLinus Torvalds state->Vcc = yenta_Vcc_power(control); 2151da177e4SLinus Torvalds state->Vpp = yenta_Vpp_power(control); 2161da177e4SLinus Torvalds state->io_irq = socket->io_irq; 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds if (cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) { 2191da177e4SLinus Torvalds u16 bridge = config_readw(socket, CB_BRIDGE_CONTROL); 2201da177e4SLinus Torvalds if (bridge & CB_BRIDGE_CRST) 2211da177e4SLinus Torvalds state->flags |= SS_RESET; 2221da177e4SLinus Torvalds return 0; 2231da177e4SLinus Torvalds } 2241da177e4SLinus Torvalds 2251da177e4SLinus Torvalds /* 16-bit card state.. */ 2261da177e4SLinus Torvalds reg = exca_readb(socket, I365_POWER); 2271da177e4SLinus Torvalds state->flags = (reg & I365_PWR_AUTO) ? SS_PWR_AUTO : 0; 2281da177e4SLinus Torvalds state->flags |= (reg & I365_PWR_OUT) ? SS_OUTPUT_ENA : 0; 2291da177e4SLinus Torvalds 2301da177e4SLinus Torvalds reg = exca_readb(socket, I365_INTCTL); 2311da177e4SLinus Torvalds state->flags |= (reg & I365_PC_RESET) ? 0 : SS_RESET; 2321da177e4SLinus Torvalds state->flags |= (reg & I365_PC_IOCARD) ? SS_IOCARD : 0; 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds reg = exca_readb(socket, I365_CSCINT); 2351da177e4SLinus Torvalds state->csc_mask = (reg & I365_CSC_DETECT) ? SS_DETECT : 0; 2361da177e4SLinus Torvalds if (state->flags & SS_IOCARD) { 2371da177e4SLinus Torvalds state->csc_mask |= (reg & I365_CSC_STSCHG) ? SS_STSCHG : 0; 2381da177e4SLinus Torvalds } else { 2391da177e4SLinus Torvalds state->csc_mask |= (reg & I365_CSC_BVD1) ? SS_BATDEAD : 0; 2401da177e4SLinus Torvalds state->csc_mask |= (reg & I365_CSC_BVD2) ? SS_BATWARN : 0; 2411da177e4SLinus Torvalds state->csc_mask |= (reg & I365_CSC_READY) ? SS_READY : 0; 2421da177e4SLinus Torvalds } 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds return 0; 2451da177e4SLinus Torvalds } 2461da177e4SLinus Torvalds 2471da177e4SLinus Torvalds static void yenta_set_power(struct yenta_socket *socket, socket_state_t *state) 2481da177e4SLinus Torvalds { 2491da177e4SLinus Torvalds u32 reg = 0; /* CB_SC_STPCLK? */ 2501da177e4SLinus Torvalds switch (state->Vcc) { 2511da177e4SLinus Torvalds case 33: reg = CB_SC_VCC_3V; break; 2521da177e4SLinus Torvalds case 50: reg = CB_SC_VCC_5V; break; 2531da177e4SLinus Torvalds default: reg = 0; break; 2541da177e4SLinus Torvalds } 2551da177e4SLinus Torvalds switch (state->Vpp) { 2561da177e4SLinus Torvalds case 33: reg |= CB_SC_VPP_3V; break; 2571da177e4SLinus Torvalds case 50: reg |= CB_SC_VPP_5V; break; 2581da177e4SLinus Torvalds case 120: reg |= CB_SC_VPP_12V; break; 2591da177e4SLinus Torvalds } 2601da177e4SLinus Torvalds if (reg != cb_readl(socket, CB_SOCKET_CONTROL)) 2611da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_CONTROL, reg); 2621da177e4SLinus Torvalds } 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds static int yenta_set_socket(struct pcmcia_socket *sock, socket_state_t *state) 2651da177e4SLinus Torvalds { 2661da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 2671da177e4SLinus Torvalds u16 bridge; 2681da177e4SLinus Torvalds 2691da177e4SLinus Torvalds yenta_set_power(socket, state); 2701da177e4SLinus Torvalds socket->io_irq = state->io_irq; 2711da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL) & ~(CB_BRIDGE_CRST | CB_BRIDGE_INTR); 2721da177e4SLinus Torvalds if (cb_readl(socket, CB_SOCKET_STATE) & CB_CBCARD) { 2731da177e4SLinus Torvalds u8 intr; 2741da177e4SLinus Torvalds bridge |= (state->flags & SS_RESET) ? CB_BRIDGE_CRST : 0; 2751da177e4SLinus Torvalds 2761da177e4SLinus Torvalds /* ISA interrupt control? */ 2771da177e4SLinus Torvalds intr = exca_readb(socket, I365_INTCTL); 2781da177e4SLinus Torvalds intr = (intr & ~0xf); 2791da177e4SLinus Torvalds if (!socket->cb_irq) { 2801da177e4SLinus Torvalds intr |= state->io_irq; 2811da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 2821da177e4SLinus Torvalds } 2831da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, intr); 2841da177e4SLinus Torvalds } else { 2851da177e4SLinus Torvalds u8 reg; 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds reg = exca_readb(socket, I365_INTCTL) & (I365_RING_ENA | I365_INTR_ENA); 2881da177e4SLinus Torvalds reg |= (state->flags & SS_RESET) ? 0 : I365_PC_RESET; 2891da177e4SLinus Torvalds reg |= (state->flags & SS_IOCARD) ? I365_PC_IOCARD : 0; 2901da177e4SLinus Torvalds if (state->io_irq != socket->cb_irq) { 2911da177e4SLinus Torvalds reg |= state->io_irq; 2921da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, reg); 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds reg = exca_readb(socket, I365_POWER) & (I365_VCC_MASK|I365_VPP1_MASK); 2971da177e4SLinus Torvalds reg |= I365_PWR_NORESET; 2981da177e4SLinus Torvalds if (state->flags & SS_PWR_AUTO) reg |= I365_PWR_AUTO; 2991da177e4SLinus Torvalds if (state->flags & SS_OUTPUT_ENA) reg |= I365_PWR_OUT; 3001da177e4SLinus Torvalds if (exca_readb(socket, I365_POWER) != reg) 3011da177e4SLinus Torvalds exca_writeb(socket, I365_POWER, reg); 3021da177e4SLinus Torvalds 3031da177e4SLinus Torvalds /* CSC interrupt: no ISA irq for CSC */ 3041da177e4SLinus Torvalds reg = I365_CSC_DETECT; 3051da177e4SLinus Torvalds if (state->flags & SS_IOCARD) { 3061da177e4SLinus Torvalds if (state->csc_mask & SS_STSCHG) reg |= I365_CSC_STSCHG; 3071da177e4SLinus Torvalds } else { 3081da177e4SLinus Torvalds if (state->csc_mask & SS_BATDEAD) reg |= I365_CSC_BVD1; 3091da177e4SLinus Torvalds if (state->csc_mask & SS_BATWARN) reg |= I365_CSC_BVD2; 3101da177e4SLinus Torvalds if (state->csc_mask & SS_READY) reg |= I365_CSC_READY; 3111da177e4SLinus Torvalds } 3121da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, reg); 3131da177e4SLinus Torvalds exca_readb(socket, I365_CSC); 3141da177e4SLinus Torvalds if(sock->zoom_video) 3151da177e4SLinus Torvalds sock->zoom_video(sock, state->flags & SS_ZVCARD); 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 3181da177e4SLinus Torvalds /* Socket event mask: get card insert/remove events.. */ 3191da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 3201da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK); 3211da177e4SLinus Torvalds return 0; 3221da177e4SLinus Torvalds } 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds static int yenta_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io) 3251da177e4SLinus Torvalds { 3261da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 3271da177e4SLinus Torvalds int map; 3281da177e4SLinus Torvalds unsigned char ioctl, addr, enable; 3291da177e4SLinus Torvalds 3301da177e4SLinus Torvalds map = io->map; 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds if (map > 1) 3331da177e4SLinus Torvalds return -EINVAL; 3341da177e4SLinus Torvalds 3351da177e4SLinus Torvalds enable = I365_ENA_IO(map); 3361da177e4SLinus Torvalds addr = exca_readb(socket, I365_ADDRWIN); 3371da177e4SLinus Torvalds 3381da177e4SLinus Torvalds /* Disable the window before changing it.. */ 3391da177e4SLinus Torvalds if (addr & enable) { 3401da177e4SLinus Torvalds addr &= ~enable; 3411da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr); 3421da177e4SLinus Torvalds } 3431da177e4SLinus Torvalds 3441da177e4SLinus Torvalds exca_writew(socket, I365_IO(map)+I365_W_START, io->start); 3451da177e4SLinus Torvalds exca_writew(socket, I365_IO(map)+I365_W_STOP, io->stop); 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds ioctl = exca_readb(socket, I365_IOCTL) & ~I365_IOCTL_MASK(map); 3481da177e4SLinus Torvalds if (io->flags & MAP_0WS) ioctl |= I365_IOCTL_0WS(map); 3491da177e4SLinus Torvalds if (io->flags & MAP_16BIT) ioctl |= I365_IOCTL_16BIT(map); 3501da177e4SLinus Torvalds if (io->flags & MAP_AUTOSZ) ioctl |= I365_IOCTL_IOCS16(map); 3511da177e4SLinus Torvalds exca_writeb(socket, I365_IOCTL, ioctl); 3521da177e4SLinus Torvalds 3531da177e4SLinus Torvalds if (io->flags & MAP_ACTIVE) 3541da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr | enable); 3551da177e4SLinus Torvalds return 0; 3561da177e4SLinus Torvalds } 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds static int yenta_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem) 3591da177e4SLinus Torvalds { 3601da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 3611da177e4SLinus Torvalds struct pci_bus_region region; 3621da177e4SLinus Torvalds int map; 3631da177e4SLinus Torvalds unsigned char addr, enable; 3641da177e4SLinus Torvalds unsigned int start, stop, card_start; 3651da177e4SLinus Torvalds unsigned short word; 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds pcibios_resource_to_bus(socket->dev, ®ion, mem->res); 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds map = mem->map; 3701da177e4SLinus Torvalds start = region.start; 3711da177e4SLinus Torvalds stop = region.end; 3721da177e4SLinus Torvalds card_start = mem->card_start; 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds if (map > 4 || start > stop || ((start ^ stop) >> 24) || 3751da177e4SLinus Torvalds (card_start >> 26) || mem->speed > 1000) 3761da177e4SLinus Torvalds return -EINVAL; 3771da177e4SLinus Torvalds 3781da177e4SLinus Torvalds enable = I365_ENA_MEM(map); 3791da177e4SLinus Torvalds addr = exca_readb(socket, I365_ADDRWIN); 3801da177e4SLinus Torvalds if (addr & enable) { 3811da177e4SLinus Torvalds addr &= ~enable; 3821da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr); 3831da177e4SLinus Torvalds } 3841da177e4SLinus Torvalds 3851da177e4SLinus Torvalds exca_writeb(socket, CB_MEM_PAGE(map), start >> 24); 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds word = (start >> 12) & 0x0fff; 3881da177e4SLinus Torvalds if (mem->flags & MAP_16BIT) 3891da177e4SLinus Torvalds word |= I365_MEM_16BIT; 3901da177e4SLinus Torvalds if (mem->flags & MAP_0WS) 3911da177e4SLinus Torvalds word |= I365_MEM_0WS; 3921da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_START, word); 3931da177e4SLinus Torvalds 3941da177e4SLinus Torvalds word = (stop >> 12) & 0x0fff; 3951da177e4SLinus Torvalds switch (to_cycles(mem->speed)) { 3961da177e4SLinus Torvalds case 0: break; 3971da177e4SLinus Torvalds case 1: word |= I365_MEM_WS0; break; 3981da177e4SLinus Torvalds case 2: word |= I365_MEM_WS1; break; 3991da177e4SLinus Torvalds default: word |= I365_MEM_WS1 | I365_MEM_WS0; break; 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_STOP, word); 4021da177e4SLinus Torvalds 4031da177e4SLinus Torvalds word = ((card_start - start) >> 12) & 0x3fff; 4041da177e4SLinus Torvalds if (mem->flags & MAP_WRPROT) 4051da177e4SLinus Torvalds word |= I365_MEM_WRPROT; 4061da177e4SLinus Torvalds if (mem->flags & MAP_ATTRIB) 4071da177e4SLinus Torvalds word |= I365_MEM_REG; 4081da177e4SLinus Torvalds exca_writew(socket, I365_MEM(map) + I365_W_OFF, word); 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds if (mem->flags & MAP_ACTIVE) 4111da177e4SLinus Torvalds exca_writeb(socket, I365_ADDRWIN, addr | enable); 4121da177e4SLinus Torvalds return 0; 4131da177e4SLinus Torvalds } 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds 416fa912bcbSDaniel Ritz 417fa912bcbSDaniel Ritz static irqreturn_t yenta_interrupt(int irq, void *dev_id, struct pt_regs *regs) 4181da177e4SLinus Torvalds { 419fa912bcbSDaniel Ritz unsigned int events; 420fa912bcbSDaniel Ritz struct yenta_socket *socket = (struct yenta_socket *) dev_id; 4211da177e4SLinus Torvalds u8 csc; 4221da177e4SLinus Torvalds u32 cb_event; 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds /* Clear interrupt status for the event */ 4251da177e4SLinus Torvalds cb_event = cb_readl(socket, CB_SOCKET_EVENT); 4261da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, cb_event); 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds csc = exca_readb(socket, I365_CSC); 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds events = (cb_event & (CB_CD1EVENT | CB_CD2EVENT)) ? SS_DETECT : 0 ; 4311da177e4SLinus Torvalds events |= (csc & I365_CSC_DETECT) ? SS_DETECT : 0; 4321da177e4SLinus Torvalds if (exca_readb(socket, I365_INTCTL) & I365_PC_IOCARD) { 4331da177e4SLinus Torvalds events |= (csc & I365_CSC_STSCHG) ? SS_STSCHG : 0; 4341da177e4SLinus Torvalds } else { 4351da177e4SLinus Torvalds events |= (csc & I365_CSC_BVD1) ? SS_BATDEAD : 0; 4361da177e4SLinus Torvalds events |= (csc & I365_CSC_BVD2) ? SS_BATWARN : 0; 4371da177e4SLinus Torvalds events |= (csc & I365_CSC_READY) ? SS_READY : 0; 4381da177e4SLinus Torvalds } 4391da177e4SLinus Torvalds 440fa912bcbSDaniel Ritz if (events) 4411da177e4SLinus Torvalds pcmcia_parse_events(&socket->socket, events); 442fa912bcbSDaniel Ritz 443fa912bcbSDaniel Ritz if (cb_event || csc) 4441da177e4SLinus Torvalds return IRQ_HANDLED; 445fa912bcbSDaniel Ritz 4461da177e4SLinus Torvalds return IRQ_NONE; 4471da177e4SLinus Torvalds } 4481da177e4SLinus Torvalds 4491da177e4SLinus Torvalds static void yenta_interrupt_wrapper(unsigned long data) 4501da177e4SLinus Torvalds { 4511da177e4SLinus Torvalds struct yenta_socket *socket = (struct yenta_socket *) data; 4521da177e4SLinus Torvalds 4531da177e4SLinus Torvalds yenta_interrupt(0, (void *)socket, NULL); 4541da177e4SLinus Torvalds socket->poll_timer.expires = jiffies + HZ; 4551da177e4SLinus Torvalds add_timer(&socket->poll_timer); 4561da177e4SLinus Torvalds } 4571da177e4SLinus Torvalds 4581da177e4SLinus Torvalds static void yenta_clear_maps(struct yenta_socket *socket) 4591da177e4SLinus Torvalds { 4601da177e4SLinus Torvalds int i; 4611da177e4SLinus Torvalds struct resource res = { .start = 0, .end = 0x0fff }; 4621da177e4SLinus Torvalds pccard_io_map io = { 0, 0, 0, 0, 1 }; 4631da177e4SLinus Torvalds pccard_mem_map mem = { .res = &res, }; 4641da177e4SLinus Torvalds 4651da177e4SLinus Torvalds yenta_set_socket(&socket->socket, &dead_socket); 4661da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 4671da177e4SLinus Torvalds io.map = i; 4681da177e4SLinus Torvalds yenta_set_io_map(&socket->socket, &io); 4691da177e4SLinus Torvalds } 4701da177e4SLinus Torvalds for (i = 0; i < 5; i++) { 4711da177e4SLinus Torvalds mem.map = i; 4721da177e4SLinus Torvalds yenta_set_mem_map(&socket->socket, &mem); 4731da177e4SLinus Torvalds } 4741da177e4SLinus Torvalds } 4751da177e4SLinus Torvalds 476fa912bcbSDaniel Ritz /* redoes voltage interrogation if required */ 477fa912bcbSDaniel Ritz static void yenta_interrogate(struct yenta_socket *socket) 478fa912bcbSDaniel Ritz { 479fa912bcbSDaniel Ritz u32 state; 480fa912bcbSDaniel Ritz 481fa912bcbSDaniel Ritz state = cb_readl(socket, CB_SOCKET_STATE); 482fa912bcbSDaniel Ritz if (!(state & (CB_5VCARD | CB_3VCARD | CB_XVCARD | CB_YVCARD)) || 483fa912bcbSDaniel Ritz (state & (CB_CDETECT1 | CB_CDETECT2 | CB_NOTACARD | CB_BADVCCREQ)) || 484fa912bcbSDaniel Ritz ((state & (CB_16BITCARD | CB_CBCARD)) == (CB_16BITCARD | CB_CBCARD))) 485fa912bcbSDaniel Ritz cb_writel(socket, CB_SOCKET_FORCE, CB_CVSTEST); 486fa912bcbSDaniel Ritz } 487fa912bcbSDaniel Ritz 4881da177e4SLinus Torvalds /* Called at resume and initialization events */ 4891da177e4SLinus Torvalds static int yenta_sock_init(struct pcmcia_socket *sock) 4901da177e4SLinus Torvalds { 4911da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 4921da177e4SLinus Torvalds u16 bridge; 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL) & ~CB_BRIDGE_INTR; 4951da177e4SLinus Torvalds if (!socket->cb_irq) 4961da177e4SLinus Torvalds bridge |= CB_BRIDGE_INTR; 4971da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds exca_writeb(socket, I365_GBLCTL, 0x00); 5001da177e4SLinus Torvalds exca_writeb(socket, I365_GENCTL, 0x00); 5011da177e4SLinus Torvalds 5021da177e4SLinus Torvalds /* Redo card voltage interrogation */ 503fa912bcbSDaniel Ritz yenta_interrogate(socket); 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds yenta_clear_maps(socket); 5061da177e4SLinus Torvalds 5071da177e4SLinus Torvalds if (socket->type && socket->type->sock_init) 5081da177e4SLinus Torvalds socket->type->sock_init(socket); 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds /* Re-enable CSC interrupts */ 5111da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CDMASK); 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds return 0; 5141da177e4SLinus Torvalds } 5151da177e4SLinus Torvalds 5161da177e4SLinus Torvalds static int yenta_sock_suspend(struct pcmcia_socket *sock) 5171da177e4SLinus Torvalds { 5181da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket); 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds /* Disable CSC interrupts */ 5211da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0x0); 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds return 0; 5241da177e4SLinus Torvalds } 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds /* 5271da177e4SLinus Torvalds * Use an adaptive allocation for the memory resource, 5281da177e4SLinus Torvalds * sometimes the memory behind pci bridges is limited: 5291da177e4SLinus Torvalds * 1/8 of the size of the io window of the parent. 5301da177e4SLinus Torvalds * max 4 MB, min 16 kB. 5311da177e4SLinus Torvalds */ 5321da177e4SLinus Torvalds #define BRIDGE_MEM_MAX 4*1024*1024 5331da177e4SLinus Torvalds #define BRIDGE_MEM_MIN 16*1024 5341da177e4SLinus Torvalds 5351da177e4SLinus Torvalds #define BRIDGE_IO_MAX 256 5361da177e4SLinus Torvalds #define BRIDGE_IO_MIN 32 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds #ifndef PCIBIOS_MIN_CARDBUS_IO 5391da177e4SLinus Torvalds #define PCIBIOS_MIN_CARDBUS_IO PCIBIOS_MIN_IO 5401da177e4SLinus Torvalds #endif 5411da177e4SLinus Torvalds 54227879835SDominik Brodowski static void yenta_allocate_res(struct yenta_socket *socket, int nr, unsigned type, int addr_start, int addr_end) 5431da177e4SLinus Torvalds { 5441da177e4SLinus Torvalds struct pci_bus *bus; 5451da177e4SLinus Torvalds struct resource *root, *res; 5461da177e4SLinus Torvalds u32 start, end; 5471da177e4SLinus Torvalds u32 align, size, min; 5481da177e4SLinus Torvalds unsigned mask; 5491da177e4SLinus Torvalds 5507925407aSIvan Kokshaysky res = socket->dev->resource + PCI_BRIDGE_RESOURCES + nr; 5517925407aSIvan Kokshaysky /* Already allocated? */ 5527925407aSIvan Kokshaysky if (res->parent) 553862104e5SDominik Brodowski return; 5547925407aSIvan Kokshaysky 5551da177e4SLinus Torvalds /* The granularity of the memory limit is 4kB, on IO it's 4 bytes */ 5561da177e4SLinus Torvalds mask = ~0xfff; 5571da177e4SLinus Torvalds if (type & IORESOURCE_IO) 5581da177e4SLinus Torvalds mask = ~3; 5591da177e4SLinus Torvalds 5601da177e4SLinus Torvalds bus = socket->dev->subordinate; 5611da177e4SLinus Torvalds res->name = bus->name; 5621da177e4SLinus Torvalds res->flags = type; 5631da177e4SLinus Torvalds 56427879835SDominik Brodowski start = config_readl(socket, addr_start) & mask; 56527879835SDominik Brodowski end = config_readl(socket, addr_end) | ~mask; 5661da177e4SLinus Torvalds if (start && end > start && !override_bios) { 5671da177e4SLinus Torvalds res->start = start; 5681da177e4SLinus Torvalds res->end = end; 569862104e5SDominik Brodowski root = pci_find_parent_resource(socket->dev, res); 570862104e5SDominik Brodowski if (root && (request_resource(root, res) == 0)) 5711da177e4SLinus Torvalds return; 572862104e5SDominik Brodowski printk(KERN_INFO "yenta %s: Preassigned resource %d busy or not available, reconfiguring...\n", 5731da177e4SLinus Torvalds pci_name(socket->dev), nr); 5741da177e4SLinus Torvalds } 5751da177e4SLinus Torvalds 576862104e5SDominik Brodowski res->start = 0; 577862104e5SDominik Brodowski res->end = 0; 578862104e5SDominik Brodowski root = pci_find_parent_resource(socket->dev, res); 579862104e5SDominik Brodowski 5801da177e4SLinus Torvalds if (type & IORESOURCE_IO) { 5811da177e4SLinus Torvalds align = 1024; 5821da177e4SLinus Torvalds size = BRIDGE_IO_MAX; 5831da177e4SLinus Torvalds min = BRIDGE_IO_MIN; 5841da177e4SLinus Torvalds start = PCIBIOS_MIN_CARDBUS_IO; 5851da177e4SLinus Torvalds end = ~0U; 5861da177e4SLinus Torvalds } else { 5871da177e4SLinus Torvalds unsigned long avail = root->end - root->start; 5881da177e4SLinus Torvalds int i; 5891da177e4SLinus Torvalds size = BRIDGE_MEM_MAX; 5901da177e4SLinus Torvalds if (size > avail/8) { 5911da177e4SLinus Torvalds size=(avail+1)/8; 5921da177e4SLinus Torvalds /* round size down to next power of 2 */ 5931da177e4SLinus Torvalds i = 0; 5941da177e4SLinus Torvalds while ((size /= 2) != 0) 5951da177e4SLinus Torvalds i++; 5961da177e4SLinus Torvalds size = 1 << i; 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds if (size < BRIDGE_MEM_MIN) 5991da177e4SLinus Torvalds size = BRIDGE_MEM_MIN; 6001da177e4SLinus Torvalds min = BRIDGE_MEM_MIN; 6011da177e4SLinus Torvalds align = size; 6021da177e4SLinus Torvalds start = PCIBIOS_MIN_MEM; 6031da177e4SLinus Torvalds end = ~0U; 6041da177e4SLinus Torvalds } 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds do { 6071da177e4SLinus Torvalds if (allocate_resource(root, res, size, start, end, align, NULL, NULL)==0) { 60827879835SDominik Brodowski config_writel(socket, addr_start, res->start); 60927879835SDominik Brodowski config_writel(socket, addr_end, res->end); 6101da177e4SLinus Torvalds return; 6111da177e4SLinus Torvalds } 6121da177e4SLinus Torvalds size = size/2; 6131da177e4SLinus Torvalds align = size; 6141da177e4SLinus Torvalds } while (size >= min); 6151da177e4SLinus Torvalds printk(KERN_INFO "yenta %s: no resource of type %x available, trying to continue...\n", 6161da177e4SLinus Torvalds pci_name(socket->dev), type); 6171da177e4SLinus Torvalds res->start = res->end = 0; 6181da177e4SLinus Torvalds } 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds /* 6211da177e4SLinus Torvalds * Allocate the bridge mappings for the device.. 6221da177e4SLinus Torvalds */ 6231da177e4SLinus Torvalds static void yenta_allocate_resources(struct yenta_socket *socket) 6241da177e4SLinus Torvalds { 62527879835SDominik Brodowski yenta_allocate_res(socket, 0, IORESOURCE_IO, 62627879835SDominik Brodowski PCI_CB_IO_BASE_0, PCI_CB_IO_LIMIT_0); 62727879835SDominik Brodowski yenta_allocate_res(socket, 1, IORESOURCE_IO, 62827879835SDominik Brodowski PCI_CB_IO_BASE_1, PCI_CB_IO_LIMIT_1); 62927879835SDominik Brodowski yenta_allocate_res(socket, 2, IORESOURCE_MEM|IORESOURCE_PREFETCH, 63027879835SDominik Brodowski PCI_CB_MEMORY_BASE_0, PCI_CB_MEMORY_LIMIT_0); 63127879835SDominik Brodowski yenta_allocate_res(socket, 3, IORESOURCE_MEM, 63227879835SDominik Brodowski PCI_CB_MEMORY_BASE_1, PCI_CB_MEMORY_LIMIT_1); 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds /* 6371da177e4SLinus Torvalds * Free the bridge mappings for the device.. 6381da177e4SLinus Torvalds */ 6391da177e4SLinus Torvalds static void yenta_free_resources(struct yenta_socket *socket) 6401da177e4SLinus Torvalds { 6411da177e4SLinus Torvalds int i; 6421da177e4SLinus Torvalds for (i=0;i<4;i++) { 6431da177e4SLinus Torvalds struct resource *res; 6441da177e4SLinus Torvalds res = socket->dev->resource + PCI_BRIDGE_RESOURCES + i; 6451da177e4SLinus Torvalds if (res->start != 0 && res->end != 0) 6461da177e4SLinus Torvalds release_resource(res); 6471da177e4SLinus Torvalds res->start = res->end = 0; 6481da177e4SLinus Torvalds } 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds /* 6531da177e4SLinus Torvalds * Close it down - release our resources and go home.. 6541da177e4SLinus Torvalds */ 6551da177e4SLinus Torvalds static void yenta_close(struct pci_dev *dev) 6561da177e4SLinus Torvalds { 6571da177e4SLinus Torvalds struct yenta_socket *sock = pci_get_drvdata(dev); 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds /* we don't want a dying socket registered */ 6601da177e4SLinus Torvalds pcmcia_unregister_socket(&sock->socket); 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds /* Disable all events so we don't die in an IRQ storm */ 6631da177e4SLinus Torvalds cb_writel(sock, CB_SOCKET_MASK, 0x0); 6641da177e4SLinus Torvalds exca_writeb(sock, I365_CSCINT, 0); 6651da177e4SLinus Torvalds 6661da177e4SLinus Torvalds if (sock->cb_irq) 6671da177e4SLinus Torvalds free_irq(sock->cb_irq, sock); 6681da177e4SLinus Torvalds else 6691da177e4SLinus Torvalds del_timer_sync(&sock->poll_timer); 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds if (sock->base) 6721da177e4SLinus Torvalds iounmap(sock->base); 6731da177e4SLinus Torvalds yenta_free_resources(sock); 6741da177e4SLinus Torvalds 6751da177e4SLinus Torvalds pci_release_regions(dev); 6761da177e4SLinus Torvalds pci_disable_device(dev); 6771da177e4SLinus Torvalds pci_set_drvdata(dev, NULL); 6781da177e4SLinus Torvalds } 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds 6811da177e4SLinus Torvalds static struct pccard_operations yenta_socket_operations = { 6821da177e4SLinus Torvalds .init = yenta_sock_init, 6831da177e4SLinus Torvalds .suspend = yenta_sock_suspend, 6841da177e4SLinus Torvalds .get_status = yenta_get_status, 6851da177e4SLinus Torvalds .get_socket = yenta_get_socket, 6861da177e4SLinus Torvalds .set_socket = yenta_set_socket, 6871da177e4SLinus Torvalds .set_io_map = yenta_set_io_map, 6881da177e4SLinus Torvalds .set_mem_map = yenta_set_mem_map, 6891da177e4SLinus Torvalds }; 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds 6921da177e4SLinus Torvalds #include "ti113x.h" 6931da177e4SLinus Torvalds #include "ricoh.h" 6941da177e4SLinus Torvalds #include "topic.h" 6951da177e4SLinus Torvalds #include "o2micro.h" 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds enum { 6981da177e4SLinus Torvalds CARDBUS_TYPE_DEFAULT = -1, 6991da177e4SLinus Torvalds CARDBUS_TYPE_TI, 7001da177e4SLinus Torvalds CARDBUS_TYPE_TI113X, 7011da177e4SLinus Torvalds CARDBUS_TYPE_TI12XX, 7021da177e4SLinus Torvalds CARDBUS_TYPE_TI1250, 7031da177e4SLinus Torvalds CARDBUS_TYPE_RICOH, 7041da177e4SLinus Torvalds CARDBUS_TYPE_TOPIC97, 7051da177e4SLinus Torvalds CARDBUS_TYPE_O2MICRO, 7061da177e4SLinus Torvalds }; 7071da177e4SLinus Torvalds 7081da177e4SLinus Torvalds /* 7091da177e4SLinus Torvalds * Different cardbus controllers have slightly different 7101da177e4SLinus Torvalds * initialization sequences etc details. List them here.. 7111da177e4SLinus Torvalds */ 7121da177e4SLinus Torvalds static struct cardbus_type cardbus_type[] = { 7131da177e4SLinus Torvalds [CARDBUS_TYPE_TI] = { 7141da177e4SLinus Torvalds .override = ti_override, 7151da177e4SLinus Torvalds .save_state = ti_save_state, 7161da177e4SLinus Torvalds .restore_state = ti_restore_state, 7171da177e4SLinus Torvalds .sock_init = ti_init, 7181da177e4SLinus Torvalds }, 7191da177e4SLinus Torvalds [CARDBUS_TYPE_TI113X] = { 7201da177e4SLinus Torvalds .override = ti113x_override, 7211da177e4SLinus Torvalds .save_state = ti_save_state, 7221da177e4SLinus Torvalds .restore_state = ti_restore_state, 7231da177e4SLinus Torvalds .sock_init = ti_init, 7241da177e4SLinus Torvalds }, 7251da177e4SLinus Torvalds [CARDBUS_TYPE_TI12XX] = { 7261da177e4SLinus Torvalds .override = ti12xx_override, 7271da177e4SLinus Torvalds .save_state = ti_save_state, 7281da177e4SLinus Torvalds .restore_state = ti_restore_state, 7291da177e4SLinus Torvalds .sock_init = ti_init, 7301da177e4SLinus Torvalds }, 7311da177e4SLinus Torvalds [CARDBUS_TYPE_TI1250] = { 7321da177e4SLinus Torvalds .override = ti1250_override, 7331da177e4SLinus Torvalds .save_state = ti_save_state, 7341da177e4SLinus Torvalds .restore_state = ti_restore_state, 7351da177e4SLinus Torvalds .sock_init = ti_init, 7361da177e4SLinus Torvalds }, 7371da177e4SLinus Torvalds [CARDBUS_TYPE_RICOH] = { 7381da177e4SLinus Torvalds .override = ricoh_override, 7391da177e4SLinus Torvalds .save_state = ricoh_save_state, 7401da177e4SLinus Torvalds .restore_state = ricoh_restore_state, 7411da177e4SLinus Torvalds }, 7421da177e4SLinus Torvalds [CARDBUS_TYPE_TOPIC97] = { 7431da177e4SLinus Torvalds .override = topic97_override, 7441da177e4SLinus Torvalds }, 7451da177e4SLinus Torvalds [CARDBUS_TYPE_O2MICRO] = { 7461da177e4SLinus Torvalds .override = o2micro_override, 7471da177e4SLinus Torvalds .restore_state = o2micro_restore_state, 7481da177e4SLinus Torvalds }, 7491da177e4SLinus Torvalds }; 7501da177e4SLinus Torvalds 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds /* 7531da177e4SLinus Torvalds * Only probe "regular" interrupts, don't 7541da177e4SLinus Torvalds * touch dangerous spots like the mouse irq, 7551da177e4SLinus Torvalds * because there are mice that apparently 7561da177e4SLinus Torvalds * get really confused if they get fondled 7571da177e4SLinus Torvalds * too intimately. 7581da177e4SLinus Torvalds * 7591da177e4SLinus Torvalds * Default to 11, 10, 9, 7, 6, 5, 4, 3. 7601da177e4SLinus Torvalds */ 7611da177e4SLinus Torvalds static u32 isa_interrupts = 0x0ef8; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds static unsigned int yenta_probe_irq(struct yenta_socket *socket, u32 isa_irq_mask) 7641da177e4SLinus Torvalds { 7651da177e4SLinus Torvalds int i; 7661da177e4SLinus Torvalds unsigned long val; 7671da177e4SLinus Torvalds u16 bridge_ctrl; 7681da177e4SLinus Torvalds u32 mask; 7691da177e4SLinus Torvalds 7701da177e4SLinus Torvalds /* Set up ISA irq routing to probe the ISA irqs.. */ 7711da177e4SLinus Torvalds bridge_ctrl = config_readw(socket, CB_BRIDGE_CONTROL); 7721da177e4SLinus Torvalds if (!(bridge_ctrl & CB_BRIDGE_INTR)) { 7731da177e4SLinus Torvalds bridge_ctrl |= CB_BRIDGE_INTR; 7741da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge_ctrl); 7751da177e4SLinus Torvalds } 7761da177e4SLinus Torvalds 7771da177e4SLinus Torvalds /* 7781da177e4SLinus Torvalds * Probe for usable interrupts using the force 7791da177e4SLinus Torvalds * register to generate bogus card status events. 7801da177e4SLinus Torvalds */ 7811da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 7821da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK); 7831da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 7841da177e4SLinus Torvalds val = probe_irq_on() & isa_irq_mask; 7851da177e4SLinus Torvalds for (i = 1; i < 16; i++) { 7861da177e4SLinus Torvalds if (!((val >> i) & 1)) 7871da177e4SLinus Torvalds continue; 7881da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG | (i << 4)); 7891da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS); 7901da177e4SLinus Torvalds udelay(100); 7911da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 7921da177e4SLinus Torvalds } 7931da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0); 7941da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds mask = probe_irq_mask(val) & 0xffff; 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds bridge_ctrl &= ~CB_BRIDGE_INTR; 7991da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge_ctrl); 8001da177e4SLinus Torvalds 8011da177e4SLinus Torvalds return mask; 8021da177e4SLinus Torvalds } 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds 8051da177e4SLinus Torvalds /* interrupt handler, only used during probing */ 8061da177e4SLinus Torvalds static irqreturn_t yenta_probe_handler(int irq, void *dev_id, struct pt_regs *regs) 8071da177e4SLinus Torvalds { 8081da177e4SLinus Torvalds struct yenta_socket *socket = (struct yenta_socket *) dev_id; 8091da177e4SLinus Torvalds u8 csc; 8101da177e4SLinus Torvalds u32 cb_event; 8111da177e4SLinus Torvalds 8121da177e4SLinus Torvalds /* Clear interrupt status for the event */ 8131da177e4SLinus Torvalds cb_event = cb_readl(socket, CB_SOCKET_EVENT); 8141da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 8151da177e4SLinus Torvalds csc = exca_readb(socket, I365_CSC); 8161da177e4SLinus Torvalds 8171da177e4SLinus Torvalds if (cb_event || csc) { 8181da177e4SLinus Torvalds socket->probe_status = 1; 8191da177e4SLinus Torvalds return IRQ_HANDLED; 8201da177e4SLinus Torvalds } 8211da177e4SLinus Torvalds 8221da177e4SLinus Torvalds return IRQ_NONE; 8231da177e4SLinus Torvalds } 8241da177e4SLinus Torvalds 8251da177e4SLinus Torvalds /* probes the PCI interrupt, use only on override functions */ 8261da177e4SLinus Torvalds static int yenta_probe_cb_irq(struct yenta_socket *socket) 8271da177e4SLinus Torvalds { 8281da177e4SLinus Torvalds u16 bridge_ctrl; 8291da177e4SLinus Torvalds 8301da177e4SLinus Torvalds if (!socket->cb_irq) 8311da177e4SLinus Torvalds return -1; 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds socket->probe_status = 0; 8341da177e4SLinus Torvalds 8351da177e4SLinus Torvalds /* disable ISA interrupts */ 8361da177e4SLinus Torvalds bridge_ctrl = config_readw(socket, CB_BRIDGE_CONTROL); 8371da177e4SLinus Torvalds bridge_ctrl &= ~CB_BRIDGE_INTR; 8381da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge_ctrl); 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds if (request_irq(socket->cb_irq, yenta_probe_handler, SA_SHIRQ, "yenta", socket)) { 8411da177e4SLinus Torvalds printk(KERN_WARNING "Yenta: request_irq() in yenta_probe_cb_irq() failed!\n"); 8421da177e4SLinus Torvalds return -1; 8431da177e4SLinus Torvalds } 8441da177e4SLinus Torvalds 8451da177e4SLinus Torvalds /* generate interrupt, wait */ 8461da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, I365_CSC_STSCHG); 8471da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 8481da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, CB_CSTSMASK); 8491da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_FORCE, CB_FCARDSTS); 8501da177e4SLinus Torvalds 8511da177e4SLinus Torvalds msleep(100); 8521da177e4SLinus Torvalds 8531da177e4SLinus Torvalds /* disable interrupts */ 8541da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0); 8551da177e4SLinus Torvalds exca_writeb(socket, I365_CSCINT, 0); 8561da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_EVENT, -1); 8571da177e4SLinus Torvalds exca_readb(socket, I365_CSC); 8581da177e4SLinus Torvalds 8591da177e4SLinus Torvalds free_irq(socket->cb_irq, socket); 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds return (int) socket->probe_status; 8621da177e4SLinus Torvalds } 8631da177e4SLinus Torvalds 8641da177e4SLinus Torvalds 8651da177e4SLinus Torvalds 8661da177e4SLinus Torvalds /* 8671da177e4SLinus Torvalds * Set static data that doesn't need re-initializing.. 8681da177e4SLinus Torvalds */ 8691da177e4SLinus Torvalds static void yenta_get_socket_capabilities(struct yenta_socket *socket, u32 isa_irq_mask) 8701da177e4SLinus Torvalds { 8711da177e4SLinus Torvalds socket->socket.pci_irq = socket->cb_irq; 872fa912bcbSDaniel Ritz if (isa_probe) 8731da177e4SLinus Torvalds socket->socket.irq_mask = yenta_probe_irq(socket, isa_irq_mask); 874fa912bcbSDaniel Ritz else 875fa912bcbSDaniel Ritz socket->socket.irq_mask = 0; 8761da177e4SLinus Torvalds 8771da177e4SLinus Torvalds printk(KERN_INFO "Yenta: ISA IRQ mask 0x%04x, PCI irq %d\n", 8781da177e4SLinus Torvalds socket->socket.irq_mask, socket->cb_irq); 8791da177e4SLinus Torvalds } 8801da177e4SLinus Torvalds 8811da177e4SLinus Torvalds /* 8821da177e4SLinus Torvalds * Initialize the standard cardbus registers 8831da177e4SLinus Torvalds */ 8841da177e4SLinus Torvalds static void yenta_config_init(struct yenta_socket *socket) 8851da177e4SLinus Torvalds { 8861da177e4SLinus Torvalds u16 bridge; 8871da177e4SLinus Torvalds struct pci_dev *dev = socket->dev; 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds pci_set_power_state(socket->dev, 0); 8901da177e4SLinus Torvalds 8911da177e4SLinus Torvalds config_writel(socket, CB_LEGACY_MODE_BASE, 0); 8921da177e4SLinus Torvalds config_writel(socket, PCI_BASE_ADDRESS_0, dev->resource[0].start); 8931da177e4SLinus Torvalds config_writew(socket, PCI_COMMAND, 8941da177e4SLinus Torvalds PCI_COMMAND_IO | 8951da177e4SLinus Torvalds PCI_COMMAND_MEMORY | 8961da177e4SLinus Torvalds PCI_COMMAND_MASTER | 8971da177e4SLinus Torvalds PCI_COMMAND_WAIT); 8981da177e4SLinus Torvalds 8991da177e4SLinus Torvalds /* MAGIC NUMBERS! Fixme */ 9001da177e4SLinus Torvalds config_writeb(socket, PCI_CACHE_LINE_SIZE, L1_CACHE_BYTES / 4); 9011da177e4SLinus Torvalds config_writeb(socket, PCI_LATENCY_TIMER, 168); 9021da177e4SLinus Torvalds config_writel(socket, PCI_PRIMARY_BUS, 9031da177e4SLinus Torvalds (176 << 24) | /* sec. latency timer */ 9041da177e4SLinus Torvalds (dev->subordinate->subordinate << 16) | /* subordinate bus */ 9051da177e4SLinus Torvalds (dev->subordinate->secondary << 8) | /* secondary bus */ 9061da177e4SLinus Torvalds dev->subordinate->primary); /* primary bus */ 9071da177e4SLinus Torvalds 9081da177e4SLinus Torvalds /* 9091da177e4SLinus Torvalds * Set up the bridging state: 9101da177e4SLinus Torvalds * - enable write posting. 9111da177e4SLinus Torvalds * - memory window 0 prefetchable, window 1 non-prefetchable 9121da177e4SLinus Torvalds * - PCI interrupts enabled if a PCI interrupt exists.. 9131da177e4SLinus Torvalds */ 9141da177e4SLinus Torvalds bridge = config_readw(socket, CB_BRIDGE_CONTROL); 9151da177e4SLinus Torvalds bridge &= ~(CB_BRIDGE_CRST | CB_BRIDGE_PREFETCH1 | CB_BRIDGE_INTR | CB_BRIDGE_ISAEN | CB_BRIDGE_VGAEN); 9161da177e4SLinus Torvalds bridge |= CB_BRIDGE_PREFETCH0 | CB_BRIDGE_POSTEN | CB_BRIDGE_INTR; 9171da177e4SLinus Torvalds config_writew(socket, CB_BRIDGE_CONTROL, bridge); 9181da177e4SLinus Torvalds } 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds /* 9211da177e4SLinus Torvalds * Initialize a cardbus controller. Make sure we have a usable 9221da177e4SLinus Torvalds * interrupt, and that we can map the cardbus area. Fill in the 9231da177e4SLinus Torvalds * socket information structure.. 9241da177e4SLinus Torvalds */ 9251da177e4SLinus Torvalds static int __devinit yenta_probe (struct pci_dev *dev, const struct pci_device_id *id) 9261da177e4SLinus Torvalds { 9271da177e4SLinus Torvalds struct yenta_socket *socket; 9281da177e4SLinus Torvalds int ret; 9291da177e4SLinus Torvalds 9301da177e4SLinus Torvalds socket = kmalloc(sizeof(struct yenta_socket), GFP_KERNEL); 9311da177e4SLinus Torvalds if (!socket) 9321da177e4SLinus Torvalds return -ENOMEM; 9331da177e4SLinus Torvalds memset(socket, 0, sizeof(*socket)); 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds /* prepare pcmcia_socket */ 9361da177e4SLinus Torvalds socket->socket.ops = ¥ta_socket_operations; 9371da177e4SLinus Torvalds socket->socket.resource_ops = &pccard_nonstatic_ops; 9381da177e4SLinus Torvalds socket->socket.dev.dev = &dev->dev; 9391da177e4SLinus Torvalds socket->socket.driver_data = socket; 9401da177e4SLinus Torvalds socket->socket.owner = THIS_MODULE; 9415bc6b68aSRussell King socket->socket.features = SS_CAP_PAGE_REGS | SS_CAP_PCCARD; 9425bc6b68aSRussell King socket->socket.map_size = 0x1000; 9435bc6b68aSRussell King socket->socket.cb_dev = dev; 9441da177e4SLinus Torvalds 9451da177e4SLinus Torvalds /* prepare struct yenta_socket */ 9461da177e4SLinus Torvalds socket->dev = dev; 9471da177e4SLinus Torvalds pci_set_drvdata(dev, socket); 9481da177e4SLinus Torvalds 9491da177e4SLinus Torvalds /* 9501da177e4SLinus Torvalds * Do some basic sanity checking.. 9511da177e4SLinus Torvalds */ 9521da177e4SLinus Torvalds if (pci_enable_device(dev)) { 9531da177e4SLinus Torvalds ret = -EBUSY; 9541da177e4SLinus Torvalds goto free; 9551da177e4SLinus Torvalds } 9561da177e4SLinus Torvalds 9571da177e4SLinus Torvalds ret = pci_request_regions(dev, "yenta_socket"); 9581da177e4SLinus Torvalds if (ret) 9591da177e4SLinus Torvalds goto disable; 9601da177e4SLinus Torvalds 9611da177e4SLinus Torvalds if (!pci_resource_start(dev, 0)) { 9621da177e4SLinus Torvalds printk(KERN_ERR "No cardbus resource!\n"); 9631da177e4SLinus Torvalds ret = -ENODEV; 9641da177e4SLinus Torvalds goto release; 9651da177e4SLinus Torvalds } 9661da177e4SLinus Torvalds 9671da177e4SLinus Torvalds /* 9681da177e4SLinus Torvalds * Ok, start setup.. Map the cardbus registers, 9691da177e4SLinus Torvalds * and request the IRQ. 9701da177e4SLinus Torvalds */ 9711da177e4SLinus Torvalds socket->base = ioremap(pci_resource_start(dev, 0), 0x1000); 9721da177e4SLinus Torvalds if (!socket->base) { 9731da177e4SLinus Torvalds ret = -ENOMEM; 9741da177e4SLinus Torvalds goto release; 9751da177e4SLinus Torvalds } 9761da177e4SLinus Torvalds 9771da177e4SLinus Torvalds /* 9781da177e4SLinus Torvalds * report the subsystem vendor and device for help debugging 9791da177e4SLinus Torvalds * the irq stuff... 9801da177e4SLinus Torvalds */ 9811da177e4SLinus Torvalds printk(KERN_INFO "Yenta: CardBus bridge found at %s [%04x:%04x]\n", 9821da177e4SLinus Torvalds pci_name(dev), dev->subsystem_vendor, dev->subsystem_device); 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds yenta_config_init(socket); 9851da177e4SLinus Torvalds 9861da177e4SLinus Torvalds /* Disable all events */ 9871da177e4SLinus Torvalds cb_writel(socket, CB_SOCKET_MASK, 0x0); 9881da177e4SLinus Torvalds 9891da177e4SLinus Torvalds /* Set up the bridge regions.. */ 9901da177e4SLinus Torvalds yenta_allocate_resources(socket); 9911da177e4SLinus Torvalds 9921da177e4SLinus Torvalds socket->cb_irq = dev->irq; 9931da177e4SLinus Torvalds 9941da177e4SLinus Torvalds /* Do we have special options for the device? */ 9951da177e4SLinus Torvalds if (id->driver_data != CARDBUS_TYPE_DEFAULT && 9961da177e4SLinus Torvalds id->driver_data < ARRAY_SIZE(cardbus_type)) { 9971da177e4SLinus Torvalds socket->type = &cardbus_type[id->driver_data]; 9981da177e4SLinus Torvalds 9991da177e4SLinus Torvalds ret = socket->type->override(socket); 10001da177e4SLinus Torvalds if (ret < 0) 10011da177e4SLinus Torvalds goto unmap; 10021da177e4SLinus Torvalds } 10031da177e4SLinus Torvalds 10041da177e4SLinus Torvalds /* We must finish initialization here */ 10051da177e4SLinus Torvalds 10061da177e4SLinus Torvalds if (!socket->cb_irq || request_irq(socket->cb_irq, yenta_interrupt, SA_SHIRQ, "yenta", socket)) { 10071da177e4SLinus Torvalds /* No IRQ or request_irq failed. Poll */ 10081da177e4SLinus Torvalds socket->cb_irq = 0; /* But zero is a valid IRQ number. */ 10091da177e4SLinus Torvalds init_timer(&socket->poll_timer); 10101da177e4SLinus Torvalds socket->poll_timer.function = yenta_interrupt_wrapper; 10111da177e4SLinus Torvalds socket->poll_timer.data = (unsigned long)socket; 10121da177e4SLinus Torvalds socket->poll_timer.expires = jiffies + HZ; 10131da177e4SLinus Torvalds add_timer(&socket->poll_timer); 10145bc6b68aSRussell King printk(KERN_INFO "Yenta: no PCI IRQ, CardBus support disabled for this socket.\n" 10155bc6b68aSRussell King KERN_INFO "Yenta: check your BIOS CardBus, BIOS IRQ or ACPI settings.\n"); 10165bc6b68aSRussell King } else { 10175bc6b68aSRussell King socket->socket.features |= SS_CAP_CARDBUS; 10181da177e4SLinus Torvalds } 10191da177e4SLinus Torvalds 10201da177e4SLinus Torvalds /* Figure out what the dang thing can do for the PCMCIA layer... */ 1021fa912bcbSDaniel Ritz yenta_interrogate(socket); 10221da177e4SLinus Torvalds yenta_get_socket_capabilities(socket, isa_interrupts); 10231da177e4SLinus Torvalds printk(KERN_INFO "Socket status: %08x\n", cb_readl(socket, CB_SOCKET_STATE)); 10241da177e4SLinus Torvalds 10251da177e4SLinus Torvalds /* Register it with the pcmcia layer.. */ 10261da177e4SLinus Torvalds ret = pcmcia_register_socket(&socket->socket); 10271da177e4SLinus Torvalds if (ret == 0) 10281da177e4SLinus Torvalds goto out; 10291da177e4SLinus Torvalds 10301da177e4SLinus Torvalds unmap: 10311da177e4SLinus Torvalds iounmap(socket->base); 10321da177e4SLinus Torvalds release: 10331da177e4SLinus Torvalds pci_release_regions(dev); 10341da177e4SLinus Torvalds disable: 10351da177e4SLinus Torvalds pci_disable_device(dev); 10361da177e4SLinus Torvalds free: 10371da177e4SLinus Torvalds kfree(socket); 10381da177e4SLinus Torvalds out: 10391da177e4SLinus Torvalds return ret; 10401da177e4SLinus Torvalds } 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds static int yenta_dev_suspend (struct pci_dev *dev, pm_message_t state) 10441da177e4SLinus Torvalds { 10451da177e4SLinus Torvalds struct yenta_socket *socket = pci_get_drvdata(dev); 10461da177e4SLinus Torvalds int ret; 10471da177e4SLinus Torvalds 10481da177e4SLinus Torvalds ret = pcmcia_socket_dev_suspend(&dev->dev, state); 10491da177e4SLinus Torvalds 10501da177e4SLinus Torvalds if (socket) { 10511da177e4SLinus Torvalds if (socket->type && socket->type->save_state) 10521da177e4SLinus Torvalds socket->type->save_state(socket); 10531da177e4SLinus Torvalds 10541da177e4SLinus Torvalds /* FIXME: pci_save_state needs to have a better interface */ 10551da177e4SLinus Torvalds pci_save_state(dev); 10561da177e4SLinus Torvalds pci_read_config_dword(dev, 16*4, &socket->saved_state[0]); 10571da177e4SLinus Torvalds pci_read_config_dword(dev, 17*4, &socket->saved_state[1]); 10581da177e4SLinus Torvalds 10591da177e4SLinus Torvalds /* 10601da177e4SLinus Torvalds * Some laptops (IBM T22) do not like us putting the Cardbus 10611da177e4SLinus Torvalds * bridge into D3. At a guess, some other laptop will 10621da177e4SLinus Torvalds * probably require this, so leave it commented out for now. 10631da177e4SLinus Torvalds */ 10641da177e4SLinus Torvalds /* pci_set_power_state(dev, 3); */ 10651da177e4SLinus Torvalds } 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds return ret; 10681da177e4SLinus Torvalds } 10691da177e4SLinus Torvalds 10701da177e4SLinus Torvalds 10711da177e4SLinus Torvalds static int yenta_dev_resume (struct pci_dev *dev) 10721da177e4SLinus Torvalds { 10731da177e4SLinus Torvalds struct yenta_socket *socket = pci_get_drvdata(dev); 10741da177e4SLinus Torvalds 10751da177e4SLinus Torvalds if (socket) { 10761da177e4SLinus Torvalds pci_set_power_state(dev, 0); 10771da177e4SLinus Torvalds /* FIXME: pci_restore_state needs to have a better interface */ 10781da177e4SLinus Torvalds pci_restore_state(dev); 10791da177e4SLinus Torvalds pci_write_config_dword(dev, 16*4, socket->saved_state[0]); 10801da177e4SLinus Torvalds pci_write_config_dword(dev, 17*4, socket->saved_state[1]); 10811da177e4SLinus Torvalds 10821da177e4SLinus Torvalds if (socket->type && socket->type->restore_state) 10831da177e4SLinus Torvalds socket->type->restore_state(socket); 10841da177e4SLinus Torvalds } 10851da177e4SLinus Torvalds 10861da177e4SLinus Torvalds return pcmcia_socket_dev_resume(&dev->dev); 10871da177e4SLinus Torvalds } 10881da177e4SLinus Torvalds 10891da177e4SLinus Torvalds 10901da177e4SLinus Torvalds #define CB_ID(vend,dev,type) \ 10911da177e4SLinus Torvalds { \ 10921da177e4SLinus Torvalds .vendor = vend, \ 10931da177e4SLinus Torvalds .device = dev, \ 10941da177e4SLinus Torvalds .subvendor = PCI_ANY_ID, \ 10951da177e4SLinus Torvalds .subdevice = PCI_ANY_ID, \ 10961da177e4SLinus Torvalds .class = PCI_CLASS_BRIDGE_CARDBUS << 8, \ 10971da177e4SLinus Torvalds .class_mask = ~0, \ 10981da177e4SLinus Torvalds .driver_data = CARDBUS_TYPE_##type, \ 10991da177e4SLinus Torvalds } 11001da177e4SLinus Torvalds 11011da177e4SLinus Torvalds static struct pci_device_id yenta_table [] = { 11021da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1031, TI), 11031da177e4SLinus Torvalds 11041da177e4SLinus Torvalds /* 11051da177e4SLinus Torvalds * TBD: Check if these TI variants can use more 11061da177e4SLinus Torvalds * advanced overrides instead. (I can't get the 11071da177e4SLinus Torvalds * data sheets for these devices. --rmk) 11081da177e4SLinus Torvalds */ 11091da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1210, TI), 11101da177e4SLinus Torvalds 11111da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1130, TI113X), 11121da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1131, TI113X), 11131da177e4SLinus Torvalds 11141da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1211, TI12XX), 11151da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1220, TI12XX), 11161da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1221, TI12XX), 11171da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1225, TI12XX), 11181da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251A, TI12XX), 11191da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1251B, TI12XX), 11201da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1420, TI12XX), 11211da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1450, TI12XX), 11221da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1451A, TI12XX), 11231da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1510, TI12XX), 11241da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1520, TI12XX), 11251da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1620, TI12XX), 11261da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4410, TI12XX), 11271da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4450, TI12XX), 11281da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4451, TI12XX), 11291da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4510, TI12XX), 11301da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_4520, TI12XX), 11311da177e4SLinus Torvalds 11321da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1250, TI1250), 11331da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TI, PCI_DEVICE_ID_TI_1410, TI1250), 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1211, TI12XX), 11361da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1225, TI12XX), 11371da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1410, TI1250), 11381da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_ENE, PCI_DEVICE_ID_ENE_1420, TI12XX), 11391da177e4SLinus Torvalds 11401da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C465, RICOH), 11411da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C466, RICOH), 11421da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C475, RICOH), 11431da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476, RICOH), 11441da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C478, RICOH), 11451da177e4SLinus Torvalds 11461da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC97, TOPIC97), 11471da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_TOSHIBA, PCI_DEVICE_ID_TOSHIBA_TOPIC100, TOPIC97), 11481da177e4SLinus Torvalds 11491da177e4SLinus Torvalds CB_ID(PCI_VENDOR_ID_O2, PCI_ANY_ID, O2MICRO), 11501da177e4SLinus Torvalds 11511da177e4SLinus Torvalds /* match any cardbus bridge */ 11521da177e4SLinus Torvalds CB_ID(PCI_ANY_ID, PCI_ANY_ID, DEFAULT), 11531da177e4SLinus Torvalds { /* all zeroes */ } 11541da177e4SLinus Torvalds }; 11551da177e4SLinus Torvalds MODULE_DEVICE_TABLE(pci, yenta_table); 11561da177e4SLinus Torvalds 11571da177e4SLinus Torvalds 11581da177e4SLinus Torvalds static struct pci_driver yenta_cardbus_driver = { 11591da177e4SLinus Torvalds .name = "yenta_cardbus", 11601da177e4SLinus Torvalds .id_table = yenta_table, 11611da177e4SLinus Torvalds .probe = yenta_probe, 11621da177e4SLinus Torvalds .remove = __devexit_p(yenta_close), 11631da177e4SLinus Torvalds .suspend = yenta_dev_suspend, 11641da177e4SLinus Torvalds .resume = yenta_dev_resume, 11651da177e4SLinus Torvalds }; 11661da177e4SLinus Torvalds 11671da177e4SLinus Torvalds 11681da177e4SLinus Torvalds static int __init yenta_socket_init(void) 11691da177e4SLinus Torvalds { 11701da177e4SLinus Torvalds return pci_register_driver (¥ta_cardbus_driver); 11711da177e4SLinus Torvalds } 11721da177e4SLinus Torvalds 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds static void __exit yenta_socket_exit (void) 11751da177e4SLinus Torvalds { 11761da177e4SLinus Torvalds pci_unregister_driver (¥ta_cardbus_driver); 11771da177e4SLinus Torvalds } 11781da177e4SLinus Torvalds 11791da177e4SLinus Torvalds 11801da177e4SLinus Torvalds module_init(yenta_socket_init); 11811da177e4SLinus Torvalds module_exit(yenta_socket_exit); 11821da177e4SLinus Torvalds 11831da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 1184