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