SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/pcmcia/m8xx_pcmcia.c

   1 /*
   2  * m8xx_pcmcia.c - Linux PCMCIA socket driver for the mpc8xx series.
   3  *
   4  * (C) 1999-2000 Magnus Damm <damm@bitsmart.com>
   5  * (C) 2001-2002 Montavista Software, Inc.
   6  *     <mlocke@mvista.com>
   7  *
   8  * Support for two slots by Cyclades Corporation
   9  *     <oliver.kurth@cyclades.de>
  10  * Further fixes, v2.6 kernel port
  11  *     <marcelo.tosatti@cyclades.com>
  12  *
  13  * Some fixes, additions (C) 2005-2007 Montavista Software, Inc.
  14  *     <vbordug@ru.mvista.com>
  15  *
  16  * "The ExCA standard specifies that socket controllers should provide
  17  * two IO and five memory windows per socket, which can be independently
  18  * configured and positioned in the host address space and mapped to
  19  * arbitrary segments of card address space. " - David A Hinds. 1999
  20  *
  21  * This controller does _not_ meet the ExCA standard.
  22  *
  23  * m8xx pcmcia controller brief info:
  24  * + 8 windows (attrib, mem, i/o)
  25  * + up to two slots (SLOT_A and SLOT_B)
  26  * + inputpins, outputpins, event and mask registers.
  27  * - no offset register. sigh.
  28  *
  29  * Because of the lacking offset register we must map the whole card.
  30  * We assign each memory window PCMCIA_MEM_WIN_SIZE address space.
  31  * Make sure there is (PCMCIA_MEM_WIN_SIZE * PCMCIA_MEM_WIN_NO
  32  * * PCMCIA_SOCKETS_NO) bytes at PCMCIA_MEM_WIN_BASE.
  33  * The i/o windows are dynamically allocated at PCMCIA_IO_WIN_BASE.
  34  * They are maximum 64KByte each...
  35  */
  36
  37 #include <linux/module.h>
  38 #include <linux/init.h>
  39 #include <linux/types.h>
  40 #include <linux/fcntl.h>
  41 #include <linux/string.h>
  42
  43 #include <linux/kernel.h>
  44 #include <linux/errno.h>
  45 #include <linux/slab.h>
  46 #include <linux/timer.h>
  47 #include <linux/ioport.h>
  48 #include <linux/delay.h>
  49 #include <linux/interrupt.h>
  50 #include <linux/fsl_devices.h>
  51
  52 #include <asm/io.h>
  53 #include <asm/bitops.h>
  54 #include <asm/system.h>
  55 #include <asm/time.h>
  56 #include <asm/mpc8xx.h>
  57 #include <asm/8xx_immap.h>
  58 #include <asm/irq.h>
  59 #include <asm/fs_pd.h>
  60 #include <asm/of_device.h>
  61 #include <asm/of_platform.h>
  62
  63 #include <pcmcia/version.h>
  64 #include <pcmcia/cs_types.h>
  65 #include <pcmcia/cs.h>
  66 #include <pcmcia/ss.h>
  67
  68 #ifdef PCMCIA_DEBUG
  69 static int pc_debug = PCMCIA_DEBUG;
  70 module_param(pc_debug, int, 0);
  71 #define dprintk(args...) printk(KERN_DEBUG "m8xx_pcmcia: " args);
  72 #else
  73 #define dprintk(args...)
  74 #endif
  75
  76 #define pcmcia_info(args...) printk(KERN_INFO "m8xx_pcmcia: "args)
  77 #define pcmcia_error(args...) printk(KERN_ERR "m8xx_pcmcia: "args)
  78
  79 static const char *version = "Version 0.06, Aug 2005";
  80 MODULE_LICENSE("Dual MPL/GPL");
  81
  82 #if !defined(CONFIG_PCMCIA_SLOT_A) && !defined(CONFIG_PCMCIA_SLOT_B)
  83
  84 /* The RPX series use SLOT_B */
  85 #if defined(CONFIG_RPXCLASSIC) || defined(CONFIG_RPXLITE)
  86 #define CONFIG_PCMCIA_SLOT_B
  87 #define CONFIG_BD_IS_MHZ
  88 #endif
  89
  90 /* The ADS board use SLOT_A */
  91 #ifdef CONFIG_ADS
  92 #define CONFIG_PCMCIA_SLOT_A
  93 #define CONFIG_BD_IS_MHZ
  94 #endif
  95
  96 /* The FADS series are a mess */
  97 #ifdef CONFIG_FADS
  98 #if defined(CONFIG_MPC860T) || defined(CONFIG_MPC860) || defined(CONFIG_MPC821)
  99 #define CONFIG_PCMCIA_SLOT_A
 100 #else
 101 #define CONFIG_PCMCIA_SLOT_B
 102 #endif
 103 #endif
 104
 105 #if defined(CONFIG_MPC885ADS)
 106 #define CONFIG_PCMCIA_SLOT_A
 107 #define PCMCIA_GLITCHY_CD
 108 #endif
 109
 110 /* Cyclades ACS uses both slots */
 111 #ifdef CONFIG_PRxK
 112 #define CONFIG_PCMCIA_SLOT_A
 113 #define CONFIG_PCMCIA_SLOT_B
 114 #endif
 115
 116 #endif /* !defined(CONFIG_PCMCIA_SLOT_A) && !defined(CONFIG_PCMCIA_SLOT_B) */
 117
 118 #if defined(CONFIG_PCMCIA_SLOT_A) && defined(CONFIG_PCMCIA_SLOT_B)
 119
 120 #define PCMCIA_SOCKETS_NO 2
 121 /* We have only 8 windows, dualsocket support will be limited. */
 122 #define PCMCIA_MEM_WIN_NO 2
 123 #define PCMCIA_IO_WIN_NO  2
 124 #define PCMCIA_SLOT_MSG "SLOT_A and SLOT_B"
 125
 126 #elif defined(CONFIG_PCMCIA_SLOT_A) || defined(CONFIG_PCMCIA_SLOT_B)
 127
 128 #define PCMCIA_SOCKETS_NO 1
 129 /* full support for one slot */
 130 #define PCMCIA_MEM_WIN_NO 5
 131 #define PCMCIA_IO_WIN_NO  2
 132
 133 /* define _slot_ to be able to optimize macros */
 134
 135 #ifdef CONFIG_PCMCIA_SLOT_A
 136 #define _slot_ 0
 137 #define PCMCIA_SLOT_MSG "SLOT_A"
 138 #else
 139 #define _slot_ 1
 140 #define PCMCIA_SLOT_MSG "SLOT_B"
 141 #endif
 142
 143 #else
 144 #error m8xx_pcmcia: Bad configuration!
 145 #endif
 146
 147 /* ------------------------------------------------------------------------- */
 148
 149 #define PCMCIA_MEM_WIN_BASE 0xe0000000 /* base address for memory window 0   */
 150 #define PCMCIA_MEM_WIN_SIZE 0x04000000 /* each memory window is 64 MByte     */
 151 #define PCMCIA_IO_WIN_BASE  _IO_BASE   /* base address for io window 0       */
 152 /* ------------------------------------------------------------------------- */
 153
 154 static int pcmcia_schlvl;
 155
 156 static DEFINE_SPINLOCK(events_lock);
 157
 158 #define PCMCIA_SOCKET_KEY_5V 1
 159 #define PCMCIA_SOCKET_KEY_LV 2
 160
 161 /* look up table for pgcrx registers */
 162 static u32 *m8xx_pgcrx[2];
 163
 164 /*
 165  * This structure is used to address each window in the PCMCIA controller.
 166  *
 167  * Keep in mind that we assume that pcmcia_win[n+1] is mapped directly
 168  * after pcmcia_win[n]...
 169  */
 170
 171 struct pcmcia_win {
 172         u32     br;
 173         u32     or;
 174 };
 175
 176 /*
 177  * For some reason the hardware guys decided to make both slots share
 178  * some registers.
 179  *
 180  * Could someone invent object oriented hardware ?
 181  *
 182  * The macros are used to get the right bit from the registers.
 183  * SLOT_A : slot = 0
 184  * SLOT_B : slot = 1
 185  */
 186
 187 #define M8XX_PCMCIA_VS1(slot)      (0x80000000 >> (slot << 4))
 188 #define M8XX_PCMCIA_VS2(slot)      (0x40000000 >> (slot << 4))
 189 #define M8XX_PCMCIA_VS_MASK(slot)  (0xc0000000 >> (slot << 4))
 190 #define M8XX_PCMCIA_VS_SHIFT(slot) (30 - (slot << 4))
 191
 192 #define M8XX_PCMCIA_WP(slot)       (0x20000000 >> (slot << 4))
 193 #define M8XX_PCMCIA_CD2(slot)      (0x10000000 >> (slot << 4))
 194 #define M8XX_PCMCIA_CD1(slot)      (0x08000000 >> (slot << 4))
 195 #define M8XX_PCMCIA_BVD2(slot)     (0x04000000 >> (slot << 4))
 196 #define M8XX_PCMCIA_BVD1(slot)     (0x02000000 >> (slot << 4))
 197 #define M8XX_PCMCIA_RDY(slot)      (0x01000000 >> (slot << 4))
 198 #define M8XX_PCMCIA_RDY_L(slot)    (0x00800000 >> (slot << 4))
 199 #define M8XX_PCMCIA_RDY_H(slot)    (0x00400000 >> (slot << 4))
 200 #define M8XX_PCMCIA_RDY_R(slot)    (0x00200000 >> (slot << 4))
 201 #define M8XX_PCMCIA_RDY_F(slot)    (0x00100000 >> (slot << 4))
 202 #define M8XX_PCMCIA_MASK(slot)     (0xFFFF0000 >> (slot << 4))
 203
 204 #define M8XX_PCMCIA_POR_VALID    0x00000001
 205 #define M8XX_PCMCIA_POR_WRPROT   0x00000002
 206 #define M8XX_PCMCIA_POR_ATTRMEM  0x00000010
 207 #define M8XX_PCMCIA_POR_IO       0x00000018
 208 #define M8XX_PCMCIA_POR_16BIT    0x00000040
 209
 210 #define M8XX_PGCRX(slot)  m8xx_pgcrx[slot]
 211
 212 #define M8XX_PGCRX_CXOE    0x00000080
 213 #define M8XX_PGCRX_CXRESET 0x00000040
 214
 215 /* we keep one lookup table per socket to check flags */
 216
 217 #define PCMCIA_EVENTS_MAX 5  /* 4 max at a time + termination */
 218
 219 struct event_table {
 220         u32 regbit;
 221         u32 eventbit;
 222 };
 223
 224 static const char driver_name[] = "m8xx-pcmcia";
 225
 226 struct socket_info {
 227         void    (*handler)(void *info, u32 events);
 228         void    *info;
 229
 230         u32 slot;
 231         pcmconf8xx_t *pcmcia;
 232         u32 bus_freq;
 233         int hwirq;
 234
 235         socket_state_t state;
 236         struct pccard_mem_map mem_win[PCMCIA_MEM_WIN_NO];
 237         struct pccard_io_map  io_win[PCMCIA_IO_WIN_NO];
 238         struct event_table events[PCMCIA_EVENTS_MAX];
 239         struct pcmcia_socket socket;
 240 };
 241
 242 static struct socket_info socket[PCMCIA_SOCKETS_NO];
 243
 244 /*
 245  * Search this table to see if the windowsize is
 246  * supported...
 247  */
 248
 249 #define M8XX_SIZES_NO 32
 250
 251 static const u32 m8xx_size_to_gray[M8XX_SIZES_NO] =
 252 {
 253         0x00000001, 0x00000002, 0x00000008, 0x00000004,
 254         0x00000080, 0x00000040, 0x00000010, 0x00000020,
 255         0x00008000, 0x00004000, 0x00001000, 0x00002000,
 256         0x00000100, 0x00000200, 0x00000800, 0x00000400,
 257
 258         0x0fffffff, 0xffffffff, 0xffffffff, 0xffffffff,
 259         0x01000000, 0x02000000, 0xffffffff, 0x04000000,
 260         0x00010000, 0x00020000, 0x00080000, 0x00040000,
 261         0x00800000, 0x00400000, 0x00100000, 0x00200000
 262 };
 263
 264 /* ------------------------------------------------------------------------- */
 265
 266 static irqreturn_t m8xx_interrupt(int irq, void *dev);
 267
 268 #define PCMCIA_BMT_LIMIT (15*4)  /* Bus Monitor Timeout value */
 269
 270 /* ------------------------------------------------------------------------- */
 271 /* board specific stuff:                                                     */
 272 /* voltage_set(), hardware_enable() and hardware_disable()                   */
 273 /* ------------------------------------------------------------------------- */
 274 /* RPX Boards from Embedded Planet                                           */
 275
 276 #if defined(CONFIG_RPXCLASSIC) || defined(CONFIG_RPXLITE)
 277
 278 /* The RPX boards seems to have it's bus monitor timeout set to 6*8 clocks.
 279  * SYPCR is write once only, therefore must the slowest memory be faster
 280  * than the bus monitor or we will get a machine check due to the bus timeout.
 281  */
 282
 283 #define PCMCIA_BOARD_MSG "RPX CLASSIC or RPX LITE"
 284
 285 #undef PCMCIA_BMT_LIMIT
 286 #define PCMCIA_BMT_LIMIT (6*8)
 287
 288 static int voltage_set(int slot, int vcc, int vpp)
 289 {
 290         u32 reg = 0;
 291
 292         switch(vcc) {
 293         case 0: break;
 294         case 33:
 295                 reg |= BCSR1_PCVCTL4;
 296                 break;
 297         case 50:
 298                 reg |= BCSR1_PCVCTL5;
 299                 break;
 300         default:
 301                 return 1;
 302         }
 303
 304         switch(vpp) {
 305         case 0: break;
 306         case 33:
 307         case 50:
 308                 if(vcc == vpp)
 309                         reg |= BCSR1_PCVCTL6;
 310                 else
 311                         return 1;
 312                 break;
 313         case 120:
 314                 reg |= BCSR1_PCVCTL7;
 315         default:
 316                 return 1;
 317         }
 318
 319         if(!((vcc == 50) || (vcc == 0)))
 320                 return 1;
 321
 322         /* first, turn off all power */
 323
 324         out_be32(((u32 *)RPX_CSR_ADDR), in_be32(((u32 *)RPX_CSR_ADDR)) & ~(BCSR1_PCVCTL4 | BCSR1_PCVCTL5 | BCSR1_PCVCTL6 | BCSR1_PCVCTL7));
 325
 326         /* enable new powersettings */
 327
 328         out_be32(((u32 *)RPX_CSR_ADDR), in_be32(((u32 *)RPX_CSR_ADDR)) | reg);
 329
 330         return 0;
 331 }
 332
 333 #define socket_get(_slot_) PCMCIA_SOCKET_KEY_5V
 334 #define hardware_enable(_slot_)  /* No hardware to enable */
 335 #define hardware_disable(_slot_) /* No hardware to disable */
 336
 337 #endif /* CONFIG_RPXCLASSIC */
 338
 339 /* FADS Boards from Motorola                                               */
 340
 341 #if defined(CONFIG_FADS)
 342
 343 #define PCMCIA_BOARD_MSG "FADS"
 344
 345 static int voltage_set(int slot, int vcc, int vpp)
 346 {
 347         u32 reg = 0;
 348
 349         switch(vcc) {
 350                 case 0:
 351                         break;
 352                 case 33:
 353                         reg |= BCSR1_PCCVCC0;
 354                         break;
 355                 case 50:
 356                         reg |= BCSR1_PCCVCC1;
 357                         break;
 358                 default:
 359                         return 1;
 360         }
 361
 362         switch(vpp) {
 363                 case 0:
 364                         break;
 365                 case 33:
 366                 case 50:
 367                         if(vcc == vpp)
 368                                 reg |= BCSR1_PCCVPP1;
 369                         else
 370                                 return 1;
 371                         break;
 372                 case 120:
 373                         if ((vcc == 33) || (vcc == 50))
 374                                 reg |= BCSR1_PCCVPP0;
 375                         else
 376                                 return 1;
 377                 default:
 378                         return 1;
 379         }
 380
 381         /* first, turn off all power */
 382         out_be32((u32 *)BCSR1, in_be32((u32 *)BCSR1) & ~(BCSR1_PCCVCC_MASK | BCSR1_PCCVPP_MASK));
 383
 384         /* enable new powersettings */
 385         out_be32((u32 *)BCSR1, in_be32((u32 *)BCSR1) | reg);
 386
 387         return 0;
 388 }
 389
 390 #define socket_get(_slot_) PCMCIA_SOCKET_KEY_5V
 391
 392 static void hardware_enable(int slot)
 393 {
 394         out_be32((u32 *)BCSR1, in_be32((u32 *)BCSR1) & ~BCSR1_PCCEN);
 395 }
 396
 397 static void hardware_disable(int slot)
 398 {
 399         out_be32((u32 *)BCSR1, in_be32((u32 *)BCSR1) |  BCSR1_PCCEN);
 400 }
 401
 402 #endif
 403
 404 /* MPC885ADS Boards */
 405
 406 #if defined(CONFIG_MPC885ADS)
 407
 408 #define PCMCIA_BOARD_MSG "MPC885ADS"
 409 #define socket_get(_slot_) PCMCIA_SOCKET_KEY_5V
 410
 411 static inline void hardware_enable(int slot)
 412 {
 413          m8xx_pcmcia_ops.hw_ctrl(slot, 1);
 414 }
 415
 416 static inline void hardware_disable(int slot)
 417 {
 418         m8xx_pcmcia_ops.hw_ctrl(slot, 0);
 419 }
 420
 421 static inline int voltage_set(int slot, int vcc, int vpp)
 422 {
 423         return m8xx_pcmcia_ops.voltage_set(slot, vcc, vpp);
 424 }
 425
 426 #endif
 427
 428 /* ------------------------------------------------------------------------- */
 429 /* Motorola MBX860                                                           */
 430
 431 #if defined(CONFIG_MBX)
 432
 433 #define PCMCIA_BOARD_MSG "MBX"
 434
 435 static int voltage_set(int slot, int vcc, int vpp)
 436 {
 437         u8 reg = 0;
 438
 439         switch(vcc) {
 440                 case 0:
 441                         break;
 442                 case 33:
 443                         reg |= CSR2_VCC_33;
 444                         break;
 445                 case 50:
 446                         reg |= CSR2_VCC_50;
 447                         break;
 448                 default:
 449                         return 1;
 450         }
 451
 452         switch(vpp) {
 453                 case 0:
 454                         break;
 455                 case 33:
 456                 case 50:
 457                         if(vcc == vpp)
 458                                 reg |= CSR2_VPP_VCC;
 459                         else
 460                                 return 1;
 461                         break;
 462                 case 120:
 463                         if ((vcc == 33) || (vcc == 50))
 464                                 reg |= CSR2_VPP_12;
 465                         else
 466                                 return 1;
 467                 default:
 468                         return 1;
 469         }
 470
 471         /* first, turn off all power */
 472         out_8((u8 *)MBX_CSR2_ADDR, in_8((u8 *)MBX_CSR2_ADDR) & ~(CSR2_VCC_MASK | CSR2_VPP_MASK));
 473
 474         /* enable new powersettings */
 475         out_8((u8 *)MBX_CSR2_ADDR, in_8((u8 *)MBX_CSR2_ADDR) | reg);
 476
 477         return 0;
 478 }
 479
 480 #define socket_get(_slot_) PCMCIA_SOCKET_KEY_5V
 481 #define hardware_enable(_slot_)  /* No hardware to enable */
 482 #define hardware_disable(_slot_) /* No hardware to disable */
 483
 484 #endif /* CONFIG_MBX */
 485
 486 #if defined(CONFIG_PRxK)
 487 #include <asm/cpld.h>
 488 extern volatile fpga_pc_regs *fpga_pc;
 489
 490 #define PCMCIA_BOARD_MSG "MPC855T"
 491
 492 static int voltage_set(int slot, int vcc, int vpp)
 493 {
 494         u8 reg = 0;
 495         u8 regread;
 496         cpld_regs *ccpld = get_cpld();
 497
 498         switch(vcc) {
 499                 case 0:
 500                         break;
 501                 case 33:
 502                         reg |= PCMCIA_VCC_33;
 503                         break;
 504                 case 50:
 505                         reg |= PCMCIA_VCC_50;
 506                         break;
 507                 default:
 508                         return 1;
 509         }
 510
 511         switch(vpp) {
 512                 case 0:
 513                         break;
 514                 case 33:
 515                 case 50:
 516                         if(vcc == vpp)
 517                                 reg |= PCMCIA_VPP_VCC;
 518                         else
 519                                 return 1;
 520                         break;
 521                 case 120:
 522                         if ((vcc == 33) || (vcc == 50))
 523                                 reg |= PCMCIA_VPP_12;
 524                         else
 525                                 return 1;
 526                 default:
 527                         return 1;
 528         }
 529
 530         reg = reg >> (slot << 2);
 531         regread = in_8(&ccpld->fpga_pc_ctl);
 532         if (reg != (regread & ((PCMCIA_VCC_MASK | PCMCIA_VPP_MASK) >> (slot << 2)))) {
 533                 /* enable new powersettings */
 534                 regread = regread & ~((PCMCIA_VCC_MASK | PCMCIA_VPP_MASK) >> (slot << 2));
 535                 out_8(&ccpld->fpga_pc_ctl, reg | regread);
 536                 msleep(100);
 537         }
 538
 539         return 0;
 540 }
 541
 542 #define socket_get(_slot_) PCMCIA_SOCKET_KEY_LV
 543 #define hardware_enable(_slot_)  /* No hardware to enable */
 544 #define hardware_disable(_slot_) /* No hardware to disable */
 545
 546 #endif /* CONFIG_PRxK */
 547
 548 static u32 pending_events[PCMCIA_SOCKETS_NO];
 549 static DEFINE_SPINLOCK(pending_event_lock);
 550
 551 static irqreturn_t m8xx_interrupt(int irq, void *dev)
 552 {
 553         struct socket_info *s;
 554         struct event_table *e;
 555         unsigned int i, events, pscr, pipr, per;
 556         pcmconf8xx_t    *pcmcia = socket[0].pcmcia;
 557
 558         dprintk("Interrupt!\n");
 559         /* get interrupt sources */
 560
 561         pscr = in_be32(&pcmcia->pcmc_pscr);
 562         pipr = in_be32(&pcmcia->pcmc_pipr);
 563         per = in_be32(&pcmcia->pcmc_per);
 564
 565         for(i = 0; i < PCMCIA_SOCKETS_NO; i++) {
 566                 s = &socket[i];
 567                 e = &s->events[0];
 568                 events = 0;
 569
 570                 while(e->regbit) {
 571                         if(pscr & e->regbit)
 572                                 events |= e->eventbit;
 573
 574                                 e++;
 575                 }
 576
 577                 /*
 578                  * report only if both card detect signals are the same
 579                  * not too nice done,
 580                  * we depend on that CD2 is the bit to the left of CD1...
 581                  */
 582                 if(events & SS_DETECT)
 583                         if(((pipr & M8XX_PCMCIA_CD2(i)) >> 1) ^
 584                                 (pipr & M8XX_PCMCIA_CD1(i)))
 585                         {
 586                                 events &= ~SS_DETECT;
 587                         }
 588
 589 #ifdef PCMCIA_GLITCHY_CD
 590                 /*
 591                  * I've experienced CD problems with my ADS board.
 592                  * We make an extra check to see if there was a
 593                  * real change of Card detection.
 594                  */
 595
 596                 if((events & SS_DETECT) &&
 597                    ((pipr &
 598                      (M8XX_PCMCIA_CD2(i) | M8XX_PCMCIA_CD1(i))) == 0) &&
 599                    (s->state.Vcc | s->state.Vpp)) {
 600                         events &= ~SS_DETECT;
 601                         /*printk( "CD glitch workaround - CD = 0x%08x!\n",
 602                                 (pipr & (M8XX_PCMCIA_CD2(i)
 603                                          | M8XX_PCMCIA_CD1(i))));*/
 604                 }
 605 #endif
 606
 607                 /* call the handler */
 608
 609                 dprintk("slot %u: events = 0x%02x, pscr = 0x%08x, "
 610                         "pipr = 0x%08x\n",
 611                         i, events, pscr, pipr);
 612
 613                 if(events) {
 614                         spin_lock(&pending_event_lock);
 615                         pending_events[i] |= events;
 616                         spin_unlock(&pending_event_lock);
 617                         /*
 618                          * Turn off RDY_L bits in the PER mask on
 619                          * CD interrupt receival.
 620                          *
 621                          * They can generate bad interrupts on the
 622                          * ACS4,8,16,32.   - marcelo
 623                          */
 624                         per &= ~M8XX_PCMCIA_RDY_L(0);
 625                         per &= ~M8XX_PCMCIA_RDY_L(1);
 626
 627                         out_be32(&pcmcia->pcmc_per, per);
 628
 629                         if (events)
 630                                 pcmcia_parse_events(&socket[i].socket, events);
 631                 }
 632         }
 633
 634         /* clear the interrupt sources */
 635         out_be32(&pcmcia->pcmc_pscr, pscr);
 636
 637         dprintk("Interrupt done.\n");
 638
 639         return IRQ_HANDLED;
 640 }
 641
 642 static u32 m8xx_get_graycode(u32 size)
 643 {
 644         u32 k;
 645
 646         for(k = 0; k < M8XX_SIZES_NO; k++)
 647                 if(m8xx_size_to_gray[k] == size)
 648                         break;
 649
 650         if((k == M8XX_SIZES_NO) || (m8xx_size_to_gray[k] == -1))
 651                 k = -1;
 652
 653         return k;
 654 }
 655
 656 static u32 m8xx_get_speed(u32 ns, u32 is_io, u32 bus_freq)
 657 {
 658         u32 reg, clocks, psst, psl, psht;
 659
 660         if(!ns) {
 661
 662                 /*
 663                  * We get called with IO maps setup to 0ns
 664                  * if not specified by the user.
 665                  * They should be 255ns.
 666                  */
 667
 668                 if(is_io)
 669                         ns = 255;
 670                 else
 671                         ns = 100;  /* fast memory if 0 */
 672         }
 673
 674         /*
 675          * In PSST, PSL, PSHT fields we tell the controller
 676          * timing parameters in CLKOUT clock cycles.
 677          * CLKOUT is the same as GCLK2_50.
 678          */
 679
 680 /* how we want to adjust the timing - in percent */
 681
 682 #define ADJ 180 /* 80 % longer accesstime - to be sure */
 683
 684         clocks = ((bus_freq / 1000) * ns) / 1000;
 685         clocks = (clocks * ADJ) / (100*1000);
 686         if(clocks >= PCMCIA_BMT_LIMIT) {
 687                 printk( "Max access time limit reached\n");
 688                 clocks = PCMCIA_BMT_LIMIT-1;
 689         }
 690
 691         psst = clocks / 7;          /* setup time */
 692         psht = clocks / 7;          /* hold time */
 693         psl  = (clocks * 5) / 7;    /* strobe length */
 694
 695         psst += clocks - (psst + psht + psl);
 696
 697         reg =  psst << 12;
 698         reg |= psl  << 7;
 699         reg |= psht << 16;
 700
 701         return reg;
 702 }
 703
 704 static int m8xx_get_status(struct pcmcia_socket *sock, unsigned int *value)
 705 {
 706         int lsock = container_of(sock, struct socket_info, socket)->slot;
 707         struct socket_info *s = &socket[lsock];
 708         unsigned int pipr, reg;
 709         pcmconf8xx_t *pcmcia = s->pcmcia;
 710
 711         pipr = in_be32(&pcmcia->pcmc_pipr);
 712
 713         *value  = ((pipr & (M8XX_PCMCIA_CD1(lsock)
 714                             | M8XX_PCMCIA_CD2(lsock))) == 0) ? SS_DETECT : 0;
 715         *value |= (pipr & M8XX_PCMCIA_WP(lsock)) ? SS_WRPROT : 0;
 716
 717         if (s->state.flags & SS_IOCARD)
 718                 *value |= (pipr & M8XX_PCMCIA_BVD1(lsock)) ? SS_STSCHG : 0;
 719         else {
 720                 *value |= (pipr & M8XX_PCMCIA_RDY(lsock)) ? SS_READY : 0;
 721                 *value |= (pipr & M8XX_PCMCIA_BVD1(lsock)) ? SS_BATDEAD : 0;
 722                 *value |= (pipr & M8XX_PCMCIA_BVD2(lsock)) ? SS_BATWARN : 0;
 723         }
 724
 725         if (s->state.Vcc | s->state.Vpp)
 726                 *value |= SS_POWERON;
 727
 728         /*
 729          * Voltage detection:
 730          * This driver only supports 16-Bit pc-cards.
 731          * Cardbus is not handled here.
 732          *
 733          * To determine what voltage to use we must read the VS1 and VS2 pin.
 734          * Depending on what socket type is present,
 735          * different combinations mean different things.
 736          *
 737          * Card Key  Socket Key   VS1   VS2   Card         Vcc for CIS parse
 738          *
 739          * 5V        5V, LV*      NC    NC    5V only       5V (if available)
 740          *
 741          * 5V        5V, LV*      GND   NC    5 or 3.3V     as low as possible
 742          *
 743          * 5V        5V, LV*      GND   GND   5, 3.3, x.xV  as low as possible
 744          *
 745          * LV*       5V            -     -    shall not fit into socket
 746          *
 747          * LV*       LV*          GND   NC    3.3V only     3.3V
 748          *
 749          * LV*       LV*          NC    GND   x.xV          x.xV (if avail.)
 750          *
 751          * LV*       LV*          GND   GND   3.3 or x.xV   as low as possible
 752          *
 753          * *LV means Low Voltage
 754          *
 755          *
 756          * That gives us the following table:
 757          *
 758          * Socket    VS1  VS2   Voltage
 759          *
 760          * 5V        NC   NC    5V
 761          * 5V        NC   GND   none (should not be possible)
 762          * 5V        GND  NC    >= 3.3V
 763          * 5V        GND  GND   >= x.xV
 764          *
 765          * LV        NC   NC    5V   (if available)
 766          * LV        NC   GND   x.xV (if available)
 767          * LV        GND  NC    3.3V
 768          * LV        GND  GND   >= x.xV
 769          *
 770          * So, how do I determine if I have a 5V or a LV
 771          * socket on my board?  Look at the socket!
 772          *
 773          *
 774          * Socket with 5V key:
 775          * ++--------------------------------------------+
 776          * ||                                            |
 777          * ||                                           ||
 778          * ||                                           ||
 779          * |                                             |
 780          * +---------------------------------------------+
 781          *
 782          * Socket with LV key:
 783          * ++--------------------------------------------+
 784          * ||                                            |
 785          * |                                            ||
 786          * |                                            ||
 787          * |                                             |
 788          * +---------------------------------------------+
 789          *
 790          *
 791          * With other words - LV only cards does not fit
 792          * into the 5V socket!
 793          */
 794
 795         /* read out VS1 and VS2 */
 796
 797         reg = (pipr & M8XX_PCMCIA_VS_MASK(lsock))
 798                 >> M8XX_PCMCIA_VS_SHIFT(lsock);
 799
 800         if(socket_get(lsock) == PCMCIA_SOCKET_KEY_LV) {
 801                 switch(reg) {
 802                 case 1:
 803                         *value |= SS_3VCARD;
 804                         break; /* GND, NC - 3.3V only */
 805                 case 2:
 806                         *value |= SS_XVCARD;
 807                         break; /* NC. GND - x.xV only */
 808                 };
 809         }
 810
 811         dprintk("GetStatus(%d) = %#2.2x\n", lsock, *value);
 812         return 0;
 813 }
 814
 815 static int m8xx_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
 816 {
 817         int lsock = container_of(sock, struct socket_info, socket)->slot;
 818         struct socket_info *s = &socket[lsock];
 819         struct event_table *e;
 820         unsigned int reg;
 821         unsigned long flags;
 822         pcmconf8xx_t *pcmcia = socket[0].pcmcia;
 823
 824         dprintk( "SetSocket(%d, flags %#3.3x, Vcc %d, Vpp %d, "
 825               "io_irq %d, csc_mask %#2.2x)\n", lsock, state->flags,
 826               state->Vcc, state->Vpp, state->io_irq, state->csc_mask);
 827
 828         /* First, set voltage - bail out if invalid */
 829         if(voltage_set(lsock, state->Vcc, state->Vpp))
 830                 return -EINVAL;
 831
 832
 833         /* Take care of reset... */
 834         if(state->flags & SS_RESET)
 835                 out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) |  M8XX_PGCRX_CXRESET); /* active high */
 836         else
 837                 out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) & ~M8XX_PGCRX_CXRESET);
 838
 839         /* ... and output enable. */
 840
 841         /* The CxOE signal is connected to a 74541 on the ADS.
 842            I guess most other boards used the ADS as a reference.
 843            I tried to control the CxOE signal with SS_OUTPUT_ENA,
 844            but the reset signal seems connected via the 541.
 845            If the CxOE is left high are some signals tristated and
 846            no pullups are present -> the cards act wierd.
 847            So right now the buffers are enabled if the power is on. */
 848
 849         if(state->Vcc || state->Vpp)
 850                 out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) & ~M8XX_PGCRX_CXOE); /* active low */
 851         else
 852                 out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) | M8XX_PGCRX_CXOE);
 853
 854         /*
 855          * We'd better turn off interrupts before
 856          * we mess with the events-table..
 857          */
 858
 859         spin_lock_irqsave(&events_lock, flags);
 860
 861         /*
 862          * Play around with the interrupt mask to be able to
 863          * give the events the generic pcmcia driver wants us to.
 864          */
 865
 866         e = &s->events[0];
 867         reg = 0;
 868
 869         if(state->csc_mask & SS_DETECT) {
 870                 e->eventbit = SS_DETECT;
 871                 reg |= e->regbit = (M8XX_PCMCIA_CD2(lsock)
 872                                     | M8XX_PCMCIA_CD1(lsock));
 873                 e++;
 874         }
 875         if(state->flags & SS_IOCARD) {
 876                 /*
 877                  * I/O card
 878                  */
 879                 if(state->csc_mask & SS_STSCHG) {
 880                         e->eventbit = SS_STSCHG;
 881                         reg |= e->regbit = M8XX_PCMCIA_BVD1(lsock);
 882                         e++;
 883                 }
 884                 /*
 885                  * If io_irq is non-zero we should enable irq.
 886                  */
 887                 if(state->io_irq) {
 888                         out_be32(M8XX_PGCRX(lsock),
 889                                  in_be32(M8XX_PGCRX(lsock)) | mk_int_int_mask(s->hwirq) << 24);
 890                         /*
 891                          * Strange thing here:
 892                          * The manual does not tell us which interrupt
 893                          * the sources generate.
 894                          * Anyhow, I found out that RDY_L generates IREQLVL.
 895                          *
 896                          * We use level triggerd interrupts, and they don't
 897                          * have to be cleared in PSCR in the interrupt handler.
 898                          */
 899                         reg |= M8XX_PCMCIA_RDY_L(lsock);
 900                 }
 901                 else
 902                         out_be32(M8XX_PGCRX(lsock), in_be32(M8XX_PGCRX(lsock)) & 0x00ffffff);
 903         }
 904         else {
 905                 /*
 906                  * Memory card
 907                  */
 908                 if(state->csc_mask & SS_BATDEAD) {
 909                         e->eventbit = SS_BATDEAD;
 910                         reg |= e->regbit = M8XX_PCMCIA_BVD1(lsock);
 911                         e++;
 912                 }
 913                 if(state->csc_mask & SS_BATWARN) {
 914                         e->eventbit = SS_BATWARN;
 915                         reg |= e->regbit = M8XX_PCMCIA_BVD2(lsock);
 916                         e++;
 917                 }
 918                 /* What should I trigger on - low/high,raise,fall? */
 919                 if(state->csc_mask & SS_READY) {
 920                         e->eventbit = SS_READY;
 921                         reg |= e->regbit = 0; //??
 922                         e++;
 923                 }
 924         }
 925
 926         e->regbit = 0;  /* terminate list */
 927
 928         /*
 929          * Clear the status changed .
 930          * Port A and Port B share the same port.
 931          * Writing ones will clear the bits.
 932          */
 933
 934         out_be32(&pcmcia->pcmc_pscr, reg);
 935
 936         /*
 937          * Write the mask.
 938          * Port A and Port B share the same port.
 939          * Need for read-modify-write.
 940          * Ones will enable the interrupt.
 941          */
 942
 943         reg |= in_be32(&pcmcia->pcmc_per) & (M8XX_PCMCIA_MASK(0) | M8XX_PCMCIA_MASK(1));
 944         out_be32(&pcmcia->pcmc_per, reg);
 945
 946         spin_unlock_irqrestore(&events_lock, flags);
 947
 948         /* copy the struct and modify the copy */
 949
 950         s->state = *state;
 951
 952         return 0;
 953 }
 954
 955 static int m8xx_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *io)
 956 {
 957         int lsock = container_of(sock, struct socket_info, socket)->slot;
 958
 959         struct socket_info *s = &socket[lsock];
 960         struct pcmcia_win *w;
 961         unsigned int reg, winnr;
 962         pcmconf8xx_t *pcmcia = s->pcmcia;
 963
 964
 965 #define M8XX_SIZE (io->stop - io->start + 1)
 966 #define M8XX_BASE (PCMCIA_IO_WIN_BASE + io->start)
 967
 968         dprintk( "SetIOMap(%d, %d, %#2.2x, %d ns, "
 969               "%#4.4x-%#4.4x)\n", lsock, io->map, io->flags,
 970               io->speed, io->start, io->stop);
 971
 972         if ((io->map >= PCMCIA_IO_WIN_NO) || (io->start > 0xffff)
 973             || (io->stop > 0xffff) || (io->stop < io->start))
 974                 return -EINVAL;
 975
 976         if((reg = m8xx_get_graycode(M8XX_SIZE)) == -1)
 977                 return -EINVAL;
 978
 979         if(io->flags & MAP_ACTIVE) {
 980
 981                 dprintk( "io->flags & MAP_ACTIVE\n");
 982
 983                 winnr = (PCMCIA_MEM_WIN_NO * PCMCIA_SOCKETS_NO)
 984                         + (lsock * PCMCIA_IO_WIN_NO) + io->map;
 985
 986                 /* setup registers */
 987
 988                 w = (void *) &pcmcia->pcmc_pbr0;
 989                 w += winnr;
 990
 991                 out_be32(&w->or, 0); /* turn off window first */
 992                 out_be32(&w->br, M8XX_BASE);
 993
 994                 reg <<= 27;
 995                 reg |= M8XX_PCMCIA_POR_IO |(lsock << 2);
 996
 997                 reg |= m8xx_get_speed(io->speed, 1, s->bus_freq);
 998
 999                 if(io->flags & MAP_WRPROT)
1000                         reg |= M8XX_PCMCIA_POR_WRPROT;
1001
1002                 /*if(io->flags & (MAP_16BIT | MAP_AUTOSZ))*/
1003                 if(io->flags & MAP_16BIT)
1004                         reg |= M8XX_PCMCIA_POR_16BIT;
1005
1006                 if(io->flags & MAP_ACTIVE)
1007                         reg |= M8XX_PCMCIA_POR_VALID;
1008
1009                 out_be32(&w->or, reg);
1010
1011                 dprintk("Socket %u: Mapped io window %u at %#8.8x, "
1012                       "OR = %#8.8x.\n", lsock, io->map, w->br, w->or);
1013         } else {
1014                 /* shutdown IO window */
1015                 winnr = (PCMCIA_MEM_WIN_NO * PCMCIA_SOCKETS_NO)
1016                         + (lsock * PCMCIA_IO_WIN_NO) + io->map;
1017
1018                 /* setup registers */
1019
1020                 w = (void *) &pcmcia->pcmc_pbr0;
1021                 w += winnr;
1022
1023                 out_be32(&w->or, 0); /* turn off window */
1024                 out_be32(&w->br, 0); /* turn off base address */
1025
1026                 dprintk("Socket %u: Unmapped io window %u at %#8.8x, "
1027                         "OR = %#8.8x.\n", lsock, io->map, w->br, w->or);
1028         }
1029
1030         /* copy the struct and modify the copy */
1031         s->io_win[io->map] = *io;
1032         s->io_win[io->map].flags &= (MAP_WRPROT
1033                                      | MAP_16BIT
1034                                      | MAP_ACTIVE);
1035         dprintk("SetIOMap exit\n");
1036
1037         return 0;
1038 }
1039
1040 static int m8xx_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *mem)
1041 {
1042         int lsock = container_of(sock, struct socket_info, socket)->slot;
1043         struct socket_info *s = &socket[lsock];
1044         struct pcmcia_win *w;
1045         struct pccard_mem_map *old;
1046         unsigned int reg, winnr;
1047         pcmconf8xx_t *pcmcia = s->pcmcia;
1048
1049         dprintk( "SetMemMap(%d, %d, %#2.2x, %d ns, "
1050               "%#5.5lx, %#5.5x)\n", lsock, mem->map, mem->flags,
1051               mem->speed, mem->static_start, mem->card_start);
1052
1053         if ((mem->map >= PCMCIA_MEM_WIN_NO)
1054 //          || ((mem->s) >= PCMCIA_MEM_WIN_SIZE)
1055             || (mem->card_start >= 0x04000000)
1056             || (mem->static_start & 0xfff)                /* 4KByte resolution */
1057             || (mem->card_start & 0xfff))
1058                 return -EINVAL;
1059
1060         if((reg = m8xx_get_graycode(PCMCIA_MEM_WIN_SIZE)) == -1) {
1061                 printk( "Cannot set size to 0x%08x.\n", PCMCIA_MEM_WIN_SIZE);
1062                 return -EINVAL;
1063         }
1064         reg <<= 27;
1065
1066         winnr = (lsock * PCMCIA_MEM_WIN_NO) + mem->map;
1067
1068         /* Setup the window in the pcmcia controller */
1069
1070         w = (void *) &pcmcia->pcmc_pbr0;
1071         w += winnr;
1072
1073         reg |= lsock << 2;
1074
1075         reg |= m8xx_get_speed(mem->speed, 0, s->bus_freq);
1076
1077         if(mem->flags & MAP_ATTRIB)
1078                 reg |=  M8XX_PCMCIA_POR_ATTRMEM;
1079
1080         if(mem->flags & MAP_WRPROT)
1081                 reg |= M8XX_PCMCIA_POR_WRPROT;
1082
1083         if(mem->flags & MAP_16BIT)
1084                 reg |= M8XX_PCMCIA_POR_16BIT;
1085
1086         if(mem->flags & MAP_ACTIVE)
1087                 reg |= M8XX_PCMCIA_POR_VALID;
1088
1089         out_be32(&w->or, reg);
1090
1091         dprintk("Socket %u: Mapped memory window %u at %#8.8x, "
1092               "OR = %#8.8x.\n", lsock, mem->map, w->br, w->or);
1093
1094         if(mem->flags & MAP_ACTIVE) {
1095                 /* get the new base address */
1096                 mem->static_start = PCMCIA_MEM_WIN_BASE +
1097                         (PCMCIA_MEM_WIN_SIZE * winnr)
1098                         + mem->card_start;
1099         }
1100
1101         dprintk("SetMemMap(%d, %d, %#2.2x, %d ns, "
1102               "%#5.5lx, %#5.5x)\n", lsock, mem->map, mem->flags,
1103               mem->speed, mem->static_start, mem->card_start);
1104
1105         /* copy the struct and modify the copy */
1106
1107         old = &s->mem_win[mem->map];
1108
1109         *old = *mem;
1110         old->flags &= (MAP_ATTRIB
1111                        | MAP_WRPROT
1112                        | MAP_16BIT
1113                        | MAP_ACTIVE);
1114
1115         return 0;
1116 }
1117
1118 static int m8xx_sock_init(struct pcmcia_socket *sock)
1119 {
1120         int i;
1121         pccard_io_map io = { 0, 0, 0, 0, 1 };
1122         pccard_mem_map mem = { 0, 0, 0, 0, 0, 0 };
1123
1124         dprintk( "sock_init(%d)\n", s);
1125
1126         m8xx_set_socket(sock, &dead_socket);
1127         for (i = 0; i < PCMCIA_IO_WIN_NO; i++) {
1128                 io.map = i;
1129                 m8xx_set_io_map(sock, &io);
1130         }
1131         for (i = 0; i < PCMCIA_MEM_WIN_NO; i++) {
1132                 mem.map = i;
1133                 m8xx_set_mem_map(sock, &mem);
1134         }
1135
1136         return 0;
1137
1138 }
1139
1140 static int m8xx_sock_suspend(struct pcmcia_socket *sock)
1141 {
1142         return m8xx_set_socket(sock, &dead_socket);
1143 }
1144
1145 static struct pccard_operations m8xx_services = {
1146         .init   = m8xx_sock_init,
1147         .suspend = m8xx_sock_suspend,
1148         .get_status = m8xx_get_status,
1149         .set_socket = m8xx_set_socket,
1150         .set_io_map = m8xx_set_io_map,
1151         .set_mem_map = m8xx_set_mem_map,
1152 };
1153
1154 static int __init m8xx_probe(struct of_device *ofdev, const struct of_device_id *match)
1155 {
1156         struct pcmcia_win *w;
1157         unsigned int i, m, hwirq;
1158         pcmconf8xx_t *pcmcia;
1159         int status;
1160         struct device_node *np = ofdev->node;
1161
1162         pcmcia_info("%s\n", version);
1163
1164         pcmcia = of_iomap(np, 0);
1165         if(pcmcia == NULL)
1166                 return -EINVAL;
1167
1168         pcmcia_schlvl = irq_of_parse_and_map(np, 0);
1169         hwirq  = irq_map[pcmcia_schlvl].hwirq;
1170         if (pcmcia_schlvl < 0)
1171                 return -EINVAL;
1172
1173         m8xx_pgcrx[0] = &pcmcia->pcmc_pgcra;
1174         m8xx_pgcrx[1] = &pcmcia->pcmc_pgcrb;
1175
1176
1177         pcmcia_info(PCMCIA_BOARD_MSG " using " PCMCIA_SLOT_MSG
1178                     " with IRQ %u  (%d). \n", pcmcia_schlvl, hwirq);
1179
1180         /* Configure Status change interrupt */
1181
1182         if(request_irq(pcmcia_schlvl, m8xx_interrupt, IRQF_SHARED,
1183                           driver_name, socket)) {
1184                 pcmcia_error("Cannot allocate IRQ %u for SCHLVL!\n",
1185                              pcmcia_schlvl);
1186                 return -1;
1187         }
1188
1189         w = (void *) &pcmcia->pcmc_pbr0;
1190
1191         out_be32(&pcmcia->pcmc_pscr, M8XX_PCMCIA_MASK(0)| M8XX_PCMCIA_MASK(1));
1192         clrbits32(&pcmcia->pcmc_per, M8XX_PCMCIA_MASK(0) | M8XX_PCMCIA_MASK(1));
1193
1194         /* connect interrupt and disable CxOE */
1195
1196         out_be32(M8XX_PGCRX(0), M8XX_PGCRX_CXOE | (mk_int_int_mask(hwirq) << 16));
1197         out_be32(M8XX_PGCRX(1), M8XX_PGCRX_CXOE | (mk_int_int_mask(hwirq) << 16));
1198
1199         /* intialize the fixed memory windows */
1200
1201         for(i = 0; i < PCMCIA_SOCKETS_NO; i++){
1202                 for (m = 0; m < PCMCIA_MEM_WIN_NO; m++) {
1203                         out_be32(&w->br, PCMCIA_MEM_WIN_BASE +
1204                                 (PCMCIA_MEM_WIN_SIZE
1205                                  * (m + i * PCMCIA_MEM_WIN_NO)));
1206
1207                         out_be32(&w->or, 0);  /* set to not valid */
1208
1209                         w++;
1210                 }
1211         }
1212
1213         /* turn off voltage */
1214         voltage_set(0, 0, 0);
1215         voltage_set(1, 0, 0);
1216
1217         /* Enable external hardware */
1218         hardware_enable(0);
1219         hardware_enable(1);
1220
1221         for (i = 0 ; i < PCMCIA_SOCKETS_NO; i++) {
1222                 socket[i].slot = i;
1223                 socket[i].socket.owner = THIS_MODULE;
1224                 socket[i].socket.features = SS_CAP_PCCARD | SS_CAP_MEM_ALIGN | SS_CAP_STATIC_MAP;
1225                 socket[i].socket.irq_mask = 0x000;
1226                 socket[i].socket.map_size = 0x1000;
1227                 socket[i].socket.io_offset = 0;
1228                 socket[i].socket.pci_irq = pcmcia_schlvl;
1229                 socket[i].socket.ops = &m8xx_services;
1230                 socket[i].socket.resource_ops = &pccard_nonstatic_ops;
1231                 socket[i].socket.cb_dev = NULL;
1232                 socket[i].socket.dev.parent = &ofdev->dev;
1233                 socket[i].pcmcia = pcmcia;
1234                 socket[i].bus_freq = ppc_proc_freq;
1235                 socket[i].hwirq = hwirq;
1236
1237
1238         }
1239
1240         for (i = 0; i < PCMCIA_SOCKETS_NO; i++) {
1241                 status = pcmcia_register_socket(&socket[i].socket);
1242                 if (status < 0)
1243                         pcmcia_error("Socket register failed\n");
1244         }
1245
1246         return 0;
1247 }
1248
1249 static int m8xx_remove(struct of_device* ofdev)
1250 {
1251         u32 m, i;
1252         struct pcmcia_win *w;
1253         pcmconf8xx_t *pcmcia = socket[0].pcmcia;
1254
1255         for (i = 0; i < PCMCIA_SOCKETS_NO; i++) {
1256                 w = (void *) &pcmcia->pcmc_pbr0;
1257
1258                 out_be32(&pcmcia->pcmc_pscr, M8XX_PCMCIA_MASK(i));
1259                 out_be32(&pcmcia->pcmc_per,
1260                         in_be32(&pcmcia->pcmc_per) & ~M8XX_PCMCIA_MASK(i));
1261
1262                 /* turn off interrupt and disable CxOE */
1263                 out_be32(M8XX_PGCRX(i), M8XX_PGCRX_CXOE);
1264
1265                 /* turn off memory windows */
1266                 for (m = 0; m < PCMCIA_MEM_WIN_NO; m++) {
1267                         out_be32(&w->or, 0); /* set to not valid */
1268                         w++;
1269                 }
1270
1271                 /* turn off voltage */
1272                 voltage_set(i, 0, 0);
1273
1274                 /* disable external hardware */
1275                 hardware_disable(i);
1276         }
1277         for (i = 0; i < PCMCIA_SOCKETS_NO; i++)
1278                 pcmcia_unregister_socket(&socket[i].socket);
1279
1280         free_irq(pcmcia_schlvl, NULL);
1281
1282         return 0;
1283 }
1284
1285 #ifdef CONFIG_PM
1286 static int m8xx_suspend(struct platform_device *pdev, pm_message_t state)
1287 {
1288         return pcmcia_socket_dev_suspend(&pdev->dev, state);
1289 }
1290
1291 static int m8xx_resume(struct platform_device *pdev)
1292 {
1293         return pcmcia_socket_dev_resume(&pdev->dev);
1294 }
1295 #else
1296 #define m8xx_suspend NULL
1297 #define m8xx_resume NULL
1298 #endif
1299
1300 static struct of_device_id m8xx_pcmcia_match[] = {
1301         {
1302                 .type = "pcmcia",
1303                 .compatible = "fsl,pq-pcmcia",
1304         },
1305         {},
1306 };
1307
1308 MODULE_DEVICE_TABLE(of, m8xx_pcmcia_match);
1309
1310 static struct of_platform_driver m8xx_pcmcia_driver = {
1311         .name           = (char *) driver_name,
1312         .match_table    = m8xx_pcmcia_match,
1313         .probe          = m8xx_probe,
1314         .remove         = m8xx_remove,
1315         .suspend        = m8xx_suspend,
1316         .resume         = m8xx_resume,
1317 };
1318
1319 static int __init m8xx_init(void)
1320 {
1321         return of_register_platform_driver(&m8xx_pcmcia_driver);
1322 }
1323
1324 static void __exit m8xx_exit(void)
1325 {
1326         of_unregister_platform_driver(&m8xx_pcmcia_driver);
1327 }
1328
1329 module_init(m8xx_init);
1330 module_exit(m8xx_exit);