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