2 * linux/drivers/ide/arm/icside.c
4 * Copyright (c) 1996-2004 Russell King.
6 * Please note that this platform does not support 32-bit IDE IO.
9 #include <linux/string.h>
10 #include <linux/module.h>
11 #include <linux/ioport.h>
12 #include <linux/slab.h>
13 #include <linux/blkdev.h>
14 #include <linux/errno.h>
15 #include <linux/hdreg.h>
16 #include <linux/ide.h>
17 #include <linux/dma-mapping.h>
18 #include <linux/device.h>
19 #include <linux/init.h>
20 #include <linux/scatterlist.h>
24 #include <asm/ecard.h>
26 #define ICS_IDENT_OFFSET 0x2280
28 #define ICS_ARCIN_V5_INTRSTAT 0x0000
29 #define ICS_ARCIN_V5_INTROFFSET 0x0004
30 #define ICS_ARCIN_V5_IDEOFFSET 0x2800
31 #define ICS_ARCIN_V5_IDEALTOFFSET 0x2b80
32 #define ICS_ARCIN_V5_IDESTEPPING 6
34 #define ICS_ARCIN_V6_IDEOFFSET_1 0x2000
35 #define ICS_ARCIN_V6_INTROFFSET_1 0x2200
36 #define ICS_ARCIN_V6_INTRSTAT_1 0x2290
37 #define ICS_ARCIN_V6_IDEALTOFFSET_1 0x2380
38 #define ICS_ARCIN_V6_IDEOFFSET_2 0x3000
39 #define ICS_ARCIN_V6_INTROFFSET_2 0x3200
40 #define ICS_ARCIN_V6_INTRSTAT_2 0x3290
41 #define ICS_ARCIN_V6_IDEALTOFFSET_2 0x3380
42 #define ICS_ARCIN_V6_IDESTEPPING 6
45 unsigned int dataoffset
;
46 unsigned int ctrloffset
;
47 unsigned int stepping
;
50 static struct cardinfo icside_cardinfo_v5
= {
51 .dataoffset
= ICS_ARCIN_V5_IDEOFFSET
,
52 .ctrloffset
= ICS_ARCIN_V5_IDEALTOFFSET
,
53 .stepping
= ICS_ARCIN_V5_IDESTEPPING
,
56 static struct cardinfo icside_cardinfo_v6_1
= {
57 .dataoffset
= ICS_ARCIN_V6_IDEOFFSET_1
,
58 .ctrloffset
= ICS_ARCIN_V6_IDEALTOFFSET_1
,
59 .stepping
= ICS_ARCIN_V6_IDESTEPPING
,
62 static struct cardinfo icside_cardinfo_v6_2
= {
63 .dataoffset
= ICS_ARCIN_V6_IDEOFFSET_2
,
64 .ctrloffset
= ICS_ARCIN_V6_IDEALTOFFSET_2
,
65 .stepping
= ICS_ARCIN_V6_IDESTEPPING
,
71 void __iomem
*irq_port
;
72 void __iomem
*ioc_base
;
74 /* parent device... until the IDE core gets one of its own */
79 #define ICS_TYPE_A3IN 0
80 #define ICS_TYPE_A3USER 1
82 #define ICS_TYPE_V5 15
83 #define ICS_TYPE_NOTYPE ((unsigned int)-1)
85 /* ---------------- Version 5 PCB Support Functions --------------------- */
86 /* Prototype: icside_irqenable_arcin_v5 (struct expansion_card *ec, int irqnr)
87 * Purpose : enable interrupts from card
89 static void icside_irqenable_arcin_v5 (struct expansion_card
*ec
, int irqnr
)
91 struct icside_state
*state
= ec
->irq_data
;
93 writeb(0, state
->irq_port
+ ICS_ARCIN_V5_INTROFFSET
);
96 /* Prototype: icside_irqdisable_arcin_v5 (struct expansion_card *ec, int irqnr)
97 * Purpose : disable interrupts from card
99 static void icside_irqdisable_arcin_v5 (struct expansion_card
*ec
, int irqnr
)
101 struct icside_state
*state
= ec
->irq_data
;
103 readb(state
->irq_port
+ ICS_ARCIN_V5_INTROFFSET
);
106 static const expansioncard_ops_t icside_ops_arcin_v5
= {
107 .irqenable
= icside_irqenable_arcin_v5
,
108 .irqdisable
= icside_irqdisable_arcin_v5
,
112 /* ---------------- Version 6 PCB Support Functions --------------------- */
113 /* Prototype: icside_irqenable_arcin_v6 (struct expansion_card *ec, int irqnr)
114 * Purpose : enable interrupts from card
116 static void icside_irqenable_arcin_v6 (struct expansion_card
*ec
, int irqnr
)
118 struct icside_state
*state
= ec
->irq_data
;
119 void __iomem
*base
= state
->irq_port
;
123 switch (state
->channel
) {
125 writeb(0, base
+ ICS_ARCIN_V6_INTROFFSET_1
);
126 readb(base
+ ICS_ARCIN_V6_INTROFFSET_2
);
129 writeb(0, base
+ ICS_ARCIN_V6_INTROFFSET_2
);
130 readb(base
+ ICS_ARCIN_V6_INTROFFSET_1
);
135 /* Prototype: icside_irqdisable_arcin_v6 (struct expansion_card *ec, int irqnr)
136 * Purpose : disable interrupts from card
138 static void icside_irqdisable_arcin_v6 (struct expansion_card
*ec
, int irqnr
)
140 struct icside_state
*state
= ec
->irq_data
;
144 readb(state
->irq_port
+ ICS_ARCIN_V6_INTROFFSET_1
);
145 readb(state
->irq_port
+ ICS_ARCIN_V6_INTROFFSET_2
);
148 /* Prototype: icside_irqprobe(struct expansion_card *ec)
149 * Purpose : detect an active interrupt from card
151 static int icside_irqpending_arcin_v6(struct expansion_card
*ec
)
153 struct icside_state
*state
= ec
->irq_data
;
155 return readb(state
->irq_port
+ ICS_ARCIN_V6_INTRSTAT_1
) & 1 ||
156 readb(state
->irq_port
+ ICS_ARCIN_V6_INTRSTAT_2
) & 1;
159 static const expansioncard_ops_t icside_ops_arcin_v6
= {
160 .irqenable
= icside_irqenable_arcin_v6
,
161 .irqdisable
= icside_irqdisable_arcin_v6
,
162 .irqpending
= icside_irqpending_arcin_v6
,
166 * Handle routing of interrupts. This is called before
167 * we write the command to the drive.
169 static void icside_maskproc(ide_drive_t
*drive
, int mask
)
171 ide_hwif_t
*hwif
= HWIF(drive
);
172 struct icside_state
*state
= hwif
->hwif_data
;
175 local_irq_save(flags
);
177 state
->channel
= hwif
->channel
;
179 if (state
->enabled
&& !mask
) {
180 switch (hwif
->channel
) {
182 writeb(0, state
->irq_port
+ ICS_ARCIN_V6_INTROFFSET_1
);
183 readb(state
->irq_port
+ ICS_ARCIN_V6_INTROFFSET_2
);
186 writeb(0, state
->irq_port
+ ICS_ARCIN_V6_INTROFFSET_2
);
187 readb(state
->irq_port
+ ICS_ARCIN_V6_INTROFFSET_1
);
191 readb(state
->irq_port
+ ICS_ARCIN_V6_INTROFFSET_2
);
192 readb(state
->irq_port
+ ICS_ARCIN_V6_INTROFFSET_1
);
195 local_irq_restore(flags
);
198 #ifdef CONFIG_BLK_DEV_IDEDMA_ICS
202 * Similar to the BM-DMA, but we use the RiscPCs IOMD DMA controllers.
203 * There is only one DMA controller per card, which means that only
204 * one drive can be accessed at one time. NOTE! We do not enforce that
205 * here, but we rely on the main IDE driver spotting that both
206 * interfaces use the same IRQ, which should guarantee this.
209 static void icside_build_sglist(ide_drive_t
*drive
, struct request
*rq
)
211 ide_hwif_t
*hwif
= drive
->hwif
;
212 struct icside_state
*state
= hwif
->hwif_data
;
213 struct scatterlist
*sg
= hwif
->sg_table
;
215 ide_map_sg(drive
, rq
);
217 if (rq_data_dir(rq
) == READ
)
218 hwif
->sg_dma_direction
= DMA_FROM_DEVICE
;
220 hwif
->sg_dma_direction
= DMA_TO_DEVICE
;
222 hwif
->sg_nents
= dma_map_sg(state
->dev
, sg
, hwif
->sg_nents
,
223 hwif
->sg_dma_direction
);
227 * Configure the IOMD to give the appropriate timings for the transfer
228 * mode being requested. We take the advice of the ATA standards, and
229 * calculate the cycle time based on the transfer mode, and the EIDE
230 * MW DMA specs that the drive provides in the IDENTIFY command.
232 * We have the following IOMD DMA modes to choose from:
234 * Type Active Recovery Cycle
235 * A 250 (250) 312 (550) 562 (800)
237 * C 125 (125) 125 (375) 250 (500)
240 * (figures in brackets are actual measured timings)
242 * However, we also need to take care of the read/write active and
246 * Mode Active -- Recovery -- Cycle IOMD type
247 * MW0 215 50 215 480 A
251 static void icside_set_dma_mode(ide_drive_t
*drive
, const u8 xfer_mode
)
253 int cycle_time
, use_dma_info
= 0;
280 * If we're going to be doing MW_DMA_1 or MW_DMA_2, we should
281 * take care to note the values in the ID...
283 if (use_dma_info
&& drive
->id
->eide_dma_time
> cycle_time
)
284 cycle_time
= drive
->id
->eide_dma_time
;
286 drive
->drive_data
= cycle_time
;
288 printk("%s: %s selected (peak %dMB/s)\n", drive
->name
,
289 ide_xfer_verbose(xfer_mode
), 2000 / drive
->drive_data
);
292 static void icside_dma_host_off(ide_drive_t
*drive
)
296 static void icside_dma_off_quietly(ide_drive_t
*drive
)
298 drive
->using_dma
= 0;
301 static void icside_dma_host_on(ide_drive_t
*drive
)
305 static int icside_dma_on(ide_drive_t
*drive
)
307 drive
->using_dma
= 1;
312 static int icside_dma_check(ide_drive_t
*drive
)
314 if (ide_tune_dma(drive
))
320 static int icside_dma_end(ide_drive_t
*drive
)
322 ide_hwif_t
*hwif
= HWIF(drive
);
323 struct icside_state
*state
= hwif
->hwif_data
;
325 drive
->waiting_for_dma
= 0;
327 disable_dma(hwif
->hw
.dma
);
329 /* Teardown mappings after DMA has completed. */
330 dma_unmap_sg(state
->dev
, hwif
->sg_table
, hwif
->sg_nents
,
331 hwif
->sg_dma_direction
);
333 return get_dma_residue(hwif
->hw
.dma
) != 0;
336 static void icside_dma_start(ide_drive_t
*drive
)
338 ide_hwif_t
*hwif
= HWIF(drive
);
340 /* We can not enable DMA on both channels simultaneously. */
341 BUG_ON(dma_channel_active(hwif
->hw
.dma
));
342 enable_dma(hwif
->hw
.dma
);
345 static int icside_dma_setup(ide_drive_t
*drive
)
347 ide_hwif_t
*hwif
= HWIF(drive
);
348 struct request
*rq
= hwif
->hwgroup
->rq
;
349 unsigned int dma_mode
;
352 dma_mode
= DMA_MODE_WRITE
;
354 dma_mode
= DMA_MODE_READ
;
357 * We can not enable DMA on both channels.
359 BUG_ON(dma_channel_active(hwif
->hw
.dma
));
361 icside_build_sglist(drive
, rq
);
364 * Ensure that we have the right interrupt routed.
366 icside_maskproc(drive
, 0);
369 * Route the DMA signals to the correct interface.
371 writeb(hwif
->select_data
, hwif
->config_data
);
374 * Select the correct timing for this drive.
376 set_dma_speed(hwif
->hw
.dma
, drive
->drive_data
);
379 * Tell the DMA engine about the SG table and
382 set_dma_sg(hwif
->hw
.dma
, hwif
->sg_table
, hwif
->sg_nents
);
383 set_dma_mode(hwif
->hw
.dma
, dma_mode
);
385 drive
->waiting_for_dma
= 1;
390 static void icside_dma_exec_cmd(ide_drive_t
*drive
, u8 cmd
)
392 /* issue cmd to drive */
393 ide_execute_command(drive
, cmd
, ide_dma_intr
, 2 * WAIT_CMD
, NULL
);
396 static int icside_dma_test_irq(ide_drive_t
*drive
)
398 ide_hwif_t
*hwif
= HWIF(drive
);
399 struct icside_state
*state
= hwif
->hwif_data
;
401 return readb(state
->irq_port
+
403 ICS_ARCIN_V6_INTRSTAT_2
:
404 ICS_ARCIN_V6_INTRSTAT_1
)) & 1;
407 static void icside_dma_timeout(ide_drive_t
*drive
)
409 printk(KERN_ERR
"%s: DMA timeout occurred: ", drive
->name
);
411 if (icside_dma_test_irq(drive
))
414 ide_dump_status(drive
, "DMA timeout", HWIF(drive
)->INB(IDE_STATUS_REG
));
416 icside_dma_end(drive
);
419 static void icside_dma_lost_irq(ide_drive_t
*drive
)
421 printk(KERN_ERR
"%s: IRQ lost\n", drive
->name
);
424 static void icside_dma_init(ide_hwif_t
*hwif
)
426 printk(" %s: SG-DMA", hwif
->name
);
429 hwif
->mwdma_mask
= 7; /* MW0..2 */
430 hwif
->swdma_mask
= 7; /* SW0..2 */
432 hwif
->dmatable_cpu
= NULL
;
433 hwif
->dmatable_dma
= 0;
434 hwif
->set_dma_mode
= icside_set_dma_mode
;
437 hwif
->ide_dma_check
= icside_dma_check
;
438 hwif
->dma_host_off
= icside_dma_host_off
;
439 hwif
->dma_off_quietly
= icside_dma_off_quietly
;
440 hwif
->dma_host_on
= icside_dma_host_on
;
441 hwif
->ide_dma_on
= icside_dma_on
;
442 hwif
->dma_setup
= icside_dma_setup
;
443 hwif
->dma_exec_cmd
= icside_dma_exec_cmd
;
444 hwif
->dma_start
= icside_dma_start
;
445 hwif
->ide_dma_end
= icside_dma_end
;
446 hwif
->ide_dma_test_irq
= icside_dma_test_irq
;
447 hwif
->dma_timeout
= icside_dma_timeout
;
448 hwif
->dma_lost_irq
= icside_dma_lost_irq
;
450 hwif
->drives
[0].autodma
= hwif
->autodma
;
451 hwif
->drives
[1].autodma
= hwif
->autodma
;
453 printk(" capable%s\n", hwif
->autodma
? ", auto-enable" : "");
456 #define icside_dma_init(hwif) (0)
459 static ide_hwif_t
*icside_find_hwif(unsigned long dataport
)
464 for (index
= 0; index
< MAX_HWIFS
; ++index
) {
465 hwif
= &ide_hwifs
[index
];
466 if (hwif
->io_ports
[IDE_DATA_OFFSET
] == dataport
)
470 for (index
= 0; index
< MAX_HWIFS
; ++index
) {
471 hwif
= &ide_hwifs
[index
];
472 if (!hwif
->io_ports
[IDE_DATA_OFFSET
])
482 icside_setup(void __iomem
*base
, struct cardinfo
*info
, struct expansion_card
*ec
)
484 unsigned long port
= (unsigned long)base
+ info
->dataoffset
;
487 hwif
= icside_find_hwif(port
);
491 memset(&hwif
->hw
, 0, sizeof(hw_regs_t
));
494 * Ensure we're using MMIO
496 default_hwif_mmiops(hwif
);
499 for (i
= IDE_DATA_OFFSET
; i
<= IDE_STATUS_OFFSET
; i
++) {
500 hwif
->hw
.io_ports
[i
] = port
;
501 hwif
->io_ports
[i
] = port
;
502 port
+= 1 << info
->stepping
;
504 hwif
->hw
.io_ports
[IDE_CONTROL_OFFSET
] = (unsigned long)base
+ info
->ctrloffset
;
505 hwif
->io_ports
[IDE_CONTROL_OFFSET
] = (unsigned long)base
+ info
->ctrloffset
;
506 hwif
->hw
.irq
= ec
->irq
;
509 hwif
->chipset
= ide_acorn
;
510 hwif
->gendev
.parent
= &ec
->dev
;
517 icside_register_v5(struct icside_state
*state
, struct expansion_card
*ec
)
522 base
= ecardm_iomap(ec
, ECARD_RES_MEMC
, 0, 0);
526 state
->irq_port
= base
;
528 ec
->irqaddr
= base
+ ICS_ARCIN_V5_INTRSTAT
;
531 ecard_setirq(ec
, &icside_ops_arcin_v5
, state
);
534 * Be on the safe side - disable interrupts
536 icside_irqdisable_arcin_v5(ec
, 0);
538 hwif
= icside_setup(base
, &icside_cardinfo_v5
, ec
);
542 state
->hwif
[0] = hwif
;
544 probe_hwif_init(hwif
);
546 ide_proc_register_port(hwif
);
552 icside_register_v6(struct icside_state
*state
, struct expansion_card
*ec
)
554 ide_hwif_t
*hwif
, *mate
;
555 void __iomem
*ioc_base
, *easi_base
;
556 unsigned int sel
= 0;
559 ioc_base
= ecardm_iomap(ec
, ECARD_RES_IOCFAST
, 0, 0);
565 easi_base
= ioc_base
;
567 if (ecard_resource_flags(ec
, ECARD_RES_EASI
)) {
568 easi_base
= ecardm_iomap(ec
, ECARD_RES_EASI
, 0, 0);
575 * Enable access to the EASI region.
580 writeb(sel
, ioc_base
);
582 ecard_setirq(ec
, &icside_ops_arcin_v6
, state
);
584 state
->irq_port
= easi_base
;
585 state
->ioc_base
= ioc_base
;
588 * Be on the safe side - disable interrupts
590 icside_irqdisable_arcin_v6(ec
, 0);
593 * Find and register the interfaces.
595 hwif
= icside_setup(easi_base
, &icside_cardinfo_v6_1
, ec
);
596 mate
= icside_setup(easi_base
, &icside_cardinfo_v6_2
, ec
);
598 if (!hwif
|| !mate
) {
603 state
->hwif
[0] = hwif
;
604 state
->hwif
[1] = mate
;
606 hwif
->maskproc
= icside_maskproc
;
608 hwif
->hwif_data
= state
;
610 hwif
->serialized
= 1;
611 hwif
->config_data
= (unsigned long)ioc_base
;
612 hwif
->select_data
= sel
;
613 hwif
->hw
.dma
= ec
->dma
;
615 mate
->maskproc
= icside_maskproc
;
617 mate
->hwif_data
= state
;
619 mate
->serialized
= 1;
620 mate
->config_data
= (unsigned long)ioc_base
;
621 mate
->select_data
= sel
| 1;
622 mate
->hw
.dma
= ec
->dma
;
624 if (ec
->dma
!= NO_DMA
&& !request_dma(ec
->dma
, hwif
->name
)) {
625 icside_dma_init(hwif
);
626 icside_dma_init(mate
);
629 probe_hwif_init(hwif
);
630 probe_hwif_init(mate
);
632 ide_proc_register_port(hwif
);
633 ide_proc_register_port(mate
);
642 icside_probe(struct expansion_card
*ec
, const struct ecard_id
*id
)
644 struct icside_state
*state
;
648 ret
= ecard_request_resources(ec
);
652 state
= kzalloc(sizeof(struct icside_state
), GFP_KERNEL
);
658 state
->type
= ICS_TYPE_NOTYPE
;
659 state
->dev
= &ec
->dev
;
661 idmem
= ecardm_iomap(ec
, ECARD_RES_IOCFAST
, 0, 0);
665 type
= readb(idmem
+ ICS_IDENT_OFFSET
) & 1;
666 type
|= (readb(idmem
+ ICS_IDENT_OFFSET
+ 4) & 1) << 1;
667 type
|= (readb(idmem
+ ICS_IDENT_OFFSET
+ 8) & 1) << 2;
668 type
|= (readb(idmem
+ ICS_IDENT_OFFSET
+ 12) & 1) << 3;
669 ecardm_iounmap(ec
, idmem
);
674 switch (state
->type
) {
676 dev_warn(&ec
->dev
, "A3IN unsupported\n");
680 case ICS_TYPE_A3USER
:
681 dev_warn(&ec
->dev
, "A3USER unsupported\n");
686 ret
= icside_register_v5(state
, ec
);
690 ret
= icside_register_v6(state
, ec
);
694 dev_warn(&ec
->dev
, "unknown interface type\n");
700 ecard_set_drvdata(ec
, state
);
706 ecard_release_resources(ec
);
711 static void __devexit
icside_remove(struct expansion_card
*ec
)
713 struct icside_state
*state
= ecard_get_drvdata(ec
);
715 switch (state
->type
) {
717 /* FIXME: tell IDE to stop using the interface */
719 /* Disable interrupts */
720 icside_irqdisable_arcin_v5(ec
, 0);
724 /* FIXME: tell IDE to stop using the interface */
725 if (ec
->dma
!= NO_DMA
)
728 /* Disable interrupts */
729 icside_irqdisable_arcin_v6(ec
, 0);
731 /* Reset the ROM pointer/EASI selection */
732 writeb(0, state
->ioc_base
);
736 ecard_set_drvdata(ec
, NULL
);
739 ecard_release_resources(ec
);
742 static void icside_shutdown(struct expansion_card
*ec
)
744 struct icside_state
*state
= ecard_get_drvdata(ec
);
748 * Disable interrupts from this card. We need to do
749 * this before disabling EASI since we may be accessing
750 * this register via that region.
752 local_irq_save(flags
);
753 ec
->ops
->irqdisable(ec
, 0);
754 local_irq_restore(flags
);
757 * Reset the ROM pointer so that we can read the ROM
758 * after a soft reboot. This also disables access to
759 * the IDE taskfile via the EASI region.
762 writeb(0, state
->ioc_base
);
765 static const struct ecard_id icside_ids
[] = {
766 { MANU_ICS
, PROD_ICS_IDE
},
767 { MANU_ICS2
, PROD_ICS2_IDE
},
771 static struct ecard_driver icside_driver
= {
772 .probe
= icside_probe
,
773 .remove
= __devexit_p(icside_remove
),
774 .shutdown
= icside_shutdown
,
775 .id_table
= icside_ids
,
781 static int __init
icside_init(void)
783 return ecard_register_driver(&icside_driver
);
786 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
787 MODULE_LICENSE("GPL");
788 MODULE_DESCRIPTION("ICS IDE driver");
790 module_init(icside_init
);