Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us