1 // SPDX-License-Identifier: GPL-2.0-only
3 * linux/arch/arm/kernel/ecard.c
5 * Copyright 1995-2001 Russell King
7 * Find all installed expansion cards, and handle interrupts from them.
9 * Created from information from Acorns RiscOS3 PRMs
11 * 08-Dec-1996 RMK Added code for the 9'th expansion card - the ether
13 * 06-May-1997 RMK Added blacklist for cards whose loader doesn't work.
14 * 12-Sep-1997 RMK Created new handling of interrupt enables/disables
15 * - cards can now register their own routine to control
16 * interrupts (recommended).
17 * 29-Sep-1997 RMK Expansion card interrupt hardware not being re-enabled
18 * on reset from Linux. (Caused cards not to respond
19 * under RiscOS without hard reset).
20 * 15-Feb-1998 RMK Added DMA support
21 * 12-Sep-1998 RMK Added EASI support
22 * 10-Jan-1999 RMK Run loaders in a simulated RISC OS environment.
23 * 17-Apr-1999 RMK Support for EASI Type C cycles.
27 #include <linux/module.h>
28 #include <linux/kernel.h>
29 #include <linux/types.h>
30 #include <linux/sched.h>
31 #include <linux/sched/mm.h>
32 #include <linux/interrupt.h>
33 #include <linux/completion.h>
34 #include <linux/reboot.h>
36 #include <linux/slab.h>
37 #include <linux/proc_fs.h>
38 #include <linux/seq_file.h>
39 #include <linux/device.h>
40 #include <linux/init.h>
41 #include <linux/mutex.h>
42 #include <linux/kthread.h>
43 #include <linux/irq.h>
47 #include <asm/ecard.h>
48 #include <mach/hardware.h>
50 #include <asm/mmu_context.h>
51 #include <asm/mach/irq.h>
52 #include <asm/tlbflush.h>
56 struct ecard_request
{
57 void (*fn
)(struct ecard_request
*);
61 unsigned int use_loader
;
63 struct completion
*complete
;
66 struct expcard_quirklist
{
67 unsigned short manufacturer
;
68 unsigned short product
;
70 void (*init
)(ecard_t
*ec
);
73 static ecard_t
*cards
;
74 static ecard_t
*slot_to_expcard
[MAX_ECARDS
];
75 static unsigned int ectcr
;
77 static void atomwide_3p_quirk(ecard_t
*ec
);
79 /* List of descriptions of cards which don't have an extended
80 * identification, or chunk directories containing a description.
82 static struct expcard_quirklist quirklist
[] __initdata
= {
83 { MANU_ACORN
, PROD_ACORN_ETHER1
, "Acorn Ether1" },
84 { MANU_ATOMWIDE
, PROD_ATOMWIDE_3PSERIAL
, NULL
, atomwide_3p_quirk
},
88 ecard_loader_reset(unsigned long base
, loader_t loader
);
90 ecard_loader_read(int off
, unsigned long base
, loader_t loader
);
92 static inline unsigned short ecard_getu16(unsigned char *v
)
94 return v
[0] | v
[1] << 8;
97 static inline signed long ecard_gets24(unsigned char *v
)
99 return v
[0] | v
[1] << 8 | v
[2] << 16 | ((v
[2] & 0x80) ? 0xff000000 : 0);
102 static inline ecard_t
*slot_to_ecard(unsigned int slot
)
104 return slot
< MAX_ECARDS
? slot_to_expcard
[slot
] : NULL
;
107 /* ===================== Expansion card daemon ======================== */
109 * Since the loader programs on the expansion cards need to be run
110 * in a specific environment, create a separate task with this
111 * environment up, and pass requests to this task as and when we
114 * This should allow 99% of loaders to be called from Linux.
116 * From a security standpoint, we trust the card vendors. This
117 * may be a misplaced trust.
119 static void ecard_task_reset(struct ecard_request
*req
)
121 struct expansion_card
*ec
= req
->ec
;
122 struct resource
*res
;
124 res
= ec
->slot_no
== 8
125 ? &ec
->resource
[ECARD_RES_MEMC
]
127 ? &ec
->resource
[ECARD_RES_EASI
]
128 : &ec
->resource
[ECARD_RES_IOCSYNC
];
130 ecard_loader_reset(res
->start
, ec
->loader
);
133 static void ecard_task_readbytes(struct ecard_request
*req
)
135 struct expansion_card
*ec
= req
->ec
;
136 unsigned char *buf
= req
->buffer
;
137 unsigned int len
= req
->length
;
138 unsigned int off
= req
->address
;
140 if (ec
->slot_no
== 8) {
141 void __iomem
*base
= (void __iomem
*)
142 ec
->resource
[ECARD_RES_MEMC
].start
;
145 * The card maintains an index which increments the address
146 * into a 4096-byte page on each access. We need to keep
147 * track of the counter.
149 static unsigned int index
;
152 page
= (off
>> 12) * 4;
159 * If we are reading offset 0, or our current index is
160 * greater than the offset, reset the hardware index counter.
162 if (off
== 0 || index
> off
) {
168 * Increment the hardware index counter until we get to the
169 * required offset. The read bytes are discarded.
171 while (index
< off
) {
177 *buf
++ = readb(base
+ page
);
181 unsigned long base
= (ec
->easi
182 ? &ec
->resource
[ECARD_RES_EASI
]
183 : &ec
->resource
[ECARD_RES_IOCSYNC
])->start
;
184 void __iomem
*pbase
= (void __iomem
*)base
;
186 if (!req
->use_loader
|| !ec
->loader
) {
189 *buf
++ = readb(pbase
+ off
);
195 * The following is required by some
196 * expansion card loader programs.
198 *(unsigned long *)0x108 = 0;
199 *buf
++ = ecard_loader_read(off
++, base
,
207 static DECLARE_WAIT_QUEUE_HEAD(ecard_wait
);
208 static struct ecard_request
*ecard_req
;
209 static DEFINE_MUTEX(ecard_mutex
);
212 * Set up the expansion card daemon's page tables.
214 static void ecard_init_pgtables(struct mm_struct
*mm
)
216 struct vm_area_struct vma
= TLB_FLUSH_VMA(mm
, VM_EXEC
);
218 /* We want to set up the page tables for the following mapping:
220 * 0x03000000 0x03000000
221 * 0x03010000 unmapped
222 * 0x03210000 0x03210000
223 * 0x03400000 unmapped
224 * 0x08000000 0x08000000
225 * 0x10000000 unmapped
227 * FIXME: we don't follow this 100% yet.
229 pgd_t
*src_pgd
, *dst_pgd
;
231 src_pgd
= pgd_offset(mm
, (unsigned long)IO_BASE
);
232 dst_pgd
= pgd_offset(mm
, IO_START
);
234 memcpy(dst_pgd
, src_pgd
, sizeof(pgd_t
) * (IO_SIZE
/ PGDIR_SIZE
));
236 src_pgd
= pgd_offset(mm
, (unsigned long)EASI_BASE
);
237 dst_pgd
= pgd_offset(mm
, EASI_START
);
239 memcpy(dst_pgd
, src_pgd
, sizeof(pgd_t
) * (EASI_SIZE
/ PGDIR_SIZE
));
241 flush_tlb_range(&vma
, IO_START
, IO_START
+ IO_SIZE
);
242 flush_tlb_range(&vma
, EASI_START
, EASI_START
+ EASI_SIZE
);
245 static int ecard_init_mm(void)
247 struct mm_struct
* mm
= mm_alloc();
248 struct mm_struct
*active_mm
= current
->active_mm
;
254 current
->active_mm
= mm
;
255 activate_mm(active_mm
, mm
);
257 ecard_init_pgtables(mm
);
262 ecard_task(void * unused
)
265 * Allocate a mm. We're not a lazy-TLB kernel task since we need
266 * to set page table entries where the user space would be. Note
267 * that this also creates the page tables. Failure is not an
271 panic("kecardd: unable to alloc mm\n");
274 struct ecard_request
*req
;
276 wait_event_interruptible(ecard_wait
, ecard_req
!= NULL
);
278 req
= xchg(&ecard_req
, NULL
);
281 complete(req
->complete
);
287 * Wake the expansion card daemon to action our request.
289 * FIXME: The test here is not sufficient to detect if the
292 static void ecard_call(struct ecard_request
*req
)
294 DECLARE_COMPLETION_ONSTACK(completion
);
296 req
->complete
= &completion
;
298 mutex_lock(&ecard_mutex
);
300 wake_up(&ecard_wait
);
303 * Now wait for kecardd to run.
305 wait_for_completion(&completion
);
306 mutex_unlock(&ecard_mutex
);
309 /* ======================= Mid-level card control ===================== */
312 ecard_readbytes(void *addr
, ecard_t
*ec
, int off
, int len
, int useld
)
314 struct ecard_request req
;
316 req
.fn
= ecard_task_readbytes
;
320 req
.use_loader
= useld
;
326 int ecard_readchunk(struct in_chunk_dir
*cd
, ecard_t
*ec
, int id
, int num
)
328 struct ex_chunk_dir excd
;
336 ecard_readbytes(&excd
, ec
, index
, 8, useld
);
338 if (c_id(&excd
) == 0) {
339 if (!useld
&& ec
->loader
) {
346 if (c_id(&excd
) == 0xf0) { /* link */
347 index
= c_start(&excd
);
350 if (c_id(&excd
) == 0x80) { /* loader */
352 ec
->loader
= kmalloc(c_len(&excd
),
355 ecard_readbytes(ec
->loader
, ec
,
357 c_len(&excd
), useld
);
363 if (c_id(&excd
) == id
&& num
-- == 0)
367 if (c_id(&excd
) & 0x80) {
368 switch (c_id(&excd
) & 0x70) {
370 ecard_readbytes((unsigned char *)excd
.d
.string
, ec
,
371 (int)c_start(&excd
), c_len(&excd
),
378 cd
->start_offset
= c_start(&excd
);
379 memcpy(cd
->d
.string
, excd
.d
.string
, 256);
383 /* ======================= Interrupt control ============================ */
385 static void ecard_def_irq_enable(ecard_t
*ec
, int irqnr
)
389 static void ecard_def_irq_disable(ecard_t
*ec
, int irqnr
)
393 static int ecard_def_irq_pending(ecard_t
*ec
)
395 return !ec
->irqmask
|| readb(ec
->irqaddr
) & ec
->irqmask
;
398 static void ecard_def_fiq_enable(ecard_t
*ec
, int fiqnr
)
400 panic("ecard_def_fiq_enable called - impossible");
403 static void ecard_def_fiq_disable(ecard_t
*ec
, int fiqnr
)
405 panic("ecard_def_fiq_disable called - impossible");
408 static int ecard_def_fiq_pending(ecard_t
*ec
)
410 return !ec
->fiqmask
|| readb(ec
->fiqaddr
) & ec
->fiqmask
;
413 static expansioncard_ops_t ecard_default_ops
= {
414 ecard_def_irq_enable
,
415 ecard_def_irq_disable
,
416 ecard_def_irq_pending
,
417 ecard_def_fiq_enable
,
418 ecard_def_fiq_disable
,
419 ecard_def_fiq_pending
423 * Enable and disable interrupts from expansion cards.
424 * (interrupts are disabled for these functions).
426 * They are not meant to be called directly, but via enable/disable_irq.
428 static void ecard_irq_unmask(struct irq_data
*d
)
430 ecard_t
*ec
= irq_data_get_irq_chip_data(d
);
434 ec
->ops
= &ecard_default_ops
;
436 if (ec
->claimed
&& ec
->ops
->irqenable
)
437 ec
->ops
->irqenable(ec
, d
->irq
);
439 printk(KERN_ERR
"ecard: rejecting request to "
440 "enable IRQs for %d\n", d
->irq
);
444 static void ecard_irq_mask(struct irq_data
*d
)
446 ecard_t
*ec
= irq_data_get_irq_chip_data(d
);
450 ec
->ops
= &ecard_default_ops
;
452 if (ec
->ops
&& ec
->ops
->irqdisable
)
453 ec
->ops
->irqdisable(ec
, d
->irq
);
457 static struct irq_chip ecard_chip
= {
459 .irq_ack
= ecard_irq_mask
,
460 .irq_mask
= ecard_irq_mask
,
461 .irq_unmask
= ecard_irq_unmask
,
464 void ecard_enablefiq(unsigned int fiqnr
)
466 ecard_t
*ec
= slot_to_ecard(fiqnr
);
470 ec
->ops
= &ecard_default_ops
;
472 if (ec
->claimed
&& ec
->ops
->fiqenable
)
473 ec
->ops
->fiqenable(ec
, fiqnr
);
475 printk(KERN_ERR
"ecard: rejecting request to "
476 "enable FIQs for %d\n", fiqnr
);
480 void ecard_disablefiq(unsigned int fiqnr
)
482 ecard_t
*ec
= slot_to_ecard(fiqnr
);
486 ec
->ops
= &ecard_default_ops
;
488 if (ec
->ops
->fiqdisable
)
489 ec
->ops
->fiqdisable(ec
, fiqnr
);
493 static void ecard_dump_irq_state(void)
497 printk("Expansion card IRQ state:\n");
499 for (ec
= cards
; ec
; ec
= ec
->next
) {
502 if (ec
->slot_no
== 8)
505 claimed
= ec
->claimed
? "" : "not ";
507 if (ec
->ops
&& ec
->ops
->irqpending
&&
508 ec
->ops
!= &ecard_default_ops
)
509 printk(" %d: %sclaimed irq %spending\n",
510 ec
->slot_no
, claimed
,
511 ec
->ops
->irqpending(ec
) ? "" : "not ");
513 printk(" %d: %sclaimed irqaddr %p, mask = %02X, status = %02X\n",
514 ec
->slot_no
, claimed
,
515 ec
->irqaddr
, ec
->irqmask
, readb(ec
->irqaddr
));
519 static void ecard_check_lockup(struct irq_desc
*desc
)
521 static unsigned long last
;
525 * If the timer interrupt has not run since the last million
526 * unrecognised expansion card interrupts, then there is
527 * something seriously wrong. Disable the expansion card
528 * interrupts so at least we can continue.
530 * Maybe we ought to start a timer to re-enable them some time
533 if (last
== jiffies
) {
535 if (lockup
> 1000000) {
536 printk(KERN_ERR
"\nInterrupt lockup detected - "
537 "disabling all expansion card interrupts\n");
539 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
540 ecard_dump_irq_state();
546 * If we did not recognise the source of this interrupt,
547 * warn the user, but don't flood the user with these messages.
549 if (!last
|| time_after(jiffies
, last
+ 5*HZ
)) {
551 printk(KERN_WARNING
"Unrecognised interrupt from backplane\n");
552 ecard_dump_irq_state();
556 static void ecard_irq_handler(struct irq_desc
*desc
)
561 desc
->irq_data
.chip
->irq_mask(&desc
->irq_data
);
562 for (ec
= cards
; ec
; ec
= ec
->next
) {
565 if (!ec
->claimed
|| !ec
->irq
|| ec
->slot_no
== 8)
568 if (ec
->ops
&& ec
->ops
->irqpending
)
569 pending
= ec
->ops
->irqpending(ec
);
571 pending
= ecard_default_ops
.irqpending(ec
);
574 generic_handle_irq(ec
->irq
);
578 desc
->irq_data
.chip
->irq_unmask(&desc
->irq_data
);
581 ecard_check_lockup(desc
);
584 static void __iomem
*__ecard_address(ecard_t
*ec
, card_type_t type
, card_speed_t speed
)
586 void __iomem
*address
= NULL
;
587 int slot
= ec
->slot_no
;
589 if (ec
->slot_no
== 8)
590 return ECARD_MEMC8_BASE
;
592 ectcr
&= ~(1 << slot
);
597 address
= ECARD_MEMC_BASE
+ (slot
<< 14);
602 address
= ECARD_IOC_BASE
+ (slot
<< 14);
604 address
= ECARD_IOC4_BASE
+ ((slot
- 4) << 14);
606 address
+= speed
<< 19;
610 address
= ECARD_EASI_BASE
+ (slot
<< 24);
611 if (speed
== ECARD_FAST
)
620 iomd_writeb(ectcr
, IOMD_ECTCR
);
625 static int ecard_prints(struct seq_file
*m
, ecard_t
*ec
)
627 seq_printf(m
, " %d: %s ", ec
->slot_no
, ec
->easi
? "EASI" : " ");
629 if (ec
->cid
.id
== 0) {
630 struct in_chunk_dir incd
;
632 seq_printf(m
, "[%04X:%04X] ",
633 ec
->cid
.manufacturer
, ec
->cid
.product
);
635 if (!ec
->card_desc
&& ec
->cid
.cd
&&
636 ecard_readchunk(&incd
, ec
, 0xf5, 0)) {
637 ec
->card_desc
= kmalloc(strlen(incd
.d
.string
)+1, GFP_KERNEL
);
640 strcpy((char *)ec
->card_desc
, incd
.d
.string
);
643 seq_printf(m
, "%s\n", ec
->card_desc
? ec
->card_desc
: "*unknown*");
645 seq_printf(m
, "Simple card %d\n", ec
->cid
.id
);
650 static int ecard_devices_proc_show(struct seq_file
*m
, void *v
)
661 static struct proc_dir_entry
*proc_bus_ecard_dir
= NULL
;
663 static void ecard_proc_init(void)
665 proc_bus_ecard_dir
= proc_mkdir("bus/ecard", NULL
);
666 proc_create_single("devices", 0, proc_bus_ecard_dir
,
667 ecard_devices_proc_show
);
670 #define ec_set_resource(ec,nr,st,sz) \
672 (ec)->resource[nr].name = dev_name(&ec->dev); \
673 (ec)->resource[nr].start = st; \
674 (ec)->resource[nr].end = (st) + (sz) - 1; \
675 (ec)->resource[nr].flags = IORESOURCE_MEM; \
678 static void __init
ecard_free_card(struct expansion_card
*ec
)
682 for (i
= 0; i
< ECARD_NUM_RESOURCES
; i
++)
683 if (ec
->resource
[i
].flags
)
684 release_resource(&ec
->resource
[i
]);
689 static struct expansion_card
*__init
ecard_alloc_card(int type
, int slot
)
691 struct expansion_card
*ec
;
695 ec
= kzalloc(sizeof(ecard_t
), GFP_KERNEL
);
697 ec
= ERR_PTR(-ENOMEM
);
702 ec
->easi
= type
== ECARD_EASI
;
706 ec
->ops
= &ecard_default_ops
;
708 dev_set_name(&ec
->dev
, "ecard%d", slot
);
709 ec
->dev
.parent
= NULL
;
710 ec
->dev
.bus
= &ecard_bus_type
;
711 ec
->dev
.dma_mask
= &ec
->dma_mask
;
712 ec
->dma_mask
= (u64
)0xffffffff;
713 ec
->dev
.coherent_dma_mask
= ec
->dma_mask
;
716 ec_set_resource(ec
, ECARD_RES_MEMC
,
717 PODSLOT_MEMC_BASE
+ (slot
<< 14),
719 base
= PODSLOT_IOC0_BASE
+ (slot
<< 14);
721 base
= PODSLOT_IOC4_BASE
+ ((slot
- 4) << 14);
723 #ifdef CONFIG_ARCH_RPC
725 ec_set_resource(ec
, ECARD_RES_EASI
,
726 PODSLOT_EASI_BASE
+ (slot
<< 24),
731 ec_set_resource(ec
, ECARD_RES_MEMC
, NETSLOT_BASE
, NETSLOT_SIZE
);
735 for (i
= 0; i
<= ECARD_RES_IOCSYNC
- ECARD_RES_IOCSLOW
; i
++)
736 ec_set_resource(ec
, i
+ ECARD_RES_IOCSLOW
,
737 base
+ (i
<< 19), PODSLOT_IOC_SIZE
);
739 for (i
= 0; i
< ECARD_NUM_RESOURCES
; i
++) {
740 if (ec
->resource
[i
].flags
&&
741 request_resource(&iomem_resource
, &ec
->resource
[i
])) {
742 dev_err(&ec
->dev
, "resource(s) not available\n");
743 ec
->resource
[i
].end
-= ec
->resource
[i
].start
;
744 ec
->resource
[i
].start
= 0;
745 ec
->resource
[i
].flags
= 0;
753 static ssize_t
irq_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
755 struct expansion_card
*ec
= ECARD_DEV(dev
);
756 return sprintf(buf
, "%u\n", ec
->irq
);
758 static DEVICE_ATTR_RO(irq
);
760 static ssize_t
dma_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
762 struct expansion_card
*ec
= ECARD_DEV(dev
);
763 return sprintf(buf
, "%u\n", ec
->dma
);
765 static DEVICE_ATTR_RO(dma
);
767 static ssize_t
resource_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
769 struct expansion_card
*ec
= ECARD_DEV(dev
);
773 for (i
= 0; i
< ECARD_NUM_RESOURCES
; i
++)
774 str
+= sprintf(str
, "%08x %08x %08lx\n",
775 ec
->resource
[i
].start
,
777 ec
->resource
[i
].flags
);
781 static DEVICE_ATTR_RO(resource
);
783 static ssize_t
vendor_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
785 struct expansion_card
*ec
= ECARD_DEV(dev
);
786 return sprintf(buf
, "%u\n", ec
->cid
.manufacturer
);
788 static DEVICE_ATTR_RO(vendor
);
790 static ssize_t
device_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
792 struct expansion_card
*ec
= ECARD_DEV(dev
);
793 return sprintf(buf
, "%u\n", ec
->cid
.product
);
795 static DEVICE_ATTR_RO(device
);
797 static ssize_t
type_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
799 struct expansion_card
*ec
= ECARD_DEV(dev
);
800 return sprintf(buf
, "%s\n", ec
->easi
? "EASI" : "IOC");
802 static DEVICE_ATTR_RO(type
);
804 static struct attribute
*ecard_dev_attrs
[] = {
805 &dev_attr_device
.attr
,
808 &dev_attr_resource
.attr
,
810 &dev_attr_vendor
.attr
,
813 ATTRIBUTE_GROUPS(ecard_dev
);
815 int ecard_request_resources(struct expansion_card
*ec
)
819 for (i
= 0; i
< ECARD_NUM_RESOURCES
; i
++) {
820 if (ecard_resource_end(ec
, i
) &&
821 !request_mem_region(ecard_resource_start(ec
, i
),
822 ecard_resource_len(ec
, i
),
823 ec
->dev
.driver
->name
)) {
831 if (ecard_resource_end(ec
, i
))
832 release_mem_region(ecard_resource_start(ec
, i
),
833 ecard_resource_len(ec
, i
));
837 EXPORT_SYMBOL(ecard_request_resources
);
839 void ecard_release_resources(struct expansion_card
*ec
)
843 for (i
= 0; i
< ECARD_NUM_RESOURCES
; i
++)
844 if (ecard_resource_end(ec
, i
))
845 release_mem_region(ecard_resource_start(ec
, i
),
846 ecard_resource_len(ec
, i
));
848 EXPORT_SYMBOL(ecard_release_resources
);
850 void ecard_setirq(struct expansion_card
*ec
, const struct expansion_card_ops
*ops
, void *irq_data
)
852 ec
->irq_data
= irq_data
;
856 EXPORT_SYMBOL(ecard_setirq
);
858 void __iomem
*ecardm_iomap(struct expansion_card
*ec
, unsigned int res
,
859 unsigned long offset
, unsigned long maxsize
)
861 unsigned long start
= ecard_resource_start(ec
, res
);
862 unsigned long end
= ecard_resource_end(ec
, res
);
864 if (offset
> (end
- start
))
868 if (maxsize
&& end
- start
> maxsize
)
869 end
= start
+ maxsize
;
871 return devm_ioremap(&ec
->dev
, start
, end
- start
);
873 EXPORT_SYMBOL(ecardm_iomap
);
875 static void atomwide_3p_quirk(ecard_t
*ec
)
877 void __iomem
*addr
= __ecard_address(ec
, ECARD_IOC
, ECARD_SYNC
);
880 /* Disable interrupts on each port */
881 for (i
= 0x2000; i
<= 0x2800; i
+= 0x0400)
882 writeb(0, addr
+ i
+ 4);
886 * Probe for an expansion card.
888 * If bit 1 of the first byte of the card is set, then the
889 * card does not exist.
891 static int __init
ecard_probe(int slot
, unsigned irq
, card_type_t type
)
899 ec
= ecard_alloc_card(type
, slot
);
906 if ((addr
= __ecard_address(ec
, type
, ECARD_SYNC
)) == NULL
)
910 ecard_readbytes(&cid
, ec
, 0, 16, 0);
914 ec
->cid
.id
= cid
.r_id
;
915 ec
->cid
.cd
= cid
.r_cd
;
916 ec
->cid
.is
= cid
.r_is
;
918 ec
->cid
.manufacturer
= ecard_getu16(cid
.r_manu
);
919 ec
->cid
.product
= ecard_getu16(cid
.r_prod
);
920 ec
->cid
.country
= cid
.r_country
;
921 ec
->cid
.irqmask
= cid
.r_irqmask
;
922 ec
->cid
.irqoff
= ecard_gets24(cid
.r_irqoff
);
923 ec
->cid
.fiqmask
= cid
.r_fiqmask
;
924 ec
->cid
.fiqoff
= ecard_gets24(cid
.r_fiqoff
);
929 ec
->irqmask
= ec
->cid
.irqmask
;
930 ec
->irqaddr
+= ec
->cid
.irqoff
;
931 ec
->fiqmask
= ec
->cid
.fiqmask
;
932 ec
->fiqaddr
+= ec
->cid
.fiqoff
;
938 for (i
= 0; i
< ARRAY_SIZE(quirklist
); i
++)
939 if (quirklist
[i
].manufacturer
== ec
->cid
.manufacturer
&&
940 quirklist
[i
].product
== ec
->cid
.product
) {
941 if (quirklist
[i
].type
)
942 ec
->card_desc
= quirklist
[i
].type
;
943 if (quirklist
[i
].init
)
944 quirklist
[i
].init(ec
);
951 * hook the interrupt handlers
954 irq_set_chip_and_handler(ec
->irq
, &ecard_chip
,
956 irq_set_chip_data(ec
->irq
, ec
);
957 irq_clear_status_flags(ec
->irq
, IRQ_NOREQUEST
);
960 #ifdef CONFIG_ARCH_RPC
961 /* On RiscPC, only first two slots have DMA capability */
966 for (ecp
= &cards
; *ecp
; ecp
= &(*ecp
)->next
);
969 slot_to_expcard
[slot
] = ec
;
971 rc
= device_register(&ec
->dev
);
984 * Initialise the expansion card system.
985 * Locate all hardware - interrupt management and
988 static int __init
ecard_init(void)
990 struct task_struct
*task
;
993 irqbase
= irq_alloc_descs(-1, 0, 8, -1);
997 task
= kthread_run(ecard_task
, NULL
, "kecardd");
999 printk(KERN_ERR
"Ecard: unable to create kernel thread: %ld\n",
1001 irq_free_descs(irqbase
, 8);
1002 return PTR_ERR(task
);
1005 printk("Probing expansion cards\n");
1007 for (slot
= 0; slot
< 8; slot
++) {
1008 if (ecard_probe(slot
, irqbase
+ slot
, ECARD_EASI
) == -ENODEV
)
1009 ecard_probe(slot
, irqbase
+ slot
, ECARD_IOC
);
1012 ecard_probe(8, 11, ECARD_IOC
);
1014 irq_set_chained_handler(IRQ_EXPANSIONCARD
, ecard_irq_handler
);
1021 subsys_initcall(ecard_init
);
1026 static const struct ecard_id
*
1027 ecard_match_device(const struct ecard_id
*ids
, struct expansion_card
*ec
)
1031 for (i
= 0; ids
[i
].manufacturer
!= 65535; i
++)
1032 if (ec
->cid
.manufacturer
== ids
[i
].manufacturer
&&
1033 ec
->cid
.product
== ids
[i
].product
)
1039 static int ecard_drv_probe(struct device
*dev
)
1041 struct expansion_card
*ec
= ECARD_DEV(dev
);
1042 struct ecard_driver
*drv
= ECARD_DRV(dev
->driver
);
1043 const struct ecard_id
*id
;
1046 id
= ecard_match_device(drv
->id_table
, ec
);
1049 ret
= drv
->probe(ec
, id
);
1055 static int ecard_drv_remove(struct device
*dev
)
1057 struct expansion_card
*ec
= ECARD_DEV(dev
);
1058 struct ecard_driver
*drv
= ECARD_DRV(dev
->driver
);
1064 * Restore the default operations. We ensure that the
1065 * ops are set before we change the data.
1067 ec
->ops
= &ecard_default_ops
;
1069 ec
->irq_data
= NULL
;
1075 * Before rebooting, we must make sure that the expansion card is in a
1076 * sensible state, so it can be re-detected. This means that the first
1077 * page of the ROM must be visible. We call the expansion cards reset
1080 static void ecard_drv_shutdown(struct device
*dev
)
1082 struct expansion_card
*ec
= ECARD_DEV(dev
);
1083 struct ecard_driver
*drv
= ECARD_DRV(dev
->driver
);
1084 struct ecard_request req
;
1093 * If this card has a loader, call the reset handler.
1096 req
.fn
= ecard_task_reset
;
1102 int ecard_register_driver(struct ecard_driver
*drv
)
1104 drv
->drv
.bus
= &ecard_bus_type
;
1106 return driver_register(&drv
->drv
);
1109 void ecard_remove_driver(struct ecard_driver
*drv
)
1111 driver_unregister(&drv
->drv
);
1114 static int ecard_match(struct device
*_dev
, struct device_driver
*_drv
)
1116 struct expansion_card
*ec
= ECARD_DEV(_dev
);
1117 struct ecard_driver
*drv
= ECARD_DRV(_drv
);
1120 if (drv
->id_table
) {
1121 ret
= ecard_match_device(drv
->id_table
, ec
) != NULL
;
1123 ret
= ec
->cid
.id
== drv
->id
;
1129 struct bus_type ecard_bus_type
= {
1131 .dev_groups
= ecard_dev_groups
,
1132 .match
= ecard_match
,
1133 .probe
= ecard_drv_probe
,
1134 .remove
= ecard_drv_remove
,
1135 .shutdown
= ecard_drv_shutdown
,
1138 static int ecard_bus_init(void)
1140 return bus_register(&ecard_bus_type
);
1143 postcore_initcall(ecard_bus_init
);
1145 EXPORT_SYMBOL(ecard_readchunk
);
1146 EXPORT_SYMBOL(ecard_register_driver
);
1147 EXPORT_SYMBOL(ecard_remove_driver
);
1148 EXPORT_SYMBOL(ecard_bus_type
);