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