[PCMCIA] MPC8xx PCMCIA update
[linux-2.6.git] / drivers / pcmcia / m8xx_pcmcia.c
1 /*
2  * m8xx_pcmcia.c - Linux PCMCIA socket driver for the mpc8xx series.
3  *
4  * (C) 1999-2000 Magnus Damm <damm@bitsmart.com>
5  * (C) 2001-2002 Montavista Software, Inc.
6  *     <mlocke@mvista.com>
7  *
8  * Support for two slots by Cyclades Corporation
9  *     <oliver.kurth@cyclades.de>
10  * Further fixes, v2.6 kernel port
11  *     <marcelo.tosatti@cyclades.com>
12  *
13  * "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);