[PATCH] 2.5.7 IDE 27
[opensuse:kernel.git] / drivers / ide / icside.c
1 /*
2  * linux/drivers/ide/icside.c
3  *
4  * Copyright (c) 1996,1997 Russell King.
5  *
6  * Changelog:
7  *  08-Jun-1996 RMK     Created
8  *  12-Sep-1997 RMK     Added interrupt enable/disable
9  *  17-Apr-1999 RMK     Added support for V6 EASI
10  *  22-May-1999 RMK     Added support for V6 DMA
11  */
12
13 #include <linux/config.h>
14 #include <linux/string.h>
15 #include <linux/module.h>
16 #include <linux/ioport.h>
17 #include <linux/slab.h>
18 #include <linux/blkdev.h>
19 #include <linux/errno.h>
20 #include <linux/hdreg.h>
21 #include <linux/ide.h>
22 #include <linux/pci.h>
23 #include <linux/init.h>
24
25 #include <asm/dma.h>
26 #include <asm/ecard.h>
27 #include <asm/io.h>
28
29 extern char *ide_xfer_verbose (byte xfer_rate);
30 extern char *ide_dmafunc_verbose(ide_dma_action_t dmafunc);
31
32 /*
33  * Maximum number of interfaces per card
34  */
35 #define MAX_IFS 2
36
37 #define ICS_IDENT_OFFSET                0x8a0
38
39 #define ICS_ARCIN_V5_INTRSTAT           0x000
40 #define ICS_ARCIN_V5_INTROFFSET         0x001
41 #define ICS_ARCIN_V5_IDEOFFSET          0xa00
42 #define ICS_ARCIN_V5_IDEALTOFFSET       0xae0
43 #define ICS_ARCIN_V5_IDESTEPPING        4
44
45 #define ICS_ARCIN_V6_IDEOFFSET_1        0x800
46 #define ICS_ARCIN_V6_INTROFFSET_1       0x880
47 #define ICS_ARCIN_V6_INTRSTAT_1         0x8a4
48 #define ICS_ARCIN_V6_IDEALTOFFSET_1     0x8e0
49 #define ICS_ARCIN_V6_IDEOFFSET_2        0xc00
50 #define ICS_ARCIN_V6_INTROFFSET_2       0xc80
51 #define ICS_ARCIN_V6_INTRSTAT_2         0xca4
52 #define ICS_ARCIN_V6_IDEALTOFFSET_2     0xce0
53 #define ICS_ARCIN_V6_IDESTEPPING        4
54
55 struct cardinfo {
56         unsigned int dataoffset;
57         unsigned int ctrloffset;
58         unsigned int stepping;
59 };
60
61 static struct cardinfo icside_cardinfo_v5 = {
62         ICS_ARCIN_V5_IDEOFFSET,
63         ICS_ARCIN_V5_IDEALTOFFSET,
64         ICS_ARCIN_V5_IDESTEPPING
65 };
66
67 static struct cardinfo icside_cardinfo_v6_1 = {
68         ICS_ARCIN_V6_IDEOFFSET_1,
69         ICS_ARCIN_V6_IDEALTOFFSET_1,
70         ICS_ARCIN_V6_IDESTEPPING
71 };
72
73 static struct cardinfo icside_cardinfo_v6_2 = {
74         ICS_ARCIN_V6_IDEOFFSET_2,
75         ICS_ARCIN_V6_IDEALTOFFSET_2,
76         ICS_ARCIN_V6_IDESTEPPING
77 };
78
79 static const card_ids icside_cids[] = {
80         { MANU_ICS,  PROD_ICS_IDE  },
81         { MANU_ICS2, PROD_ICS2_IDE },
82         { 0xffff, 0xffff }
83 };
84
85 typedef enum {
86         ics_if_unknown,
87         ics_if_arcin_v5,
88         ics_if_arcin_v6
89 } iftype_t;
90
91 /* ---------------- Version 5 PCB Support Functions --------------------- */
92 /* Prototype: icside_irqenable_arcin_v5 (struct expansion_card *ec, int irqnr)
93  * Purpose  : enable interrupts from card
94  */
95 static void icside_irqenable_arcin_v5 (struct expansion_card *ec, int irqnr)
96 {
97         unsigned int memc_port = (unsigned int)ec->irq_data;
98         outb (0, memc_port + ICS_ARCIN_V5_INTROFFSET);
99 }
100
101 /* Prototype: icside_irqdisable_arcin_v5 (struct expansion_card *ec, int irqnr)
102  * Purpose  : disable interrupts from card
103  */
104 static void icside_irqdisable_arcin_v5 (struct expansion_card *ec, int irqnr)
105 {
106         unsigned int memc_port = (unsigned int)ec->irq_data;
107         inb (memc_port + ICS_ARCIN_V5_INTROFFSET);
108 }
109
110 static const expansioncard_ops_t icside_ops_arcin_v5 = {
111         icside_irqenable_arcin_v5,
112         icside_irqdisable_arcin_v5,
113         NULL,
114         NULL,
115         NULL,
116         NULL
117 };
118
119
120 /* ---------------- Version 6 PCB Support Functions --------------------- */
121 /* Prototype: icside_irqenable_arcin_v6 (struct expansion_card *ec, int irqnr)
122  * Purpose  : enable interrupts from card
123  */
124 static void icside_irqenable_arcin_v6 (struct expansion_card *ec, int irqnr)
125 {
126         unsigned int ide_base_port = (unsigned int)ec->irq_data;
127
128         outb (0, ide_base_port + ICS_ARCIN_V6_INTROFFSET_1);
129         outb (0, ide_base_port + ICS_ARCIN_V6_INTROFFSET_2);
130 }
131
132 /* Prototype: icside_irqdisable_arcin_v6 (struct expansion_card *ec, int irqnr)
133  * Purpose  : disable interrupts from card
134  */
135 static void icside_irqdisable_arcin_v6 (struct expansion_card *ec, int irqnr)
136 {
137         unsigned int ide_base_port = (unsigned int)ec->irq_data;
138
139         inb (ide_base_port + ICS_ARCIN_V6_INTROFFSET_1);
140         inb (ide_base_port + ICS_ARCIN_V6_INTROFFSET_2);
141 }
142
143 /* Prototype: icside_irqprobe(struct expansion_card *ec)
144  * Purpose  : detect an active interrupt from card
145  */
146 static int icside_irqpending_arcin_v6(struct expansion_card *ec)
147 {
148         unsigned int ide_base_port = (unsigned int)ec->irq_data;
149
150         return inb(ide_base_port + ICS_ARCIN_V6_INTRSTAT_1) & 1 ||
151                inb(ide_base_port + ICS_ARCIN_V6_INTRSTAT_2) & 1;
152 }
153
154 static const expansioncard_ops_t icside_ops_arcin_v6 = {
155         icside_irqenable_arcin_v6,
156         icside_irqdisable_arcin_v6,
157         icside_irqpending_arcin_v6,
158         NULL,
159         NULL,
160         NULL
161 };
162
163 /* Prototype: icside_identifyif (struct expansion_card *ec)
164  * Purpose  : identify IDE interface type
165  * Notes    : checks the description string
166  */
167 static iftype_t __init icside_identifyif (struct expansion_card *ec)
168 {
169         unsigned int addr;
170         iftype_t iftype;
171         int id = 0;
172
173         iftype = ics_if_unknown;
174
175         addr = ecard_address (ec, ECARD_IOC, ECARD_FAST) + ICS_IDENT_OFFSET;
176
177         id = inb (addr) & 1;
178         id |= (inb (addr + 1) & 1) << 1;
179         id |= (inb (addr + 2) & 1) << 2;
180         id |= (inb (addr + 3) & 1) << 3;
181
182         switch (id) {
183         case 0: /* A3IN */
184                 printk("icside: A3IN unsupported\n");
185                 break;
186
187         case 1: /* A3USER */
188                 printk("icside: A3USER unsupported\n");
189                 break;
190
191         case 3: /* ARCIN V6 */
192                 printk(KERN_DEBUG "icside: detected ARCIN V6 in slot %d\n", ec->slot_no);
193                 iftype = ics_if_arcin_v6;
194                 break;
195
196         case 15:/* ARCIN V5 (no id) */
197                 printk(KERN_DEBUG "icside: detected ARCIN V5 in slot %d\n", ec->slot_no);
198                 iftype = ics_if_arcin_v5;
199                 break;
200
201         default:/* we don't know - complain very loudly */
202                 printk("icside: ***********************************\n");
203                 printk("icside: *** UNKNOWN ICS INTERFACE id=%d ***\n", id);
204                 printk("icside: ***********************************\n");
205                 printk("icside: please report this to linux@arm.linux.org.uk\n");
206                 printk("icside: defaulting to ARCIN V5\n");
207                 iftype = ics_if_arcin_v5;
208                 break;
209         }
210
211         return iftype;
212 }
213
214 #ifdef CONFIG_BLK_DEV_IDEDMA_ICS
215 /*
216  * SG-DMA support.
217  *
218  * Similar to the BM-DMA, but we use the RiscPCs IOMD DMA controllers.
219  * There is only one DMA controller per card, which means that only
220  * one drive can be accessed at one time.  NOTE! We do not enforce that
221  * here, but we rely on the main IDE driver spotting that both
222  * interfaces use the same IRQ, which should guarantee this.
223  */
224 #define NR_ENTRIES 256
225 #define TABLE_SIZE (NR_ENTRIES * 8)
226
227 static int ide_build_sglist(struct ata_channel *hwif, struct request *rq)
228 {
229         request_queue_t *q = &hwif->drives[DEVICE_NR(rq->rq_dev) & 1].queue;
230         struct scatterlist *sg = hwif->sg_table;
231         int nents = blk_rq_map_sg(q, rq, sg);
232
233         if (rq->q && nents > rq->nr_phys_segments)
234                 printk("icside: received %d segments, build %d\n",
235                         rq->nr_phys_segments, nents);
236
237         if (rq_data_dir(rq) == READ)
238                 hwif->sg_dma_direction = PCI_DMA_FROMDEVICE;
239         else
240                 hwif->sg_dma_direction = PCI_DMA_TODEVICE;
241
242         return pci_map_sg(NULL, sg, nents, hwif->sg_dma_direction);
243 }
244
245 static int
246 icside_build_dmatable(ide_drive_t *drive, int reading)
247 {
248         return drive->channel->sg_nents = ide_build_sglist(drive->channel, HWGROUP(drive)->rq);
249 }
250
251 /* Teardown mappings after DMA has completed.  */
252 static void icside_destroy_dmatable(ide_drive_t *drive)
253 {
254         struct scatterlist *sg = drive->channel->sg_table;
255         int nents = drive->channel->sg_nents;
256
257         pci_unmap_sg(NULL, sg, nents, drive->channel->sg_dma_direction);
258 }
259
260 /*
261  * Configure the IOMD to give the appropriate timings for the transfer
262  * mode being requested.  We take the advice of the ATA standards, and
263  * calculate the cycle time based on the transfer mode, and the EIDE
264  * MW DMA specs that the drive provides in the IDENTIFY command.
265  *
266  * We have the following IOMD DMA modes to choose from:
267  *
268  *      Type    Active          Recovery        Cycle
269  *      A       250 (250)       312 (550)       562 (800)
270  *      B       187             250             437
271  *      C       125 (125)       125 (375)       250 (500)
272  *      D       62              125             187
273  *
274  * (figures in brackets are actual measured timings)
275  *
276  * However, we also need to take care of the read/write active and
277  * recovery timings:
278  *
279  *                      Read    Write
280  *      Mode    Active  -- Recovery --  Cycle   IOMD type
281  *      MW0     215     50      215     480     A
282  *      MW1     80      50      50      150     C
283  *      MW2     70      25      25      120     C
284  */
285 static int
286 icside_config_if(ide_drive_t *drive, int xfer_mode)
287 {
288         int func = ide_dma_off;
289         int cycle_time = 0, use_dma_info = 0;
290
291         switch (xfer_mode) {
292         case XFER_MW_DMA_2: cycle_time = 250; use_dma_info = 1; break;
293         case XFER_MW_DMA_1: cycle_time = 250; use_dma_info = 1; break;
294         case XFER_MW_DMA_0: cycle_time = 480;                   break;
295         }
296
297         /*
298          * If we're going to be doing MW_DMA_1 or MW_DMA_2, we should
299          * take care to note the values in the ID...
300          */
301         if (use_dma_info && drive->id->eide_dma_time > cycle_time)
302                 cycle_time = drive->id->eide_dma_time;
303
304         drive->drive_data = cycle_time;
305
306         if (!drive->init_speed)
307                 drive->init_speed = xfer_mode;
308
309         if (cycle_time && ide_config_drive_speed(drive, xfer_mode) == 0)
310                 func = ide_dma_on;
311         else
312                 drive->drive_data = 480;
313
314         printk("%s: %s selected (peak %dMB/s)\n", drive->name,
315                 ide_xfer_verbose(xfer_mode), 2000 / drive->drive_data);
316
317         drive->current_speed = xfer_mode;
318
319         return func;
320 }
321
322 static int
323 icside_set_speed(ide_drive_t *drive, byte speed)
324 {
325         return icside_config_if(drive, speed);
326 }
327
328 /*
329  * dma_intr() is the handler for disk read/write DMA interrupts
330  */
331 static ide_startstop_t icside_dmaintr(ide_drive_t *drive)
332 {
333         int i;
334         byte stat, dma_stat;
335
336         dma_stat = drive->channel->dmaproc(ide_dma_end, drive);
337         stat = GET_STAT();                      /* get drive status */
338         if (OK_STAT(stat,DRIVE_READY,drive->bad_wstat|DRQ_STAT)) {
339                 if (!dma_stat) {
340                         struct request *rq = HWGROUP(drive)->rq;
341                         rq = HWGROUP(drive)->rq;
342                         for (i = rq->nr_sectors; i > 0;) {
343                                 i -= rq->current_nr_sectors;
344                                 ide_end_request(drive, 1);
345                         }
346                         return ide_stopped;
347                 }
348                 printk("%s: dma_intr: bad DMA status (dma_stat=%x)\n", 
349                        drive->name, dma_stat);
350         }
351         return ide_error(drive, "dma_intr", stat);
352 }
353
354
355 static int
356 icside_dma_check(ide_drive_t *drive)
357 {
358         struct hd_driveid *id = drive->id;
359         struct ata_channel *hwif = drive->channel;
360         int autodma = hwif->autodma;
361         int xfer_mode = XFER_PIO_2;
362         int func = ide_dma_off_quietly;
363
364         if (!id || !(id->capability & 1) || !autodma)
365                 goto out;
366
367         /*
368          * Enable DMA on any drive that has multiword DMA
369          */
370         if (id->field_valid & 2) {
371                 if (id->dma_mword & 4) {
372                         xfer_mode = XFER_MW_DMA_2;
373                         func = ide_dma_on;
374                 } else if (id->dma_mword & 2) {
375                         xfer_mode = XFER_MW_DMA_1;
376                         func = ide_dma_on;
377                 } else if (id->dma_mword & 1) {
378                         xfer_mode = XFER_MW_DMA_0;
379                         func = ide_dma_on;
380                 }
381                 goto out;
382         }
383
384 out:
385         func = icside_config_if(drive, xfer_mode);
386
387         return hwif->dmaproc(func, drive);
388 }
389
390 static int
391 icside_dma_verbose(ide_drive_t *drive)
392 {
393         printk(", DMA");
394         return 1;
395 }
396
397 static int
398 icside_dmaproc(ide_dma_action_t func, ide_drive_t *drive)
399 {
400         struct ata_channel *hwif = drive->channel;
401         int count, reading = 0;
402
403         switch (func) {
404         case ide_dma_off:
405                 printk("%s: DMA disabled\n", drive->name);
406                 /*FALLTHROUGH*/
407
408         case ide_dma_off_quietly:
409         case ide_dma_on:
410                 /*
411                  * We don't need any bouncing.  Yes, this looks the
412                  * wrong way around, but it is correct.
413                  */
414                 blk_queue_bounce_limit(&drive->queue, BLK_BOUNCE_ANY);
415                 drive->using_dma = (func == ide_dma_on);
416                 return 0;
417
418         case ide_dma_check:
419                 return icside_dma_check(drive);
420
421         case ide_dma_read:
422                 reading = 1;
423         case ide_dma_write:
424                 count = icside_build_dmatable(drive, reading);
425                 if (!count)
426                         return 1;
427                 disable_dma(hwif->hw.dma);
428
429                 /* Route the DMA signals to
430                  * to the correct interface.
431                  */
432                 outb(hwif->select_data, hwif->config_data);
433
434                 /* Select the correct timing
435                  * for this drive
436                  */
437                 set_dma_speed(hwif->hw.dma, drive->drive_data);
438
439                 set_dma_sg(hwif->hw.dma, drive->channel->sg_table, count);
440                 set_dma_mode(hwif->hw.dma, reading ? DMA_MODE_READ
441                              : DMA_MODE_WRITE);
442
443                 drive->waiting_for_dma = 1;
444                 if (drive->media != ide_disk)
445                         return 0;
446
447                 ide_set_handler(drive, &icside_dmaintr, WAIT_CMD, NULL);
448                 OUT_BYTE(reading ? WIN_READDMA : WIN_WRITEDMA,
449                          IDE_COMMAND_REG);
450
451         case ide_dma_begin:
452                 enable_dma(hwif->hw.dma);
453                 return 0;
454
455         case ide_dma_end:
456                 drive->waiting_for_dma = 0;
457                 disable_dma(hwif->hw.dma);
458                 icside_destroy_dmatable(drive);
459                 return get_dma_residue(hwif->hw.dma) != 0;
460
461         case ide_dma_test_irq:
462                 return inb((unsigned long)hwif->hw.priv) & 1;
463
464         case ide_dma_verbose:
465                 return icside_dma_verbose(drive);
466
467         case ide_dma_timeout:
468         default:
469                 printk("icside_dmaproc: unsupported %s func: %d\n",
470                         ide_dmafunc_verbose(func), func);
471         }
472         return 1;
473 }
474
475 static int
476 icside_setup_dma(struct ata_channel *hwif, int autodma)
477 {
478         printk("    %s: SG-DMA", hwif->name);
479
480         hwif->sg_table = kmalloc(sizeof(struct scatterlist) * NR_ENTRIES,
481                                  GFP_KERNEL);
482         if (!hwif->sg_table)
483                 goto failed;
484
485         hwif->dmatable_cpu = NULL;
486         hwif->dmatable_dma = 0;
487         hwif->speedproc = icside_set_speed;
488         hwif->dmaproc = icside_dmaproc;
489         hwif->autodma = autodma;
490
491         printk(" capable%s\n", autodma ?
492                 ", auto-enable" : "");
493
494         return 1;
495
496 failed:
497         printk(" -- ERROR, unable to allocate DMA table\n");
498         return 0;
499 }
500
501 void ide_release_dma(struct ata_channel *hwif)
502 {
503         if (hwif->sg_table) {
504                 kfree(hwif->sg_table);
505                 hwif->sg_table = NULL;
506         }
507 }
508 #endif
509
510 static struct ata_channel *
511 icside_find_hwif(unsigned long dataport)
512 {
513         struct ata_channel *hwif;
514         int index;
515
516         for (index = 0; index < MAX_HWIFS; ++index) {
517                 hwif = &ide_hwifs[index];
518                 if (hwif->io_ports[IDE_DATA_OFFSET] == (ide_ioreg_t)dataport)
519                         goto found;
520         }
521
522         for (index = 0; index < MAX_HWIFS; ++index) {
523                 hwif = &ide_hwifs[index];
524                 if (!hwif->io_ports[IDE_DATA_OFFSET])
525                         goto found;
526         }
527
528         return NULL;
529 found:
530         return hwif;
531 }
532
533 static struct ata_channel *
534 icside_setup(unsigned long base, struct cardinfo *info, int irq)
535 {
536         unsigned long port = base + info->dataoffset;
537         struct ata_channel *hwif;
538
539         hwif = icside_find_hwif(base);
540         if (hwif) {
541                 int i;
542
543                 memset(&hwif->hw, 0, sizeof(hw_regs_t));
544
545                 for (i = IDE_DATA_OFFSET; i <= IDE_STATUS_OFFSET; i++) {
546                         hwif->hw.io_ports[i] = (ide_ioreg_t)port;
547                         hwif->io_ports[i] = (ide_ioreg_t)port;
548                         port += 1 << info->stepping;
549                 }
550                 hwif->hw.io_ports[IDE_CONTROL_OFFSET] = base + info->ctrloffset;
551                 hwif->io_ports[IDE_CONTROL_OFFSET] = base + info->ctrloffset;
552                 hwif->hw.irq  = irq;
553                 hwif->irq     = irq;
554                 hwif->hw.dma  = NO_DMA;
555                 hwif->noprobe = 0;
556                 hwif->chipset = ide_acorn;
557         }
558
559         return hwif;
560 }
561
562 static int __init icside_register_v5(struct expansion_card *ec, int autodma)
563 {
564         unsigned long slot_port;
565         struct ata_channel *hwif;
566
567         slot_port = ecard_address(ec, ECARD_MEMC, 0);
568
569         ec->irqaddr  = (unsigned char *)ioaddr(slot_port + ICS_ARCIN_V5_INTRSTAT);
570         ec->irqmask  = 1;
571         ec->irq_data = (void *)slot_port;
572         ec->ops      = (expansioncard_ops_t *)&icside_ops_arcin_v5;
573
574         /*
575          * Be on the safe side - disable interrupts
576          */
577         inb(slot_port + ICS_ARCIN_V5_INTROFFSET);
578
579         hwif = icside_setup(slot_port, &icside_cardinfo_v5, ec->irq);
580
581         return hwif ? 0 : -1;
582 }
583
584 static int __init icside_register_v6(struct expansion_card *ec, int autodma)
585 {
586         unsigned long slot_port, port;
587         struct ata_channel *hwif;
588         struct ata_channel *mate;
589         int sel = 0;
590
591         slot_port = ecard_address(ec, ECARD_IOC, ECARD_FAST);
592         port      = ecard_address(ec, ECARD_EASI, ECARD_FAST);
593
594         if (port == 0)
595                 port = slot_port;
596         else
597                 sel = 1 << 5;
598
599         outb(sel, slot_port);
600
601         ec->irq_data = (void *)port;
602         ec->ops      = (expansioncard_ops_t *)&icside_ops_arcin_v6;
603
604         /*
605          * Be on the safe side - disable interrupts
606          */
607         inb(port + ICS_ARCIN_V6_INTROFFSET_1);
608         inb(port + ICS_ARCIN_V6_INTROFFSET_2);
609
610         hwif = icside_setup(port, &icside_cardinfo_v6_1, ec->irq);
611         mate = icside_setup(port, &icside_cardinfo_v6_2, ec->irq);
612
613 #ifdef CONFIG_BLK_DEV_IDEDMA_ICS
614         if (ec->dma != NO_DMA) {
615                 if (request_dma(ec->dma, hwif->name))
616                         goto no_dma;
617
618                 if (hwif) {
619                         hwif->config_data = slot_port;
620                         hwif->select_data = sel;
621                         hwif->hw.dma  = ec->dma;
622                         hwif->hw.priv = (void *)
623                                         (port + ICS_ARCIN_V6_INTRSTAT_1);
624                         hwif->unit = 0;
625                         icside_setup_dma(hwif, autodma);
626                 }
627                 if (mate) {
628                         mate->config_data = slot_port;
629                         mate->select_data = sel | 1;
630                         mate->hw.dma  = ec->dma;
631                         mate->hw.priv = (void *)
632                                         (port + ICS_ARCIN_V6_INTRSTAT_2);
633                         mate->unit = 1;
634                         icside_setup_dma(mate, autodma);
635                 }
636         }
637 no_dma:
638 #endif
639         return hwif || mate ? 0 : -1;
640 }
641
642 int __init icside_init(void)
643 {
644         int autodma = 0;
645
646 #ifdef CONFIG_IDEDMA_ICS_AUTO
647         autodma = 1;
648 #endif
649
650         ecard_startfind ();
651
652         do {
653                 struct expansion_card *ec;
654                 int result;
655
656                 ec = ecard_find(0, icside_cids);
657                 if (ec == NULL)
658                         break;
659
660                 ecard_claim(ec);
661
662                 switch (icside_identifyif(ec)) {
663                 case ics_if_arcin_v5:
664                         result = icside_register_v5(ec, autodma);
665                         break;
666
667                 case ics_if_arcin_v6:
668                         result = icside_register_v6(ec, autodma);
669                         break;
670
671                 default:
672                         result = -1;
673                         break;
674                 }
675
676                 if (result)
677                         ecard_release(ec);
678         } while (1);
679
680         return 0;
681 }