drivers/pcmcia/ti113x.h

   1 /*
   2  * ti113x.h 1.16 1999/10/25 20:03:34
   3  *
   4  * The contents of this file are subject to the Mozilla Public License
   5  * Version 1.1 (the "License"); you may not use this file except in
   6  * compliance with the License. You may obtain a copy of the License
   7  * at http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS"
  10  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  11  * the License for the specific language governing rights and
  12  * limitations under the License.
  13  *
  14  * The initial developer of the original code is David A. Hinds
  15  * <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  16  * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  17  *
  18  * Alternatively, the contents of this file may be used under the
  19  * terms of the GNU General Public License version 2 (the "GPL"), in which
  20  * case the provisions of the GPL are applicable instead of the
  21  * above.  If you wish to allow the use of your version of this file
  22  * only under the terms of the GPL and not to allow others to use
  23  * your version of this file under the MPL, indicate your decision by
  24  * deleting the provisions above and replace them with the notice and
  25  * other provisions required by the GPL.  If you do not delete the
  26  * provisions above, a recipient may use your version of this file
  27  * under either the MPL or the GPL.
  28  */
  29
  30 #ifndef _LINUX_TI113X_H
  31 #define _LINUX_TI113X_H
  32
  33 #include <linux/config.h>
  34
  35 /* Register definitions for TI 113X PCI-to-CardBus bridges */
  36
  37 /* System Control Register */
  38 #define TI113X_SYSTEM_CONTROL           0x0080  /* 32 bit */
  39 #define  TI113X_SCR_SMIROUTE            0x04000000
  40 #define  TI113X_SCR_SMISTATUS           0x02000000
  41 #define  TI113X_SCR_SMIENB              0x01000000
  42 #define  TI113X_SCR_VCCPROT             0x00200000
  43 #define  TI113X_SCR_REDUCEZV            0x00100000
  44 #define  TI113X_SCR_CDREQEN             0x00080000
  45 #define  TI113X_SCR_CDMACHAN            0x00070000
  46 #define  TI113X_SCR_SOCACTIVE           0x00002000
  47 #define  TI113X_SCR_PWRSTREAM           0x00000800
  48 #define  TI113X_SCR_DELAYUP             0x00000400
  49 #define  TI113X_SCR_DELAYDOWN           0x00000200
  50 #define  TI113X_SCR_INTERROGATE         0x00000100
  51 #define  TI113X_SCR_CLKRUN_SEL          0x00000080
  52 #define  TI113X_SCR_PWRSAVINGS          0x00000040
  53 #define  TI113X_SCR_SUBSYSRW            0x00000020
  54 #define  TI113X_SCR_CB_DPAR             0x00000010
  55 #define  TI113X_SCR_CDMA_EN             0x00000008
  56 #define  TI113X_SCR_ASYNC_IRQ           0x00000004
  57 #define  TI113X_SCR_KEEPCLK             0x00000002
  58 #define  TI113X_SCR_CLKRUN_ENA          0x00000001
  59
  60 #define  TI122X_SCR_SER_STEP            0xc0000000
  61 #define  TI122X_SCR_INTRTIE             0x20000000
  62 #define  TI122X_SCR_CBRSVD              0x00400000
  63 #define  TI122X_SCR_MRBURSTDN           0x00008000
  64 #define  TI122X_SCR_MRBURSTUP           0x00004000
  65 #define  TI122X_SCR_RIMUX               0x00000001
  66
  67 /* Multimedia Control Register */
  68 #define TI1250_MULTIMEDIA_CTL           0x0084  /* 8 bit */
  69 #define  TI1250_MMC_ZVOUTEN             0x80
  70 #define  TI1250_MMC_PORTSEL             0x40
  71 #define  TI1250_MMC_ZVEN1               0x02
  72 #define  TI1250_MMC_ZVEN0               0x01
  73
  74 #define TI1250_GENERAL_STATUS           0x0085  /* 8 bit */
  75 #define TI1250_GPIO0_CONTROL            0x0088  /* 8 bit */
  76 #define TI1250_GPIO1_CONTROL            0x0089  /* 8 bit */
  77 #define TI1250_GPIO2_CONTROL            0x008a  /* 8 bit */
  78 #define TI1250_GPIO3_CONTROL            0x008b  /* 8 bit */
  79 #define TI122X_IRQMUX                   0x008c  /* 32 bit */
  80
  81 /* Retry Status Register */
  82 #define TI113X_RETRY_STATUS             0x0090  /* 8 bit */
  83 #define  TI113X_RSR_PCIRETRY            0x80
  84 #define  TI113X_RSR_CBRETRY             0x40
  85 #define  TI113X_RSR_TEXP_CBB            0x20
  86 #define  TI113X_RSR_MEXP_CBB            0x10
  87 #define  TI113X_RSR_TEXP_CBA            0x08
  88 #define  TI113X_RSR_MEXP_CBA            0x04
  89 #define  TI113X_RSR_TEXP_PCI            0x02
  90 #define  TI113X_RSR_MEXP_PCI            0x01
  91
  92 /* Card Control Register */
  93 #define TI113X_CARD_CONTROL             0x0091  /* 8 bit */
  94 #define  TI113X_CCR_RIENB               0x80
  95 #define  TI113X_CCR_ZVENABLE            0x40
  96 #define  TI113X_CCR_PCI_IRQ_ENA         0x20
  97 #define  TI113X_CCR_PCI_IREQ            0x10
  98 #define  TI113X_CCR_PCI_CSC             0x08
  99 #define  TI113X_CCR_SPKROUTEN           0x02
 100 #define  TI113X_CCR_IFG                 0x01
 101
 102 #define  TI1220_CCR_PORT_SEL            0x20
 103 #define  TI122X_CCR_AUD2MUX             0x04
 104
 105 /* Device Control Register */
 106 #define TI113X_DEVICE_CONTROL           0x0092  /* 8 bit */
 107 #define  TI113X_DCR_5V_FORCE            0x40
 108 #define  TI113X_DCR_3V_FORCE            0x20
 109 #define  TI113X_DCR_IMODE_MASK          0x06
 110 #define  TI113X_DCR_IMODE_ISA           0x02
 111 #define  TI113X_DCR_IMODE_SERIAL        0x04
 112
 113 #define  TI12XX_DCR_IMODE_PCI_ONLY      0x00
 114 #define  TI12XX_DCR_IMODE_ALL_SERIAL    0x06
 115
 116 /* Buffer Control Register */
 117 #define TI113X_BUFFER_CONTROL           0x0093  /* 8 bit */
 118 #define  TI113X_BCR_CB_READ_DEPTH       0x08
 119 #define  TI113X_BCR_CB_WRITE_DEPTH      0x04
 120 #define  TI113X_BCR_PCI_READ_DEPTH      0x02
 121 #define  TI113X_BCR_PCI_WRITE_DEPTH     0x01
 122
 123 /* Diagnostic Register */
 124 #define TI1250_DIAGNOSTIC               0x0093  /* 8 bit */
 125 #define  TI1250_DIAG_TRUE_VALUE         0x80
 126 #define  TI1250_DIAG_PCI_IREQ           0x40
 127 #define  TI1250_DIAG_PCI_CSC            0x20
 128 #define  TI1250_DIAG_ASYNC_CSC          0x01
 129
 130 /* DMA Registers */
 131 #define TI113X_DMA_0                    0x0094  /* 32 bit */
 132 #define TI113X_DMA_1                    0x0098  /* 32 bit */
 133
 134 /* ExCA IO offset registers */
 135 #define TI113X_IO_OFFSET(map)           (0x36+((map)<<1))
 136
 137 #ifdef CONFIG_CARDBUS
 138
 139 static int ti_intctl(struct yenta_socket *socket)
 140 {
 141         u8 new, reg = exca_readb(socket, I365_INTCTL);
 142
 143         new = reg & ~I365_INTR_ENA;
 144         if (socket->cb_irq)
 145                 new |= I365_INTR_ENA;
 146         if (new != reg)
 147                 exca_writeb(socket, I365_INTCTL, new);
 148         return 0;
 149 }
 150
 151 /*
 152  *      Zoom video control for TI122x/113x chips
 153  */
 154
 155 static void ti_zoom_video(struct pcmcia_socket *sock, int onoff)
 156 {
 157         u8 reg;
 158         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
 159
 160         /* If we don't have a Zoom Video switch this is harmless,
 161            we just tristate the unused (ZV) lines */
 162         reg = config_readb(socket, TI113X_CARD_CONTROL);
 163         if (onoff)
 164                 /* Zoom zoom, we will all go together, zoom zoom, zoom zoom */
 165                 reg |= TI113X_CCR_ZVENABLE;
 166         else
 167                 reg &= ~TI113X_CCR_ZVENABLE;
 168         config_writeb(socket, TI113X_CARD_CONTROL, reg);
 169 }
 170
 171 /*
 172  *      The 145x series can also use this. They have an additional
 173  *      ZV autodetect mode we don't use but don't actually need.
 174  *      FIXME: manual says its in func0 and func1 but disagrees with
 175  *      itself about this - do we need to force func0, if so we need
 176  *      to know a lot more about socket pairings in pcmcia_socket than
 177  *      we do now.. uggh.
 178  */
 179
 180 static void ti1250_zoom_video(struct pcmcia_socket *sock, int onoff)
 181 {
 182         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
 183         int shift = 0;
 184         u8 reg;
 185
 186         ti_zoom_video(sock, onoff);
 187
 188         reg = config_readb(socket, 0x84);
 189         reg |= (1<<7);  /* ZV bus enable */
 190
 191         if(PCI_FUNC(socket->dev->devfn)==1)
 192                 shift = 1;
 193
 194         if(onoff)
 195         {
 196                 reg &= ~(1<<6);         /* Clear select bit */
 197                 reg |= shift<<6;        /* Favour our socket */
 198                 reg |= 1<<shift;        /* Socket zoom video on */
 199         }
 200         else
 201         {
 202                 reg &= ~(1<<6);         /* Clear select bit */
 203                 reg |= (1^shift)<<6;    /* Favour other socket */
 204                 reg &= ~(1<<shift);     /* Socket zoon video off */
 205         }
 206
 207         config_writeb(socket, 0x84, reg);
 208 }
 209
 210 static void ti_set_zv(struct pcmcia_socket *sock)
 211 {
 212         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
 213         if(socket->dev->vendor == PCI_VENDOR_ID_TI)
 214         {
 215                 switch(socket->dev->device)
 216                 {
 217                         /* There may be more .. */
 218                         case PCI_DEVICE_ID_TI_1220:
 219                         case PCI_DEVICE_ID_TI_1221:
 220                         case PCI_DEVICE_ID_TI_1225:
 221                                 sock->zoom_video = ti_zoom_video;
 222                                 break;
 223                         case PCI_DEVICE_ID_TI_1250:
 224                         case PCI_DEVICE_ID_TI_1251A:
 225                         case PCI_DEVICE_ID_TI_1251B:
 226                         case PCI_DEVICE_ID_TI_1450:
 227                                 sock->zoom_video = ti1250_zoom_video;
 228                 }
 229         }
 230 }
 231 static int ti_init(struct pcmcia_socket *sock)
 232 {
 233         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
 234         yenta_init(sock);
 235         ti_set_zv(sock);
 236         ti_intctl(socket);
 237         return 0;
 238 }
 239
 240
 241 /*
 242  * Generic TI init - TI has an extension for the
 243  * INTCTL register that sets the PCI CSC interrupt.
 244  * Make sure we set it correctly at open and init
 245  * time
 246  * - open: disable the PCI CSC interrupt. This makes
 247  *   it possible to use the CSC interrupt to probe the
 248  *   ISA interrupts.
 249  * - init: set the interrupt to match our PCI state.
 250  *   This makes us correctly get PCI CSC interrupt
 251  *   events.
 252  */
 253 static int ti_override(struct yenta_socket *socket)
 254 {
 255         u8 new, reg = exca_readb(socket, I365_INTCTL);
 256
 257         new = reg & ~I365_INTR_ENA;
 258         if (new != reg)
 259                 exca_writeb(socket, I365_INTCTL, new);
 260
 261         /*
 262          * If ISA interrupts don't work, then fall back to routing card
 263          * interrupts to the PCI interrupt of the socket.
 264          *
 265          * Tweaking this when we are using serial PCI IRQs causes hangs
 266          *   --rmk
 267          */
 268         if (!socket->socket.irq_mask) {
 269                 u8 irqmux, devctl;
 270
 271                 devctl = config_readb(socket, TI113X_DEVICE_CONTROL);
 272                 if ((devctl & TI113X_DCR_IMODE_MASK) != TI12XX_DCR_IMODE_ALL_SERIAL) {
 273                         printk (KERN_INFO "ti113x: Routing card interrupts to PCI\n");
 274
 275                         devctl &= ~TI113X_DCR_IMODE_MASK;
 276
 277                         irqmux = config_readl(socket, TI122X_IRQMUX);
 278                         irqmux = (irqmux & ~0x0f) | 0x02; /* route INTA */
 279                         irqmux = (irqmux & ~0xf0) | 0x20; /* route INTB */
 280
 281                         config_writel(socket, TI122X_IRQMUX, irqmux);
 282                         config_writeb(socket, TI113X_DEVICE_CONTROL, devctl);
 283                 }
 284         }
 285
 286         socket->socket.ops->init = ti_init;
 287         return 0;
 288 }
 289
 290 #define ti_sysctl(socket)       ((socket)->private[0])
 291 #define ti_cardctl(socket)      ((socket)->private[1])
 292 #define ti_devctl(socket)       ((socket)->private[2])
 293 #define ti_diag(socket)         ((socket)->private[3])
 294 #define ti_irqmux(socket)       ((socket)->private[4])
 295
 296
 297 static int ti113x_init(struct pcmcia_socket *sock)
 298 {
 299         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
 300         yenta_init(sock);
 301         ti_set_zv(sock);
 302
 303         config_writel(socket, TI113X_SYSTEM_CONTROL, ti_sysctl(socket));
 304         config_writeb(socket, TI113X_CARD_CONTROL, ti_cardctl(socket));
 305         config_writeb(socket, TI113X_DEVICE_CONTROL, ti_devctl(socket));
 306         ti_intctl(socket);
 307         return 0;
 308 }
 309
 310 static int ti113x_override(struct yenta_socket *socket)
 311 {
 312         ti_sysctl(socket) = config_readl(socket, TI113X_SYSTEM_CONTROL);
 313         ti_cardctl(socket) = config_readb(socket, TI113X_CARD_CONTROL);
 314         ti_devctl(socket) = config_readb(socket, TI113X_DEVICE_CONTROL);
 315
 316         ti_cardctl(socket) &= ~(TI113X_CCR_PCI_IRQ_ENA | TI113X_CCR_PCI_IREQ | TI113X_CCR_PCI_CSC);
 317         if (socket->cb_irq)
 318                 ti_cardctl(socket) |= TI113X_CCR_PCI_IRQ_ENA | TI113X_CCR_PCI_CSC | TI113X_CCR_PCI_IREQ;
 319         ti_override(socket);
 320         socket->socket.ops->init = ti113x_init;
 321         return 0;
 322 }
 323
 324
 325 static int ti1250_init(struct pcmcia_socket *sock)
 326 {
 327         struct yenta_socket *socket = container_of(sock, struct yenta_socket, socket);
 328         yenta_init(sock);
 329         ti113x_init(sock);
 330         ti_set_zv(sock);
 331         ti_irqmux(socket) = config_readl(socket, TI122X_IRQMUX);
 332         ti_irqmux(socket) = (ti_irqmux(socket) & ~0x0f) | 0x02; /* route INTA */
 333         if (!(ti_sysctl(socket) & TI122X_SCR_INTRTIE))
 334                 ti_irqmux(socket) |= 0x20; /* route INTB */
 335
 336         config_writel(socket, TI122X_IRQMUX, ti_irqmux(socket));
 337
 338         config_writeb(socket, TI1250_DIAGNOSTIC, ti_diag(socket));
 339         return 0;
 340 }
 341
 342 static int ti1250_override(struct yenta_socket *socket)
 343 {
 344         ti_diag(socket) = config_readb(socket, TI1250_DIAGNOSTIC);
 345
 346         ti_diag(socket) &= ~(TI1250_DIAG_PCI_CSC | TI1250_DIAG_PCI_IREQ);
 347         if (socket->cb_irq)
 348                 ti_diag(socket) |= TI1250_DIAG_PCI_CSC | TI1250_DIAG_PCI_IREQ;
 349         ti113x_override(socket);
 350         socket->socket.ops->init = ti1250_init;
 351         return 0;
 352 }
 353
 354
 355 static int ti12xx_override(struct yenta_socket *socket)
 356 {
 357         /* make sure that memory burst is active */
 358         ti_sysctl(socket) = config_readl(socket, TI113X_SYSTEM_CONTROL);
 359         ti_sysctl(socket) |= TI122X_SCR_MRBURSTUP;
 360         config_writel(socket, TI113X_SYSTEM_CONTROL, ti_sysctl(socket));
 361
 362         return ti113x_override(socket);
 363 }
 364
 365 #endif /* CONFIG_CARDBUS */
 366
 367 #endif /* _LINUX_TI113X_H */
 368