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