11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds * ti113x.h 1.16 1999/10/25 20:03:34
31da177e4SLinus Torvalds *
41da177e4SLinus Torvalds * The contents of this file are subject to the Mozilla Public License
51da177e4SLinus Torvalds * Version 1.1 (the "License"); you may not use this file except in
61da177e4SLinus Torvalds * compliance with the License. You may obtain a copy of the License
71da177e4SLinus Torvalds * at http://www.mozilla.org/MPL/
81da177e4SLinus Torvalds *
91da177e4SLinus Torvalds * Software distributed under the License is distributed on an "AS IS"
101da177e4SLinus Torvalds * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
111da177e4SLinus Torvalds * the License for the specific language governing rights and
121da177e4SLinus Torvalds * limitations under the License.
131da177e4SLinus Torvalds *
141da177e4SLinus Torvalds * The initial developer of the original code is David A. Hinds
151da177e4SLinus Torvalds * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
161da177e4SLinus Torvalds * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
171da177e4SLinus Torvalds *
181da177e4SLinus Torvalds * Alternatively, the contents of this file may be used under the
191da177e4SLinus Torvalds * terms of the GNU General Public License version 2 (the "GPL"), in which
201da177e4SLinus Torvalds * case the provisions of the GPL are applicable instead of the
211da177e4SLinus Torvalds * above. If you wish to allow the use of your version of this file
221da177e4SLinus Torvalds * only under the terms of the GPL and not to allow others to use
231da177e4SLinus Torvalds * your version of this file under the MPL, indicate your decision by
241da177e4SLinus Torvalds * deleting the provisions above and replace them with the notice and
251da177e4SLinus Torvalds * other provisions required by the GPL. If you do not delete the
261da177e4SLinus Torvalds * provisions above, a recipient may use your version of this file
271da177e4SLinus Torvalds * under either the MPL or the GPL.
281da177e4SLinus Torvalds */
291da177e4SLinus Torvalds
301da177e4SLinus Torvalds #ifndef _LINUX_TI113X_H
311da177e4SLinus Torvalds #define _LINUX_TI113X_H
321da177e4SLinus Torvalds
331da177e4SLinus Torvalds
341da177e4SLinus Torvalds /* Register definitions for TI 113X PCI-to-CardBus bridges */
351da177e4SLinus Torvalds
361da177e4SLinus Torvalds /* System Control Register */
371da177e4SLinus Torvalds #define TI113X_SYSTEM_CONTROL 0x0080 /* 32 bit */
381da177e4SLinus Torvalds #define TI113X_SCR_SMIROUTE 0x04000000
391da177e4SLinus Torvalds #define TI113X_SCR_SMISTATUS 0x02000000
401da177e4SLinus Torvalds #define TI113X_SCR_SMIENB 0x01000000
411da177e4SLinus Torvalds #define TI113X_SCR_VCCPROT 0x00200000
421da177e4SLinus Torvalds #define TI113X_SCR_REDUCEZV 0x00100000
431da177e4SLinus Torvalds #define TI113X_SCR_CDREQEN 0x00080000
441da177e4SLinus Torvalds #define TI113X_SCR_CDMACHAN 0x00070000
451da177e4SLinus Torvalds #define TI113X_SCR_SOCACTIVE 0x00002000
461da177e4SLinus Torvalds #define TI113X_SCR_PWRSTREAM 0x00000800
471da177e4SLinus Torvalds #define TI113X_SCR_DELAYUP 0x00000400
481da177e4SLinus Torvalds #define TI113X_SCR_DELAYDOWN 0x00000200
491da177e4SLinus Torvalds #define TI113X_SCR_INTERROGATE 0x00000100
501da177e4SLinus Torvalds #define TI113X_SCR_CLKRUN_SEL 0x00000080
511da177e4SLinus Torvalds #define TI113X_SCR_PWRSAVINGS 0x00000040
521da177e4SLinus Torvalds #define TI113X_SCR_SUBSYSRW 0x00000020
531da177e4SLinus Torvalds #define TI113X_SCR_CB_DPAR 0x00000010
541da177e4SLinus Torvalds #define TI113X_SCR_CDMA_EN 0x00000008
551da177e4SLinus Torvalds #define TI113X_SCR_ASYNC_IRQ 0x00000004
561da177e4SLinus Torvalds #define TI113X_SCR_KEEPCLK 0x00000002
571da177e4SLinus Torvalds #define TI113X_SCR_CLKRUN_ENA 0x00000001
581da177e4SLinus Torvalds
591da177e4SLinus Torvalds #define TI122X_SCR_SER_STEP 0xc0000000
601da177e4SLinus Torvalds #define TI122X_SCR_INTRTIE 0x20000000
616c1a10dbSDaniel Ritz #define TIXX21_SCR_TIEALL 0x10000000
621da177e4SLinus Torvalds #define TI122X_SCR_CBRSVD 0x00400000
631da177e4SLinus Torvalds #define TI122X_SCR_MRBURSTDN 0x00008000
641da177e4SLinus Torvalds #define TI122X_SCR_MRBURSTUP 0x00004000
651da177e4SLinus Torvalds #define TI122X_SCR_RIMUX 0x00000001
661da177e4SLinus Torvalds
671da177e4SLinus Torvalds /* Multimedia Control Register */
681da177e4SLinus Torvalds #define TI1250_MULTIMEDIA_CTL 0x0084 /* 8 bit */
691da177e4SLinus Torvalds #define TI1250_MMC_ZVOUTEN 0x80
701da177e4SLinus Torvalds #define TI1250_MMC_PORTSEL 0x40
711da177e4SLinus Torvalds #define TI1250_MMC_ZVEN1 0x02
721da177e4SLinus Torvalds #define TI1250_MMC_ZVEN0 0x01
731da177e4SLinus Torvalds
741da177e4SLinus Torvalds #define TI1250_GENERAL_STATUS 0x0085 /* 8 bit */
751da177e4SLinus Torvalds #define TI1250_GPIO0_CONTROL 0x0088 /* 8 bit */
761da177e4SLinus Torvalds #define TI1250_GPIO1_CONTROL 0x0089 /* 8 bit */
771da177e4SLinus Torvalds #define TI1250_GPIO2_CONTROL 0x008a /* 8 bit */
781da177e4SLinus Torvalds #define TI1250_GPIO3_CONTROL 0x008b /* 8 bit */
791da177e4SLinus Torvalds #define TI1250_GPIO_MODE_MASK 0xc0
801da177e4SLinus Torvalds
811da177e4SLinus Torvalds /* IRQMUX/MFUNC Register */
821da177e4SLinus Torvalds #define TI122X_MFUNC 0x008c /* 32 bit */
831da177e4SLinus Torvalds #define TI122X_MFUNC0_MASK 0x0000000f
841da177e4SLinus Torvalds #define TI122X_MFUNC1_MASK 0x000000f0
851da177e4SLinus Torvalds #define TI122X_MFUNC2_MASK 0x00000f00
861da177e4SLinus Torvalds #define TI122X_MFUNC3_MASK 0x0000f000
871da177e4SLinus Torvalds #define TI122X_MFUNC4_MASK 0x000f0000
881da177e4SLinus Torvalds #define TI122X_MFUNC5_MASK 0x00f00000
891da177e4SLinus Torvalds #define TI122X_MFUNC6_MASK 0x0f000000
901da177e4SLinus Torvalds
911da177e4SLinus Torvalds #define TI122X_MFUNC0_INTA 0x00000002
921da177e4SLinus Torvalds #define TI125X_MFUNC0_INTB 0x00000001
931da177e4SLinus Torvalds #define TI122X_MFUNC1_INTB 0x00000020
941da177e4SLinus Torvalds #define TI122X_MFUNC3_IRQSER 0x00001000
951da177e4SLinus Torvalds
961da177e4SLinus Torvalds
971da177e4SLinus Torvalds /* Retry Status Register */
981da177e4SLinus Torvalds #define TI113X_RETRY_STATUS 0x0090 /* 8 bit */
991da177e4SLinus Torvalds #define TI113X_RSR_PCIRETRY 0x80
1001da177e4SLinus Torvalds #define TI113X_RSR_CBRETRY 0x40
1011da177e4SLinus Torvalds #define TI113X_RSR_TEXP_CBB 0x20
1021da177e4SLinus Torvalds #define TI113X_RSR_MEXP_CBB 0x10
1031da177e4SLinus Torvalds #define TI113X_RSR_TEXP_CBA 0x08
1041da177e4SLinus Torvalds #define TI113X_RSR_MEXP_CBA 0x04
1051da177e4SLinus Torvalds #define TI113X_RSR_TEXP_PCI 0x02
1061da177e4SLinus Torvalds #define TI113X_RSR_MEXP_PCI 0x01
1071da177e4SLinus Torvalds
1081da177e4SLinus Torvalds /* Card Control Register */
1091da177e4SLinus Torvalds #define TI113X_CARD_CONTROL 0x0091 /* 8 bit */
1101da177e4SLinus Torvalds #define TI113X_CCR_RIENB 0x80
1111da177e4SLinus Torvalds #define TI113X_CCR_ZVENABLE 0x40
1121da177e4SLinus Torvalds #define TI113X_CCR_PCI_IRQ_ENA 0x20
1131da177e4SLinus Torvalds #define TI113X_CCR_PCI_IREQ 0x10
1141da177e4SLinus Torvalds #define TI113X_CCR_PCI_CSC 0x08
1151da177e4SLinus Torvalds #define TI113X_CCR_SPKROUTEN 0x02
1161da177e4SLinus Torvalds #define TI113X_CCR_IFG 0x01
1171da177e4SLinus Torvalds
1181da177e4SLinus Torvalds #define TI1220_CCR_PORT_SEL 0x20
1191da177e4SLinus Torvalds #define TI122X_CCR_AUD2MUX 0x04
1201da177e4SLinus Torvalds
1211da177e4SLinus Torvalds /* Device Control Register */
1221da177e4SLinus Torvalds #define TI113X_DEVICE_CONTROL 0x0092 /* 8 bit */
1231da177e4SLinus Torvalds #define TI113X_DCR_5V_FORCE 0x40
1241da177e4SLinus Torvalds #define TI113X_DCR_3V_FORCE 0x20
1251da177e4SLinus Torvalds #define TI113X_DCR_IMODE_MASK 0x06
1261da177e4SLinus Torvalds #define TI113X_DCR_IMODE_ISA 0x02
1271da177e4SLinus Torvalds #define TI113X_DCR_IMODE_SERIAL 0x04
1281da177e4SLinus Torvalds
1291da177e4SLinus Torvalds #define TI12XX_DCR_IMODE_PCI_ONLY 0x00
1301da177e4SLinus Torvalds #define TI12XX_DCR_IMODE_ALL_SERIAL 0x06
1311da177e4SLinus Torvalds
1321da177e4SLinus Torvalds /* Buffer Control Register */
1331da177e4SLinus Torvalds #define TI113X_BUFFER_CONTROL 0x0093 /* 8 bit */
1341da177e4SLinus Torvalds #define TI113X_BCR_CB_READ_DEPTH 0x08
1351da177e4SLinus Torvalds #define TI113X_BCR_CB_WRITE_DEPTH 0x04
1361da177e4SLinus Torvalds #define TI113X_BCR_PCI_READ_DEPTH 0x02
1371da177e4SLinus Torvalds #define TI113X_BCR_PCI_WRITE_DEPTH 0x01
1381da177e4SLinus Torvalds
1391da177e4SLinus Torvalds /* Diagnostic Register */
1401da177e4SLinus Torvalds #define TI1250_DIAGNOSTIC 0x0093 /* 8 bit */
1411da177e4SLinus Torvalds #define TI1250_DIAG_TRUE_VALUE 0x80
1421da177e4SLinus Torvalds #define TI1250_DIAG_PCI_IREQ 0x40
1431da177e4SLinus Torvalds #define TI1250_DIAG_PCI_CSC 0x20
1441da177e4SLinus Torvalds #define TI1250_DIAG_ASYNC_CSC 0x01
1451da177e4SLinus Torvalds
1461da177e4SLinus Torvalds /* DMA Registers */
1471da177e4SLinus Torvalds #define TI113X_DMA_0 0x0094 /* 32 bit */
1481da177e4SLinus Torvalds #define TI113X_DMA_1 0x0098 /* 32 bit */
1491da177e4SLinus Torvalds
1501da177e4SLinus Torvalds /* ExCA IO offset registers */
1511da177e4SLinus Torvalds #define TI113X_IO_OFFSET(map) (0x36+((map)<<1))
1521da177e4SLinus Torvalds
1531da177e4SLinus Torvalds /* EnE test register */
1541da177e4SLinus Torvalds #define ENE_TEST_C9 0xc9 /* 8bit */
1551da177e4SLinus Torvalds #define ENE_TEST_C9_TLTENABLE 0x02
1568c3520d4SDaniel Ritz #define ENE_TEST_C9_PFENABLE_F0 0x04
1578c3520d4SDaniel Ritz #define ENE_TEST_C9_PFENABLE_F1 0x08
15814540c6dSRoel Kluin #define ENE_TEST_C9_PFENABLE (ENE_TEST_C9_PFENABLE_F0 | ENE_TEST_C9_PFENABLE_F1)
1598c3520d4SDaniel Ritz #define ENE_TEST_C9_WPDISALBLE_F0 0x40
1608c3520d4SDaniel Ritz #define ENE_TEST_C9_WPDISALBLE_F1 0x80
1618c3520d4SDaniel Ritz #define ENE_TEST_C9_WPDISALBLE (ENE_TEST_C9_WPDISALBLE_F0 | ENE_TEST_C9_WPDISALBLE_F1)
1621da177e4SLinus Torvalds
1631da177e4SLinus Torvalds /*
1641da177e4SLinus Torvalds * Texas Instruments CardBus controller overrides.
1651da177e4SLinus Torvalds */
1661da177e4SLinus Torvalds #define ti_sysctl(socket) ((socket)->private[0])
1671da177e4SLinus Torvalds #define ti_cardctl(socket) ((socket)->private[1])
1681da177e4SLinus Torvalds #define ti_devctl(socket) ((socket)->private[2])
1691da177e4SLinus Torvalds #define ti_diag(socket) ((socket)->private[3])
1701da177e4SLinus Torvalds #define ti_mfunc(socket) ((socket)->private[4])
1711da177e4SLinus Torvalds #define ene_test_c9(socket) ((socket)->private[5])
1721da177e4SLinus Torvalds
1731da177e4SLinus Torvalds /*
1741da177e4SLinus Torvalds * These are the TI specific power management handlers.
1751da177e4SLinus Torvalds */
ti_save_state(struct yenta_socket * socket)1761da177e4SLinus Torvalds static void ti_save_state(struct yenta_socket *socket)
1771da177e4SLinus Torvalds {
1781da177e4SLinus Torvalds ti_sysctl(socket) = config_readl(socket, TI113X_SYSTEM_CONTROL);
1791da177e4SLinus Torvalds ti_mfunc(socket) = config_readl(socket, TI122X_MFUNC);
1801da177e4SLinus Torvalds ti_cardctl(socket) = config_readb(socket, TI113X_CARD_CONTROL);
1811da177e4SLinus Torvalds ti_devctl(socket) = config_readb(socket, TI113X_DEVICE_CONTROL);
1821da177e4SLinus Torvalds ti_diag(socket) = config_readb(socket, TI1250_DIAGNOSTIC);
1831da177e4SLinus Torvalds
1841da177e4SLinus Torvalds if (socket->dev->vendor == PCI_VENDOR_ID_ENE)
1851da177e4SLinus Torvalds ene_test_c9(socket) = config_readb(socket, ENE_TEST_C9);
1861da177e4SLinus Torvalds }
1871da177e4SLinus Torvalds
ti_restore_state(struct yenta_socket * socket)1881da177e4SLinus Torvalds static void ti_restore_state(struct yenta_socket *socket)
1891da177e4SLinus Torvalds {
1901da177e4SLinus Torvalds config_writel(socket, TI113X_SYSTEM_CONTROL, ti_sysctl(socket));
1911da177e4SLinus Torvalds config_writel(socket, TI122X_MFUNC, ti_mfunc(socket));
1921da177e4SLinus Torvalds config_writeb(socket, TI113X_CARD_CONTROL, ti_cardctl(socket));
1931da177e4SLinus Torvalds config_writeb(socket, TI113X_DEVICE_CONTROL, ti_devctl(socket));
1941da177e4SLinus Torvalds config_writeb(socket, TI1250_DIAGNOSTIC, ti_diag(socket));
1951da177e4SLinus Torvalds
1961da177e4SLinus Torvalds if (socket->dev->vendor == PCI_VENDOR_ID_ENE)
1971da177e4SLinus Torvalds config_writeb(socket, ENE_TEST_C9, ene_test_c9(socket));
1981da177e4SLinus Torvalds }
1991da177e4SLinus Torvalds
2001da177e4SLinus Torvalds /*
2011da177e4SLinus Torvalds * Zoom video control for TI122x/113x chips
2021da177e4SLinus Torvalds */
2031da177e4SLinus Torvalds
ti_zoom_video(struct pcmcia_socket * sock,int onoff)2041da177e4SLinus Torvalds static void ti_zoom_video(struct pcmcia_socket *sock, int onoff)
2051da177e4SLinus Torvalds {
2061da177e4SLinus Torvalds u8 reg;
2071da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
2081da177e4SLinus Torvalds
2091da177e4SLinus Torvalds /* If we don't have a Zoom Video switch this is harmless,
2101da177e4SLinus Torvalds we just tristate the unused (ZV) lines */
2111da177e4SLinus Torvalds reg = config_readb(socket, TI113X_CARD_CONTROL);
2121da177e4SLinus Torvalds if (onoff)
2131da177e4SLinus Torvalds /* Zoom zoom, we will all go together, zoom zoom, zoom zoom */
2141da177e4SLinus Torvalds reg |= TI113X_CCR_ZVENABLE;
2151da177e4SLinus Torvalds else
2161da177e4SLinus Torvalds reg &= ~TI113X_CCR_ZVENABLE;
2171da177e4SLinus Torvalds config_writeb(socket, TI113X_CARD_CONTROL, reg);
2181da177e4SLinus Torvalds }
2191da177e4SLinus Torvalds
2201da177e4SLinus Torvalds /*
2211da177e4SLinus Torvalds * The 145x series can also use this. They have an additional
2221da177e4SLinus Torvalds * ZV autodetect mode we don't use but don't actually need.
2231da177e4SLinus Torvalds * FIXME: manual says its in func0 and func1 but disagrees with
2241da177e4SLinus Torvalds * itself about this - do we need to force func0, if so we need
2251da177e4SLinus Torvalds * to know a lot more about socket pairings in pcmcia_socket than
2261da177e4SLinus Torvalds * we do now.. uggh.
2271da177e4SLinus Torvalds */
2281da177e4SLinus Torvalds
ti1250_zoom_video(struct pcmcia_socket * sock,int onoff)2291da177e4SLinus Torvalds static void ti1250_zoom_video(struct pcmcia_socket *sock, int onoff)
2301da177e4SLinus Torvalds {
2311da177e4SLinus Torvalds struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
2321da177e4SLinus Torvalds int shift = 0;
2331da177e4SLinus Torvalds u8 reg;
2341da177e4SLinus Torvalds
2351da177e4SLinus Torvalds ti_zoom_video(sock, onoff);
2361da177e4SLinus Torvalds
2371da177e4SLinus Torvalds reg = config_readb(socket, TI1250_MULTIMEDIA_CTL);
2381da177e4SLinus Torvalds reg |= TI1250_MMC_ZVOUTEN; /* ZV bus enable */
2391da177e4SLinus Torvalds
2401da177e4SLinus Torvalds if(PCI_FUNC(socket->dev->devfn)==1)
2411da177e4SLinus Torvalds shift = 1;
2421da177e4SLinus Torvalds
2431da177e4SLinus Torvalds if(onoff)
2441da177e4SLinus Torvalds {
2451da177e4SLinus Torvalds reg &= ~(1<<6); /* Clear select bit */
2461da177e4SLinus Torvalds reg |= shift<<6; /* Favour our socket */
2471da177e4SLinus Torvalds reg |= 1<<shift; /* Socket zoom video on */
2481da177e4SLinus Torvalds }
2491da177e4SLinus Torvalds else
2501da177e4SLinus Torvalds {
2511da177e4SLinus Torvalds reg &= ~(1<<6); /* Clear select bit */
2521da177e4SLinus Torvalds reg |= (1^shift)<<6; /* Favour other socket */
2531da177e4SLinus Torvalds reg &= ~(1<<shift); /* Socket zoon video off */
2541da177e4SLinus Torvalds }
2551da177e4SLinus Torvalds
2561da177e4SLinus Torvalds config_writeb(socket, TI1250_MULTIMEDIA_CTL, reg);
2571da177e4SLinus Torvalds }
2581da177e4SLinus Torvalds
ti_set_zv(struct yenta_socket * socket)2591da177e4SLinus Torvalds static void ti_set_zv(struct yenta_socket *socket)
2601da177e4SLinus Torvalds {
2611da177e4SLinus Torvalds if(socket->dev->vendor == PCI_VENDOR_ID_TI)
2621da177e4SLinus Torvalds {
2631da177e4SLinus Torvalds switch(socket->dev->device)
2641da177e4SLinus Torvalds {
2651da177e4SLinus Torvalds /* There may be more .. */
2661da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1220:
2671da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1221:
2681da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1225:
2691da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_4510:
2701da177e4SLinus Torvalds socket->socket.zoom_video = ti_zoom_video;
2711da177e4SLinus Torvalds break;
2721da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1250:
2731da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1251A:
2741da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1251B:
2751da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1450:
2761da177e4SLinus Torvalds socket->socket.zoom_video = ti1250_zoom_video;
2771da177e4SLinus Torvalds }
2781da177e4SLinus Torvalds }
2791da177e4SLinus Torvalds }
2801da177e4SLinus Torvalds
2811da177e4SLinus Torvalds
2821da177e4SLinus Torvalds /*
2831da177e4SLinus Torvalds * Generic TI init - TI has an extension for the
2841da177e4SLinus Torvalds * INTCTL register that sets the PCI CSC interrupt.
2851da177e4SLinus Torvalds * Make sure we set it correctly at open and init
2861da177e4SLinus Torvalds * time
2871da177e4SLinus Torvalds * - override: disable the PCI CSC interrupt. This makes
2881da177e4SLinus Torvalds * it possible to use the CSC interrupt to probe the
2891da177e4SLinus Torvalds * ISA interrupts.
2901da177e4SLinus Torvalds * - init: set the interrupt to match our PCI state.
2911da177e4SLinus Torvalds * This makes us correctly get PCI CSC interrupt
2921da177e4SLinus Torvalds * events.
2931da177e4SLinus Torvalds */
ti_init(struct yenta_socket * socket)2941da177e4SLinus Torvalds static int ti_init(struct yenta_socket *socket)
2951da177e4SLinus Torvalds {
2961da177e4SLinus Torvalds u8 new, reg = exca_readb(socket, I365_INTCTL);
2971da177e4SLinus Torvalds
2981da177e4SLinus Torvalds new = reg & ~I365_INTR_ENA;
2990d3a940dSJens Künzer if (socket->dev->irq)
3001da177e4SLinus Torvalds new |= I365_INTR_ENA;
3011da177e4SLinus Torvalds if (new != reg)
3021da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, new);
3031da177e4SLinus Torvalds return 0;
3041da177e4SLinus Torvalds }
3051da177e4SLinus Torvalds
ti_override(struct yenta_socket * socket)3061da177e4SLinus Torvalds static int ti_override(struct yenta_socket *socket)
3071da177e4SLinus Torvalds {
3081da177e4SLinus Torvalds u8 new, reg = exca_readb(socket, I365_INTCTL);
3091da177e4SLinus Torvalds
3101da177e4SLinus Torvalds new = reg & ~I365_INTR_ENA;
3111da177e4SLinus Torvalds if (new != reg)
3121da177e4SLinus Torvalds exca_writeb(socket, I365_INTCTL, new);
3131da177e4SLinus Torvalds
3141da177e4SLinus Torvalds ti_set_zv(socket);
3151da177e4SLinus Torvalds
3161da177e4SLinus Torvalds return 0;
3171da177e4SLinus Torvalds }
3181da177e4SLinus Torvalds
ti113x_use_isa_irq(struct yenta_socket * socket)3190d3a940dSJens Künzer static void ti113x_use_isa_irq(struct yenta_socket *socket)
3200d3a940dSJens Künzer {
3210d3a940dSJens Künzer int isa_irq = -1;
3220d3a940dSJens Künzer u8 intctl;
3230d3a940dSJens Künzer u32 isa_irq_mask = 0;
3240d3a940dSJens Künzer
3250d3a940dSJens Künzer if (!isa_probe)
3260d3a940dSJens Künzer return;
3270d3a940dSJens Künzer
3280d3a940dSJens Künzer /* get a free isa int */
3290d3a940dSJens Künzer isa_irq_mask = yenta_probe_irq(socket, isa_interrupts);
3300d3a940dSJens Künzer if (!isa_irq_mask)
3310d3a940dSJens Künzer return; /* no useable isa irq found */
3320d3a940dSJens Künzer
3330d3a940dSJens Künzer /* choose highest available */
3340d3a940dSJens Künzer for (; isa_irq_mask; isa_irq++)
3350d3a940dSJens Künzer isa_irq_mask >>= 1;
3360d3a940dSJens Künzer socket->cb_irq = isa_irq;
3370d3a940dSJens Künzer
3380d3a940dSJens Künzer exca_writeb(socket, I365_CSCINT, (isa_irq << 4));
3390d3a940dSJens Künzer
3400d3a940dSJens Künzer intctl = exca_readb(socket, I365_INTCTL);
3410d3a940dSJens Künzer intctl &= ~(I365_INTR_ENA | I365_IRQ_MASK); /* CSC Enable */
3420d3a940dSJens Künzer exca_writeb(socket, I365_INTCTL, intctl);
3430d3a940dSJens Künzer
3440d3a940dSJens Künzer dev_info(&socket->dev->dev,
3450d3a940dSJens Künzer "Yenta TI113x: using isa irq %d for CardBus\n", isa_irq);
3460d3a940dSJens Künzer }
3470d3a940dSJens Künzer
3480d3a940dSJens Künzer
ti113x_override(struct yenta_socket * socket)3491da177e4SLinus Torvalds static int ti113x_override(struct yenta_socket *socket)
3501da177e4SLinus Torvalds {
3511da177e4SLinus Torvalds u8 cardctl;
3521da177e4SLinus Torvalds
3531da177e4SLinus Torvalds cardctl = config_readb(socket, TI113X_CARD_CONTROL);
3541da177e4SLinus Torvalds cardctl &= ~(TI113X_CCR_PCI_IRQ_ENA | TI113X_CCR_PCI_IREQ | TI113X_CCR_PCI_CSC);
3550d3a940dSJens Künzer if (socket->dev->irq)
3561da177e4SLinus Torvalds cardctl |= TI113X_CCR_PCI_IRQ_ENA | TI113X_CCR_PCI_CSC | TI113X_CCR_PCI_IREQ;
3570d3a940dSJens Künzer else
3580d3a940dSJens Künzer ti113x_use_isa_irq(socket);
3590d3a940dSJens Künzer
3601da177e4SLinus Torvalds config_writeb(socket, TI113X_CARD_CONTROL, cardctl);
3611da177e4SLinus Torvalds
3621da177e4SLinus Torvalds return ti_override(socket);
3631da177e4SLinus Torvalds }
3641da177e4SLinus Torvalds
3651da177e4SLinus Torvalds
3661da177e4SLinus Torvalds /* irqrouting for func0, probes PCI interrupt and ISA interrupts */
ti12xx_irqroute_func0(struct yenta_socket * socket)3671da177e4SLinus Torvalds static void ti12xx_irqroute_func0(struct yenta_socket *socket)
3681da177e4SLinus Torvalds {
3691da177e4SLinus Torvalds u32 mfunc, mfunc_old, devctl;
3701da177e4SLinus Torvalds u8 gpio3, gpio3_old;
3711da177e4SLinus Torvalds int pci_irq_status;
3721da177e4SLinus Torvalds
3731da177e4SLinus Torvalds mfunc = mfunc_old = config_readl(socket, TI122X_MFUNC);
3741da177e4SLinus Torvalds devctl = config_readb(socket, TI113X_DEVICE_CONTROL);
375f2e6cf76SJoe Perches dev_info(&socket->dev->dev, "TI: mfunc 0x%08x, devctl 0x%02x\n",
376f2e6cf76SJoe Perches mfunc, devctl);
3771da177e4SLinus Torvalds
3781da177e4SLinus Torvalds /* make sure PCI interrupts are enabled before probing */
3791da177e4SLinus Torvalds ti_init(socket);
3801da177e4SLinus Torvalds
3811da177e4SLinus Torvalds /* test PCI interrupts first. only try fixing if return value is 0! */
3821da177e4SLinus Torvalds pci_irq_status = yenta_probe_cb_irq(socket);
3831da177e4SLinus Torvalds if (pci_irq_status)
3841da177e4SLinus Torvalds goto out;
3851da177e4SLinus Torvalds
3861da177e4SLinus Torvalds /*
3871da177e4SLinus Torvalds * We're here which means PCI interrupts are _not_ delivered. try to
3881da177e4SLinus Torvalds * find the right setting (all serial or parallel)
3891da177e4SLinus Torvalds */
390f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
391dd797d81SDominik Brodowski "TI: probing PCI interrupt failed, trying to fix\n");
3921da177e4SLinus Torvalds
3931da177e4SLinus Torvalds /* for serial PCI make sure MFUNC3 is set to IRQSER */
3941da177e4SLinus Torvalds if ((devctl & TI113X_DCR_IMODE_MASK) == TI12XX_DCR_IMODE_ALL_SERIAL) {
3951da177e4SLinus Torvalds switch (socket->dev->device) {
3961da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1250:
3971da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1251A:
3981da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1251B:
3991da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1450:
4001da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1451A:
4011da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_4450:
4021da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_4451:
4031da177e4SLinus Torvalds /* these chips have no IRQSER setting in MFUNC3 */
4041da177e4SLinus Torvalds break;
4051da177e4SLinus Torvalds
4061da177e4SLinus Torvalds default:
4071da177e4SLinus Torvalds mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER;
4081da177e4SLinus Torvalds
4091da177e4SLinus Torvalds /* write down if changed, probe */
4101da177e4SLinus Torvalds if (mfunc != mfunc_old) {
4111da177e4SLinus Torvalds config_writel(socket, TI122X_MFUNC, mfunc);
4121da177e4SLinus Torvalds
4131da177e4SLinus Torvalds pci_irq_status = yenta_probe_cb_irq(socket);
4141da177e4SLinus Torvalds if (pci_irq_status == 1) {
415f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
416dd797d81SDominik Brodowski "TI: all-serial interrupts ok\n");
4171da177e4SLinus Torvalds mfunc_old = mfunc;
4181da177e4SLinus Torvalds goto out;
4191da177e4SLinus Torvalds }
4201da177e4SLinus Torvalds
4211da177e4SLinus Torvalds /* not working, back to old value */
4221da177e4SLinus Torvalds mfunc = mfunc_old;
4231da177e4SLinus Torvalds config_writel(socket, TI122X_MFUNC, mfunc);
4241da177e4SLinus Torvalds
4251da177e4SLinus Torvalds if (pci_irq_status == -1)
4261da177e4SLinus Torvalds goto out;
4271da177e4SLinus Torvalds }
4281da177e4SLinus Torvalds }
4291da177e4SLinus Torvalds
4301da177e4SLinus Torvalds /* serial PCI interrupts not working fall back to parallel */
431f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
432dd797d81SDominik Brodowski "TI: falling back to parallel PCI interrupts\n");
4331da177e4SLinus Torvalds devctl &= ~TI113X_DCR_IMODE_MASK;
4341da177e4SLinus Torvalds devctl |= TI113X_DCR_IMODE_SERIAL; /* serial ISA could be right */
4351da177e4SLinus Torvalds config_writeb(socket, TI113X_DEVICE_CONTROL, devctl);
4361da177e4SLinus Torvalds }
4371da177e4SLinus Torvalds
4381da177e4SLinus Torvalds /* parallel PCI interrupts: route INTA */
4391da177e4SLinus Torvalds switch (socket->dev->device) {
4401da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1250:
4411da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1251A:
4421da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1251B:
4431da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1450:
4441da177e4SLinus Torvalds /* make sure GPIO3 is set to INTA */
4451da177e4SLinus Torvalds gpio3 = gpio3_old = config_readb(socket, TI1250_GPIO3_CONTROL);
4461da177e4SLinus Torvalds gpio3 &= ~TI1250_GPIO_MODE_MASK;
4471da177e4SLinus Torvalds if (gpio3 != gpio3_old)
4481da177e4SLinus Torvalds config_writeb(socket, TI1250_GPIO3_CONTROL, gpio3);
4491da177e4SLinus Torvalds break;
4501da177e4SLinus Torvalds
4511da177e4SLinus Torvalds default:
4521da177e4SLinus Torvalds gpio3 = gpio3_old = 0;
4531da177e4SLinus Torvalds
4541da177e4SLinus Torvalds mfunc = (mfunc & ~TI122X_MFUNC0_MASK) | TI122X_MFUNC0_INTA;
4551da177e4SLinus Torvalds if (mfunc != mfunc_old)
4561da177e4SLinus Torvalds config_writel(socket, TI122X_MFUNC, mfunc);
4571da177e4SLinus Torvalds }
4581da177e4SLinus Torvalds
4591da177e4SLinus Torvalds /* time to probe again */
4601da177e4SLinus Torvalds pci_irq_status = yenta_probe_cb_irq(socket);
4611da177e4SLinus Torvalds if (pci_irq_status == 1) {
4621da177e4SLinus Torvalds mfunc_old = mfunc;
463f2e6cf76SJoe Perches dev_info(&socket->dev->dev, "TI: parallel PCI interrupts ok\n");
4641da177e4SLinus Torvalds } else {
4651da177e4SLinus Torvalds /* not working, back to old value */
4661da177e4SLinus Torvalds mfunc = mfunc_old;
4671da177e4SLinus Torvalds config_writel(socket, TI122X_MFUNC, mfunc);
4681da177e4SLinus Torvalds if (gpio3 != gpio3_old)
4691da177e4SLinus Torvalds config_writeb(socket, TI1250_GPIO3_CONTROL, gpio3_old);
4701da177e4SLinus Torvalds }
4711da177e4SLinus Torvalds
4721da177e4SLinus Torvalds out:
4731da177e4SLinus Torvalds if (pci_irq_status < 1) {
4741da177e4SLinus Torvalds socket->cb_irq = 0;
475f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
476f2e6cf76SJoe Perches "Yenta TI: no PCI interrupts. Fish. Please report.\n");
4771da177e4SLinus Torvalds }
4781da177e4SLinus Torvalds }
4791da177e4SLinus Torvalds
4801da177e4SLinus Torvalds
481c835a388SDaniel Ritz /* changes the irq of func1 to match that of func0 */
ti12xx_align_irqs(struct yenta_socket * socket,int * old_irq)482c835a388SDaniel Ritz static int ti12xx_align_irqs(struct yenta_socket *socket, int *old_irq)
483c835a388SDaniel Ritz {
484c835a388SDaniel Ritz struct pci_dev *func0;
485c835a388SDaniel Ritz
486c835a388SDaniel Ritz /* find func0 device */
487c835a388SDaniel Ritz func0 = pci_get_slot(socket->dev->bus, socket->dev->devfn & ~0x07);
488c835a388SDaniel Ritz if (!func0)
489c835a388SDaniel Ritz return 0;
490c835a388SDaniel Ritz
491c835a388SDaniel Ritz if (old_irq)
492c835a388SDaniel Ritz *old_irq = socket->cb_irq;
493c835a388SDaniel Ritz socket->cb_irq = socket->dev->irq = func0->irq;
494c835a388SDaniel Ritz
495c835a388SDaniel Ritz pci_dev_put(func0);
496c835a388SDaniel Ritz
497c835a388SDaniel Ritz return 1;
498c835a388SDaniel Ritz }
499c835a388SDaniel Ritz
5001da177e4SLinus Torvalds /*
5011da177e4SLinus Torvalds * ties INTA and INTB together. also changes the devices irq to that of
5021da177e4SLinus Torvalds * the function 0 device. call from func1 only.
5031da177e4SLinus Torvalds * returns 1 if INTRTIE changed, 0 otherwise.
5041da177e4SLinus Torvalds */
ti12xx_tie_interrupts(struct yenta_socket * socket,int * old_irq)5051da177e4SLinus Torvalds static int ti12xx_tie_interrupts(struct yenta_socket *socket, int *old_irq)
5061da177e4SLinus Torvalds {
5071da177e4SLinus Torvalds u32 sysctl;
508c835a388SDaniel Ritz int ret;
5091da177e4SLinus Torvalds
5101da177e4SLinus Torvalds sysctl = config_readl(socket, TI113X_SYSTEM_CONTROL);
5111da177e4SLinus Torvalds if (sysctl & TI122X_SCR_INTRTIE)
5121da177e4SLinus Torvalds return 0;
5131da177e4SLinus Torvalds
514c835a388SDaniel Ritz /* align */
515c835a388SDaniel Ritz ret = ti12xx_align_irqs(socket, old_irq);
516c835a388SDaniel Ritz if (!ret)
5171da177e4SLinus Torvalds return 0;
5181da177e4SLinus Torvalds
519c835a388SDaniel Ritz /* tie */
5201da177e4SLinus Torvalds sysctl |= TI122X_SCR_INTRTIE;
5211da177e4SLinus Torvalds config_writel(socket, TI113X_SYSTEM_CONTROL, sysctl);
5221da177e4SLinus Torvalds
5231da177e4SLinus Torvalds return 1;
5241da177e4SLinus Torvalds }
5251da177e4SLinus Torvalds
5261da177e4SLinus Torvalds /* undo what ti12xx_tie_interrupts() did */
ti12xx_untie_interrupts(struct yenta_socket * socket,int old_irq)5271da177e4SLinus Torvalds static void ti12xx_untie_interrupts(struct yenta_socket *socket, int old_irq)
5281da177e4SLinus Torvalds {
5291da177e4SLinus Torvalds u32 sysctl = config_readl(socket, TI113X_SYSTEM_CONTROL);
5301da177e4SLinus Torvalds sysctl &= ~TI122X_SCR_INTRTIE;
5311da177e4SLinus Torvalds config_writel(socket, TI113X_SYSTEM_CONTROL, sysctl);
5321da177e4SLinus Torvalds
5331da177e4SLinus Torvalds socket->cb_irq = socket->dev->irq = old_irq;
5341da177e4SLinus Torvalds }
5351da177e4SLinus Torvalds
5361da177e4SLinus Torvalds /*
5371da177e4SLinus Torvalds * irqrouting for func1, plays with INTB routing
5381da177e4SLinus Torvalds * only touches MFUNC for INTB routing. all other bits are taken
5391da177e4SLinus Torvalds * care of in func0 already.
5401da177e4SLinus Torvalds */
ti12xx_irqroute_func1(struct yenta_socket * socket)5411da177e4SLinus Torvalds static void ti12xx_irqroute_func1(struct yenta_socket *socket)
5421da177e4SLinus Torvalds {
543c835a388SDaniel Ritz u32 mfunc, mfunc_old, devctl, sysctl;
5441da177e4SLinus Torvalds int pci_irq_status;
5451da177e4SLinus Torvalds
5461da177e4SLinus Torvalds mfunc = mfunc_old = config_readl(socket, TI122X_MFUNC);
5471da177e4SLinus Torvalds devctl = config_readb(socket, TI113X_DEVICE_CONTROL);
548f2e6cf76SJoe Perches dev_info(&socket->dev->dev, "TI: mfunc 0x%08x, devctl 0x%02x\n",
549dd797d81SDominik Brodowski mfunc, devctl);
5501da177e4SLinus Torvalds
551c835a388SDaniel Ritz /* if IRQs are configured as tied, align irq of func1 with func0 */
552c835a388SDaniel Ritz sysctl = config_readl(socket, TI113X_SYSTEM_CONTROL);
553c835a388SDaniel Ritz if (sysctl & TI122X_SCR_INTRTIE)
554c835a388SDaniel Ritz ti12xx_align_irqs(socket, NULL);
555c835a388SDaniel Ritz
5561da177e4SLinus Torvalds /* make sure PCI interrupts are enabled before probing */
5571da177e4SLinus Torvalds ti_init(socket);
5581da177e4SLinus Torvalds
5591da177e4SLinus Torvalds /* test PCI interrupts first. only try fixing if return value is 0! */
5601da177e4SLinus Torvalds pci_irq_status = yenta_probe_cb_irq(socket);
5611da177e4SLinus Torvalds if (pci_irq_status)
5621da177e4SLinus Torvalds goto out;
5631da177e4SLinus Torvalds
5641da177e4SLinus Torvalds /*
5651da177e4SLinus Torvalds * We're here which means PCI interrupts are _not_ delivered. try to
5661da177e4SLinus Torvalds * find the right setting
5671da177e4SLinus Torvalds */
568f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
569dd797d81SDominik Brodowski "TI: probing PCI interrupt failed, trying to fix\n");
5701da177e4SLinus Torvalds
5711da177e4SLinus Torvalds /* if all serial: set INTRTIE, probe again */
5721da177e4SLinus Torvalds if ((devctl & TI113X_DCR_IMODE_MASK) == TI12XX_DCR_IMODE_ALL_SERIAL) {
5731da177e4SLinus Torvalds int old_irq;
5741da177e4SLinus Torvalds
5751da177e4SLinus Torvalds if (ti12xx_tie_interrupts(socket, &old_irq)) {
5761da177e4SLinus Torvalds pci_irq_status = yenta_probe_cb_irq(socket);
5771da177e4SLinus Torvalds if (pci_irq_status == 1) {
578f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
579dd797d81SDominik Brodowski "TI: all-serial interrupts, tied ok\n");
5801da177e4SLinus Torvalds goto out;
5811da177e4SLinus Torvalds }
5821da177e4SLinus Torvalds
5831da177e4SLinus Torvalds ti12xx_untie_interrupts(socket, old_irq);
5841da177e4SLinus Torvalds }
5851da177e4SLinus Torvalds }
5861da177e4SLinus Torvalds /* parallel PCI: route INTB, probe again */
5871da177e4SLinus Torvalds else {
5881da177e4SLinus Torvalds int old_irq;
5891da177e4SLinus Torvalds
5901da177e4SLinus Torvalds switch (socket->dev->device) {
5911da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1250:
5921da177e4SLinus Torvalds /* the 1250 has one pin for IRQSER/INTB depending on devctl */
5931da177e4SLinus Torvalds break;
5941da177e4SLinus Torvalds
5951da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1251A:
5961da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1251B:
5971da177e4SLinus Torvalds case PCI_DEVICE_ID_TI_1450:
5981da177e4SLinus Torvalds /*
5991da177e4SLinus Torvalds * those have a pin for IRQSER/INTB plus INTB in MFUNC0
6001da177e4SLinus Torvalds * we alread probed the shared pin, now go for MFUNC0
6011da177e4SLinus Torvalds */
6021da177e4SLinus Torvalds mfunc = (mfunc & ~TI122X_MFUNC0_MASK) | TI125X_MFUNC0_INTB;
6031da177e4SLinus Torvalds break;
6041da177e4SLinus Torvalds
6051da177e4SLinus Torvalds default:
6061da177e4SLinus Torvalds mfunc = (mfunc & ~TI122X_MFUNC1_MASK) | TI122X_MFUNC1_INTB;
6071da177e4SLinus Torvalds break;
6081da177e4SLinus Torvalds }
6091da177e4SLinus Torvalds
6101da177e4SLinus Torvalds /* write, probe */
6111da177e4SLinus Torvalds if (mfunc != mfunc_old) {
6121da177e4SLinus Torvalds config_writel(socket, TI122X_MFUNC, mfunc);
6131da177e4SLinus Torvalds
6141da177e4SLinus Torvalds pci_irq_status = yenta_probe_cb_irq(socket);
6151da177e4SLinus Torvalds if (pci_irq_status == 1) {
616f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
617dd797d81SDominik Brodowski "TI: parallel PCI interrupts ok\n");
6181da177e4SLinus Torvalds goto out;
6191da177e4SLinus Torvalds }
6201da177e4SLinus Torvalds
6211da177e4SLinus Torvalds mfunc = mfunc_old;
6221da177e4SLinus Torvalds config_writel(socket, TI122X_MFUNC, mfunc);
6231da177e4SLinus Torvalds
6241da177e4SLinus Torvalds if (pci_irq_status == -1)
6251da177e4SLinus Torvalds goto out;
6261da177e4SLinus Torvalds }
6271da177e4SLinus Torvalds
6281da177e4SLinus Torvalds /* still nothing: set INTRTIE */
6291da177e4SLinus Torvalds if (ti12xx_tie_interrupts(socket, &old_irq)) {
6301da177e4SLinus Torvalds pci_irq_status = yenta_probe_cb_irq(socket);
6311da177e4SLinus Torvalds if (pci_irq_status == 1) {
632f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
633dd797d81SDominik Brodowski "TI: parallel PCI interrupts, tied ok\n");
6341da177e4SLinus Torvalds goto out;
6351da177e4SLinus Torvalds }
6361da177e4SLinus Torvalds
6371da177e4SLinus Torvalds ti12xx_untie_interrupts(socket, old_irq);
6381da177e4SLinus Torvalds }
6391da177e4SLinus Torvalds }
6401da177e4SLinus Torvalds
6411da177e4SLinus Torvalds out:
6421da177e4SLinus Torvalds if (pci_irq_status < 1) {
6431da177e4SLinus Torvalds socket->cb_irq = 0;
644f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
645dd797d81SDominik Brodowski "TI: no PCI interrupts. Fish. Please report.\n");
6461da177e4SLinus Torvalds }
6471da177e4SLinus Torvalds }
6481da177e4SLinus Torvalds
649fa912bcbSDaniel Ritz
650fa912bcbSDaniel Ritz /* Returns true value if the second slot of a two-slot controller is empty */
ti12xx_2nd_slot_empty(struct yenta_socket * socket)651fa912bcbSDaniel Ritz static int ti12xx_2nd_slot_empty(struct yenta_socket *socket)
652fa912bcbSDaniel Ritz {
653fa912bcbSDaniel Ritz struct pci_dev *func;
654fa912bcbSDaniel Ritz struct yenta_socket *slot2;
655fa912bcbSDaniel Ritz int devfn;
656fa912bcbSDaniel Ritz unsigned int state;
657fa912bcbSDaniel Ritz int ret = 1;
6586c1a10dbSDaniel Ritz u32 sysctl;
659fa912bcbSDaniel Ritz
660fa912bcbSDaniel Ritz /* catch the two-slot controllers */
661fa912bcbSDaniel Ritz switch (socket->dev->device) {
662fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1220:
663fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1221:
664fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1225:
665fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1251A:
666fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1251B:
667fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1420:
668fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1450:
669fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1451A:
670fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1520:
671fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1620:
672fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_4520:
673fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_4450:
674fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_4451:
675fa912bcbSDaniel Ritz /*
676fa912bcbSDaniel Ritz * there are way more, but they need to be added in yenta_socket.c
677fa912bcbSDaniel Ritz * and pci_ids.h first anyway.
678fa912bcbSDaniel Ritz */
679fa912bcbSDaniel Ritz break;
680fa912bcbSDaniel Ritz
68159e35ba1SAlex Williamson case PCI_DEVICE_ID_TI_XX12:
6826c1a10dbSDaniel Ritz case PCI_DEVICE_ID_TI_X515:
6836c1a10dbSDaniel Ritz case PCI_DEVICE_ID_TI_X420:
6846c1a10dbSDaniel Ritz case PCI_DEVICE_ID_TI_X620:
6856c1a10dbSDaniel Ritz case PCI_DEVICE_ID_TI_XX21_XX11:
6866c1a10dbSDaniel Ritz case PCI_DEVICE_ID_TI_7410:
6876c1a10dbSDaniel Ritz case PCI_DEVICE_ID_TI_7610:
6886c1a10dbSDaniel Ritz /*
6896c1a10dbSDaniel Ritz * those are either single or dual slot CB with additional functions
6906c1a10dbSDaniel Ritz * like 1394, smartcard reader, etc. check the TIEALL flag for them
69125985edcSLucas De Marchi * the TIEALL flag binds the IRQ of all functions together.
6926c1a10dbSDaniel Ritz * we catch the single slot variants later.
6936c1a10dbSDaniel Ritz */
6946c1a10dbSDaniel Ritz sysctl = config_readl(socket, TI113X_SYSTEM_CONTROL);
6956c1a10dbSDaniel Ritz if (sysctl & TIXX21_SCR_TIEALL)
6966c1a10dbSDaniel Ritz return 0;
6976c1a10dbSDaniel Ritz
6986c1a10dbSDaniel Ritz break;
6996c1a10dbSDaniel Ritz
700fa912bcbSDaniel Ritz /* single-slot controllers have the 2nd slot empty always :) */
701fa912bcbSDaniel Ritz default:
702fa912bcbSDaniel Ritz return 1;
703fa912bcbSDaniel Ritz }
704fa912bcbSDaniel Ritz
705fa912bcbSDaniel Ritz /* get other slot */
706fa912bcbSDaniel Ritz devfn = socket->dev->devfn & ~0x07;
707fa912bcbSDaniel Ritz func = pci_get_slot(socket->dev->bus,
708fa912bcbSDaniel Ritz (socket->dev->devfn & 0x07) ? devfn : devfn | 0x01);
709fa912bcbSDaniel Ritz if (!func)
710fa912bcbSDaniel Ritz return 1;
711fa912bcbSDaniel Ritz
7126c1a10dbSDaniel Ritz /*
7136c1a10dbSDaniel Ritz * check that the device id of both slots match. this is needed for the
7146c1a10dbSDaniel Ritz * XX21 and the XX11 controller that share the same device id for single
7156c1a10dbSDaniel Ritz * and dual slot controllers. return '2nd slot empty'. we already checked
7166c1a10dbSDaniel Ritz * if the interrupt is tied to another function.
7176c1a10dbSDaniel Ritz */
7186c1a10dbSDaniel Ritz if (socket->dev->device != func->device)
7196c1a10dbSDaniel Ritz goto out;
7206c1a10dbSDaniel Ritz
721fa912bcbSDaniel Ritz slot2 = pci_get_drvdata(func);
722fa912bcbSDaniel Ritz if (!slot2)
723fa912bcbSDaniel Ritz goto out;
724fa912bcbSDaniel Ritz
725fa912bcbSDaniel Ritz /* check state */
72605f43d48SAlex Harford yenta_get_status(&slot2->socket, &state);
727fa912bcbSDaniel Ritz if (state & SS_DETECT) {
728fa912bcbSDaniel Ritz ret = 0;
729fa912bcbSDaniel Ritz goto out;
730fa912bcbSDaniel Ritz }
731fa912bcbSDaniel Ritz
732fa912bcbSDaniel Ritz out:
733fa912bcbSDaniel Ritz pci_dev_put(func);
734fa912bcbSDaniel Ritz return ret;
735fa912bcbSDaniel Ritz }
736fa912bcbSDaniel Ritz
737fa912bcbSDaniel Ritz /*
738fa912bcbSDaniel Ritz * TI specifiy parts for the power hook.
739fa912bcbSDaniel Ritz *
740fa912bcbSDaniel Ritz * some TI's with some CB's produces interrupt storm on power on. it has been
741fa912bcbSDaniel Ritz * seen with atheros wlan cards on TI1225 and TI1410. solution is simply to
742fa912bcbSDaniel Ritz * disable any CB interrupts during this time.
743fa912bcbSDaniel Ritz */
ti12xx_power_hook(struct pcmcia_socket * sock,int operation)744fa912bcbSDaniel Ritz static int ti12xx_power_hook(struct pcmcia_socket *sock, int operation)
745fa912bcbSDaniel Ritz {
746fa912bcbSDaniel Ritz struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
747fa912bcbSDaniel Ritz u32 mfunc, devctl, sysctl;
748fa912bcbSDaniel Ritz u8 gpio3;
749fa912bcbSDaniel Ritz
750fa912bcbSDaniel Ritz /* only POWER_PRE and POWER_POST are interesting */
751fa912bcbSDaniel Ritz if ((operation != HOOK_POWER_PRE) && (operation != HOOK_POWER_POST))
752fa912bcbSDaniel Ritz return 0;
753fa912bcbSDaniel Ritz
754fa912bcbSDaniel Ritz devctl = config_readb(socket, TI113X_DEVICE_CONTROL);
755fa912bcbSDaniel Ritz sysctl = config_readl(socket, TI113X_SYSTEM_CONTROL);
756fa912bcbSDaniel Ritz mfunc = config_readl(socket, TI122X_MFUNC);
757fa912bcbSDaniel Ritz
758fa912bcbSDaniel Ritz /*
759fa912bcbSDaniel Ritz * all serial/tied: only disable when modparm set. always doing it
760fa912bcbSDaniel Ritz * would mean a regression for working setups 'cos it disables the
761fa912bcbSDaniel Ritz * interrupts for both both slots on 2-slot controllers
762fa912bcbSDaniel Ritz * (and users of single slot controllers where it's save have to
763fa912bcbSDaniel Ritz * live with setting the modparm, most don't have to anyway)
764fa912bcbSDaniel Ritz */
765fa912bcbSDaniel Ritz if (((devctl & TI113X_DCR_IMODE_MASK) == TI12XX_DCR_IMODE_ALL_SERIAL) &&
766fa912bcbSDaniel Ritz (pwr_irqs_off || ti12xx_2nd_slot_empty(socket))) {
767fa912bcbSDaniel Ritz switch (socket->dev->device) {
768fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1250:
769fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1251A:
770fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1251B:
771fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1450:
772fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1451A:
773fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_4450:
774fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_4451:
775fa912bcbSDaniel Ritz /* these chips have no IRQSER setting in MFUNC3 */
776fa912bcbSDaniel Ritz break;
777fa912bcbSDaniel Ritz
778fa912bcbSDaniel Ritz default:
779fa912bcbSDaniel Ritz if (operation == HOOK_POWER_PRE)
780fa912bcbSDaniel Ritz mfunc = (mfunc & ~TI122X_MFUNC3_MASK);
781fa912bcbSDaniel Ritz else
782fa912bcbSDaniel Ritz mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER;
783fa912bcbSDaniel Ritz }
784fa912bcbSDaniel Ritz
785fa912bcbSDaniel Ritz return 0;
786fa912bcbSDaniel Ritz }
787fa912bcbSDaniel Ritz
788fa912bcbSDaniel Ritz /* do the job differently for func0/1 */
789fa912bcbSDaniel Ritz if ((PCI_FUNC(socket->dev->devfn) == 0) ||
790fa912bcbSDaniel Ritz ((sysctl & TI122X_SCR_INTRTIE) &&
791fa912bcbSDaniel Ritz (pwr_irqs_off || ti12xx_2nd_slot_empty(socket)))) {
792fa912bcbSDaniel Ritz /* some bridges are different */
793fa912bcbSDaniel Ritz switch (socket->dev->device) {
794fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1250:
795fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1251A:
796fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1251B:
797fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1450:
798fa912bcbSDaniel Ritz /* those oldies use gpio3 for INTA */
799fa912bcbSDaniel Ritz gpio3 = config_readb(socket, TI1250_GPIO3_CONTROL);
800fa912bcbSDaniel Ritz if (operation == HOOK_POWER_PRE)
801fa912bcbSDaniel Ritz gpio3 = (gpio3 & ~TI1250_GPIO_MODE_MASK) | 0x40;
802fa912bcbSDaniel Ritz else
803fa912bcbSDaniel Ritz gpio3 &= ~TI1250_GPIO_MODE_MASK;
804fa912bcbSDaniel Ritz config_writeb(socket, TI1250_GPIO3_CONTROL, gpio3);
805fa912bcbSDaniel Ritz break;
806fa912bcbSDaniel Ritz
807fa912bcbSDaniel Ritz default:
808fa912bcbSDaniel Ritz /* all new bridges are the same */
809fa912bcbSDaniel Ritz if (operation == HOOK_POWER_PRE)
810fa912bcbSDaniel Ritz mfunc &= ~TI122X_MFUNC0_MASK;
811fa912bcbSDaniel Ritz else
812fa912bcbSDaniel Ritz mfunc |= TI122X_MFUNC0_INTA;
813fa912bcbSDaniel Ritz config_writel(socket, TI122X_MFUNC, mfunc);
814fa912bcbSDaniel Ritz }
815fa912bcbSDaniel Ritz } else {
816fa912bcbSDaniel Ritz switch (socket->dev->device) {
817fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1251A:
818fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1251B:
819fa912bcbSDaniel Ritz case PCI_DEVICE_ID_TI_1450:
820fa912bcbSDaniel Ritz /* those have INTA elsewhere and INTB in MFUNC0 */
821fa912bcbSDaniel Ritz if (operation == HOOK_POWER_PRE)
822fa912bcbSDaniel Ritz mfunc &= ~TI122X_MFUNC0_MASK;
823fa912bcbSDaniel Ritz else
824fa912bcbSDaniel Ritz mfunc |= TI125X_MFUNC0_INTB;
825fa912bcbSDaniel Ritz config_writel(socket, TI122X_MFUNC, mfunc);
826fa912bcbSDaniel Ritz
827fa912bcbSDaniel Ritz break;
828fa912bcbSDaniel Ritz
829fa912bcbSDaniel Ritz default:
830fa912bcbSDaniel Ritz /* all new bridges are the same */
831fa912bcbSDaniel Ritz if (operation == HOOK_POWER_PRE)
832fa912bcbSDaniel Ritz mfunc &= ~TI122X_MFUNC1_MASK;
833fa912bcbSDaniel Ritz else
834fa912bcbSDaniel Ritz mfunc |= TI122X_MFUNC1_INTB;
835fa912bcbSDaniel Ritz config_writel(socket, TI122X_MFUNC, mfunc);
836fa912bcbSDaniel Ritz }
837fa912bcbSDaniel Ritz }
838fa912bcbSDaniel Ritz
839fa912bcbSDaniel Ritz return 0;
840fa912bcbSDaniel Ritz }
841fa912bcbSDaniel Ritz
ti12xx_override(struct yenta_socket * socket)8421da177e4SLinus Torvalds static int ti12xx_override(struct yenta_socket *socket)
8431da177e4SLinus Torvalds {
8441da177e4SLinus Torvalds u32 val, val_orig;
8451da177e4SLinus Torvalds
8461da177e4SLinus Torvalds /* make sure that memory burst is active */
8471da177e4SLinus Torvalds val_orig = val = config_readl(socket, TI113X_SYSTEM_CONTROL);
8481da177e4SLinus Torvalds if (disable_clkrun && PCI_FUNC(socket->dev->devfn) == 0) {
849f2e6cf76SJoe Perches dev_info(&socket->dev->dev, "Disabling CLKRUN feature\n");
8501da177e4SLinus Torvalds val |= TI113X_SCR_KEEPCLK;
8511da177e4SLinus Torvalds }
8521da177e4SLinus Torvalds if (!(val & TI122X_SCR_MRBURSTUP)) {
853f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
854dd797d81SDominik Brodowski "Enabling burst memory read transactions\n");
8551da177e4SLinus Torvalds val |= TI122X_SCR_MRBURSTUP;
8561da177e4SLinus Torvalds }
8571da177e4SLinus Torvalds if (val_orig != val)
8581da177e4SLinus Torvalds config_writel(socket, TI113X_SYSTEM_CONTROL, val);
8591da177e4SLinus Torvalds
8601da177e4SLinus Torvalds /*
8611da177e4SLinus Torvalds * Yenta expects controllers to use CSCINT to route
8621da177e4SLinus Torvalds * CSC interrupts to PCI rather than INTVAL.
8631da177e4SLinus Torvalds */
8641da177e4SLinus Torvalds val = config_readb(socket, TI1250_DIAGNOSTIC);
865f2e6cf76SJoe Perches dev_info(&socket->dev->dev, "Using %s to route CSC interrupts to PCI\n",
8661da177e4SLinus Torvalds (val & TI1250_DIAG_PCI_CSC) ? "CSCINT" : "INTVAL");
867f2e6cf76SJoe Perches dev_info(&socket->dev->dev, "Routing CardBus interrupts to %s\n",
8681da177e4SLinus Torvalds (val & TI1250_DIAG_PCI_IREQ) ? "PCI" : "ISA");
8691da177e4SLinus Torvalds
8701da177e4SLinus Torvalds /* do irqrouting, depending on function */
8711da177e4SLinus Torvalds if (PCI_FUNC(socket->dev->devfn) == 0)
8721da177e4SLinus Torvalds ti12xx_irqroute_func0(socket);
8731da177e4SLinus Torvalds else
8741da177e4SLinus Torvalds ti12xx_irqroute_func1(socket);
8751da177e4SLinus Torvalds
876fa912bcbSDaniel Ritz /* install power hook */
877fa912bcbSDaniel Ritz socket->socket.power_hook = ti12xx_power_hook;
878fa912bcbSDaniel Ritz
8791da177e4SLinus Torvalds return ti_override(socket);
8801da177e4SLinus Torvalds }
8811da177e4SLinus Torvalds
8821da177e4SLinus Torvalds
ti1250_override(struct yenta_socket * socket)8831da177e4SLinus Torvalds static int ti1250_override(struct yenta_socket *socket)
8841da177e4SLinus Torvalds {
8851da177e4SLinus Torvalds u8 old, diag;
8861da177e4SLinus Torvalds
8871da177e4SLinus Torvalds old = config_readb(socket, TI1250_DIAGNOSTIC);
8881da177e4SLinus Torvalds diag = old & ~(TI1250_DIAG_PCI_CSC | TI1250_DIAG_PCI_IREQ);
8891da177e4SLinus Torvalds if (socket->cb_irq)
8901da177e4SLinus Torvalds diag |= TI1250_DIAG_PCI_CSC | TI1250_DIAG_PCI_IREQ;
8911da177e4SLinus Torvalds
8921da177e4SLinus Torvalds if (diag != old) {
893f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
894dd797d81SDominik Brodowski "adjusting diagnostic: %02x -> %02x\n",
8951da177e4SLinus Torvalds old, diag);
8961da177e4SLinus Torvalds config_writeb(socket, TI1250_DIAGNOSTIC, diag);
8971da177e4SLinus Torvalds }
8981da177e4SLinus Torvalds
8991da177e4SLinus Torvalds return ti12xx_override(socket);
9001da177e4SLinus Torvalds }
9011da177e4SLinus Torvalds
9028c3520d4SDaniel Ritz
9038c3520d4SDaniel Ritz /**
9048c3520d4SDaniel Ritz * EnE specific part. EnE bridges are register compatible with TI bridges but
9058c3520d4SDaniel Ritz * have their own test registers and more important their own little problems.
9068c3520d4SDaniel Ritz * Some fixup code to make everybody happy (TM).
9078c3520d4SDaniel Ritz */
9088c3520d4SDaniel Ritz
90963e7ebd0SDaniel Ritz #ifdef CONFIG_YENTA_ENE_TUNE
91078187865SRandy Dunlap /*
9118c3520d4SDaniel Ritz * set/clear various test bits:
9128c3520d4SDaniel Ritz * Defaults to clear the bit.
9138c3520d4SDaniel Ritz * - mask (u8) defines what bits to change
9148c3520d4SDaniel Ritz * - bits (u8) is the values to change them to
9158c3520d4SDaniel Ritz * -> it's
9168c3520d4SDaniel Ritz * current = (current & ~mask) | bits
9178c3520d4SDaniel Ritz */
9188c3520d4SDaniel Ritz /* pci ids of devices that wants to have the bit set */
9198c3520d4SDaniel Ritz #define DEVID(_vend,_dev,_subvend,_subdev,mask,bits) { \
9208c3520d4SDaniel Ritz .vendor = _vend, \
9218c3520d4SDaniel Ritz .device = _dev, \
9228c3520d4SDaniel Ritz .subvendor = _subvend, \
9238c3520d4SDaniel Ritz .subdevice = _subdev, \
9248c3520d4SDaniel Ritz .driver_data = ((mask) << 8 | (bits)), \
9258c3520d4SDaniel Ritz }
9268c3520d4SDaniel Ritz static struct pci_device_id ene_tune_tbl[] = {
9278c3520d4SDaniel Ritz /* Echo Audio products based on motorola DSP56301 and DSP56361 */
9288c3520d4SDaniel Ritz DEVID(PCI_VENDOR_ID_MOTOROLA, 0x1801, 0xECC0, PCI_ANY_ID,
9298c3520d4SDaniel Ritz ENE_TEST_C9_TLTENABLE | ENE_TEST_C9_PFENABLE, ENE_TEST_C9_TLTENABLE),
9308c3520d4SDaniel Ritz DEVID(PCI_VENDOR_ID_MOTOROLA, 0x3410, 0xECC0, PCI_ANY_ID,
9318c3520d4SDaniel Ritz ENE_TEST_C9_TLTENABLE | ENE_TEST_C9_PFENABLE, ENE_TEST_C9_TLTENABLE),
9328c3520d4SDaniel Ritz
9338c3520d4SDaniel Ritz {}
9348c3520d4SDaniel Ritz };
9358c3520d4SDaniel Ritz
ene_tune_bridge(struct pcmcia_socket * sock,struct pci_bus * bus)9368c3520d4SDaniel Ritz static void ene_tune_bridge(struct pcmcia_socket *sock, struct pci_bus *bus)
9378c3520d4SDaniel Ritz {
9388c3520d4SDaniel Ritz struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
9398c3520d4SDaniel Ritz struct pci_dev *dev;
9408c3520d4SDaniel Ritz struct pci_device_id *id = NULL;
9418c3520d4SDaniel Ritz u8 test_c9, old_c9, mask, bits;
9428c3520d4SDaniel Ritz
9438c3520d4SDaniel Ritz list_for_each_entry(dev, &bus->devices, bus_list) {
9448c3520d4SDaniel Ritz id = (struct pci_device_id *) pci_match_id(ene_tune_tbl, dev);
9458c3520d4SDaniel Ritz if (id)
9468c3520d4SDaniel Ritz break;
9478c3520d4SDaniel Ritz }
9488c3520d4SDaniel Ritz
9498c3520d4SDaniel Ritz test_c9 = old_c9 = config_readb(socket, ENE_TEST_C9);
9508c3520d4SDaniel Ritz if (id) {
9518c3520d4SDaniel Ritz mask = (id->driver_data >> 8) & 0xFF;
9528c3520d4SDaniel Ritz bits = id->driver_data & 0xFF;
9538c3520d4SDaniel Ritz
9548c3520d4SDaniel Ritz test_c9 = (test_c9 & ~mask) | bits;
9558c3520d4SDaniel Ritz }
9568c3520d4SDaniel Ritz else
9578c3520d4SDaniel Ritz /* default to clear TLTEnable bit, old behaviour */
9588c3520d4SDaniel Ritz test_c9 &= ~ENE_TEST_C9_TLTENABLE;
9598c3520d4SDaniel Ritz
960f2e6cf76SJoe Perches dev_info(&socket->dev->dev,
961f2e6cf76SJoe Perches "EnE: changing testregister 0xC9, %02x -> %02x\n",
962dd797d81SDominik Brodowski old_c9, test_c9);
9638c3520d4SDaniel Ritz config_writeb(socket, ENE_TEST_C9, test_c9);
9648c3520d4SDaniel Ritz }
9658c3520d4SDaniel Ritz
ene_override(struct yenta_socket * socket)9668c3520d4SDaniel Ritz static int ene_override(struct yenta_socket *socket)
9678c3520d4SDaniel Ritz {
9688c3520d4SDaniel Ritz /* install tune_bridge() function */
9698c3520d4SDaniel Ritz socket->socket.tune_bridge = ene_tune_bridge;
9708c3520d4SDaniel Ritz
9718c3520d4SDaniel Ritz return ti1250_override(socket);
9728c3520d4SDaniel Ritz }
973c2059b2eSDavid Vrabel #else
974c2059b2eSDavid Vrabel # define ene_override ti1250_override
97563e7ebd0SDaniel Ritz #endif /* !CONFIG_YENTA_ENE_TUNE */
9768c3520d4SDaniel Ritz
9771da177e4SLinus Torvalds #endif /* _LINUX_TI113X_H */
9781da177e4SLinus Torvalds
979