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