[PATCH] 2.5.12 IDE 49
[opensuse:kernel.git] / drivers / ide / ide-probe.c
1 /*
2  *  Copyright (C) 1994-1998  Linus Torvalds & authors (see below)
3  *
4  *  Mostly written by Mark Lord <mlord@pobox.com>
5  *                and Gadi Oxman <gadio@netvision.net.il>
6  *                and Andre Hedrick <andre@linux-ide.org>
7  *
8  *  See linux/MAINTAINERS for address of current maintainer.
9  *
10  * This is the IDE probe module, as evolved from hd.c and ide.c.
11  *
12  * Version 1.00         move drive probing code from ide.c to ide-probe.c
13  * Version 1.01         fix compilation problem for m68k
14  * Version 1.02         increase WAIT_PIDENTIFY to avoid CD-ROM locking at boot
15  *                       by Andrea Arcangeli
16  * Version 1.03         fix for (hwif->chipset == ide_4drives)
17  * Version 1.04         fixed buggy treatments of known flash memory cards
18  *
19  * Version 1.05         fix for (hwif->chipset == ide_pdc4030)
20  *                      added ide6/7/8/9
21  *                      allowed for secondary flash card to be detectable
22  *                       with new flag : drive->ata_flash : 1;
23  * Version 1.06         stream line request queue and prep for cascade project.
24  * Version 1.07         max_sect <= 255; slower disks would get behind and
25  *                      then fall over when they get to 256.    Paul G.
26  */
27
28 #include <linux/config.h>
29 #include <linux/module.h>
30 #include <linux/types.h>
31 #include <linux/string.h>
32 #include <linux/kernel.h>
33 #include <linux/timer.h>
34 #include <linux/mm.h>
35 #include <linux/interrupt.h>
36 #include <linux/major.h>
37 #include <linux/errno.h>
38 #include <linux/genhd.h>
39 #include <linux/slab.h>
40 #include <linux/delay.h>
41 #include <linux/ide.h>
42 #include <linux/spinlock.h>
43 #include <linux/pci.h>
44
45 #include <asm/byteorder.h>
46 #include <asm/irq.h>
47 #include <asm/uaccess.h>
48 #include <asm/io.h>
49
50 static inline void do_identify (ide_drive_t *drive, byte cmd)
51 {
52         int bswap = 1;
53         struct hd_driveid *id;
54
55         id = drive->id = kmalloc (SECTOR_WORDS*4, GFP_ATOMIC);  /* called with interrupts disabled! */
56         if (!id) {
57                 printk(KERN_WARNING "(ide-probe::do_identify) Out of memory.\n");
58                 goto err_kmalloc;
59         }
60
61         /* Read 512 bytes of id info.
62          *
63          * Please note that it is well known that some *very* old drives are
64          * able to provide only 256 of them, since this was the amount read by
65          * DOS.
66          *
67          * However let's try to get away with this...
68          */
69
70 #if 1
71         ata_read(drive, id, SECTOR_WORDS);
72 #else
73         {
74                 unsigned long   *ptr = (unsigned long *)id ;
75                 unsigned long   lcount = 256/2 ;
76                 // printk("IDE_DATA_REG = %#lx",IDE_DATA_REG);
77                 while( lcount-- )
78                         *ptr++ = inl(IDE_DATA_REG);
79         }
80 #endif
81         ide__sti();     /* local CPU only */
82         ide_fix_driveid(id);
83
84         if (id->word156 == 0x4d42) {
85                 printk("%s: drive->id->word156 == 0x%04x \n", drive->name, drive->id->word156);
86         }
87
88         if (!drive->forced_lun)
89                 drive->last_lun = id->last_lun & 0x7;
90 #if defined (CONFIG_SCSI_EATA_DMA) || defined (CONFIG_SCSI_EATA_PIO) || defined (CONFIG_SCSI_EATA)
91         /*
92          * EATA SCSI controllers do a hardware ATA emulation:
93          * Ignore them if there is a driver for them available.
94          */
95         if ((id->model[0] == 'P' && id->model[1] == 'M')
96          || (id->model[0] == 'S' && id->model[1] == 'K')) {
97                 printk("%s: EATA SCSI HBA %.10s\n", drive->name, id->model);
98                 goto err_misc;
99         }
100 #endif
101
102         /*
103          *  WIN_IDENTIFY returns little-endian info,
104          *  WIN_PIDENTIFY *usually* returns little-endian info.
105          */
106         if (cmd == WIN_PIDENTIFY) {
107                 if ((id->model[0] == 'N' && id->model[1] == 'E') /* NEC */
108                  || (id->model[0] == 'F' && id->model[1] == 'X') /* Mitsumi */
109                  || (id->model[0] == 'P' && id->model[1] == 'i'))/* Pioneer */
110                         bswap ^= 1;     /* Vertos drives may still be weird */
111         }
112         ide_fixstring (id->model,     sizeof(id->model),     bswap);
113         ide_fixstring (id->fw_rev,    sizeof(id->fw_rev),    bswap);
114         ide_fixstring (id->serial_no, sizeof(id->serial_no), bswap);
115
116         if (strstr(id->model, "E X A B Y T E N E S T"))
117                 goto err_misc;
118
119         id->model[sizeof(id->model)-1] = '\0';  /* we depend on this a lot! */
120         printk("%s: %s, ", drive->name, id->model);
121         drive->present = 1;
122
123         /*
124          * Check for an ATAPI device
125          */
126         if (cmd == WIN_PIDENTIFY) {
127                 byte type = (id->config >> 8) & 0x1f;
128                 printk("ATAPI ");
129 #ifdef CONFIG_BLK_DEV_PDC4030
130                 if (drive->channel->unit == 1 && drive->channel->chipset == ide_pdc4030) {
131                         printk(" -- not supported on 2nd Promise port\n");
132                         goto err_misc;
133                 }
134 #endif
135                 switch (type) {
136                         case ATA_FLOPPY:
137                                 if (!strstr(id->model, "CD-ROM")) {
138                                         if (!strstr(id->model, "oppy") && !strstr(id->model, "poyp") && !strstr(id->model, "ZIP"))
139                                                 printk("cdrom or floppy?, assuming ");
140                                         if (drive->type != ATA_ROM) {
141                                                 printk ("FLOPPY");
142                                                 break;
143                                         }
144                                 }
145                                 type = ATA_ROM; /* Early cdrom models used zero */
146                         case ATA_ROM:
147                                 drive->removable = 1;
148 #ifdef CONFIG_PPC
149                                 /* kludge for Apple PowerBook internal zip */
150                                 if (!strstr(id->model, "CD-ROM") && strstr(id->model, "ZIP")) {
151                                         printk ("FLOPPY");
152                                         type = ATA_FLOPPY;
153                                         break;
154                                 }
155 #endif
156                                 printk ("CD/DVD-ROM");
157                                 break;
158                         case ATA_TAPE:
159                                 printk ("TAPE");
160                                 break;
161                         case ATA_MOD:
162                                 printk ("OPTICAL");
163                                 drive->removable = 1;
164                                 break;
165                         default:
166                                 printk("UNKNOWN (type %d)", type);
167                                 break;
168                 }
169                 printk (" drive\n");
170                 drive->type = type;
171                 return;
172         }
173
174         /*
175          * Not an ATAPI device: looks like a "regular" hard disk
176          */
177         if (id->config & (1<<7))
178                 drive->removable = 1;
179
180         /*
181          * FIXME: This is just plain ugly or plain unnecessary.
182          *
183          * Prevent long system lockup probing later for non-existant slave
184          * drive if the hwif is actually a flash memory card of some variety:
185          */
186
187         if (drive_is_flashcard(drive)) {
188                 ide_drive_t *mate = &drive->channel->drives[1 ^ drive->select.b.unit];
189                 if (!mate->ata_flash) {
190                         mate->present = 0;
191                         mate->noprobe = 1;
192                 }
193         }
194         drive->type = ATA_DISK;
195         printk("ATA DISK drive\n");
196
197         /* Initialize our quirk list. */
198         if (drive->channel->quirkproc)
199                 drive->quirk_list = drive->channel->quirkproc(drive);
200
201         return;
202
203 err_misc:
204         kfree(id);
205 err_kmalloc:
206         drive->present = 0;
207         return;
208 }
209
210 /*
211  * try_to_identify() sends an ATA(PI) IDENTIFY request to a drive
212  * and waits for a response.  It also monitors irqs while this is
213  * happening, in hope of automatically determining which one is
214  * being used by the interface.
215  *
216  * Returns:     0  device was identified
217  *              1  device timed-out (no response to identify request)
218  *              2  device aborted the command (refused to identify itself)
219  */
220 static int actual_try_to_identify (ide_drive_t *drive, byte cmd)
221 {
222         int rc;
223         ide_ioreg_t hd_status;
224         unsigned long timeout;
225         byte s, a;
226
227         if (IDE_CONTROL_REG) {
228                 /* take a deep breath */
229                 ide_delay_50ms();
230                 a = IN_BYTE(IDE_ALTSTATUS_REG);
231                 s = IN_BYTE(IDE_STATUS_REG);
232                 if ((a ^ s) & ~INDEX_STAT) {
233                         printk("%s: probing with STATUS(0x%02x) instead of ALTSTATUS(0x%02x)\n", drive->name, s, a);
234                         hd_status = IDE_STATUS_REG;     /* ancient Seagate drives, broken interfaces */
235                 } else {
236                         hd_status = IDE_ALTSTATUS_REG;  /* use non-intrusive polling */
237                 }
238         } else {
239                 ide_delay_50ms();
240                 hd_status = IDE_STATUS_REG;
241         }
242
243         /* set features register for atapi identify command to be sure of reply */
244         if ((cmd == WIN_PIDENTIFY))
245                 OUT_BYTE(0,IDE_FEATURE_REG);    /* disable dma & overlap */
246
247 #if CONFIG_BLK_DEV_PDC4030
248         if (drive->channel->chipset == ide_pdc4030) {
249                 /* DC4030 hosted drives need their own identify... */
250                 extern int pdc4030_identify(ide_drive_t *);
251                 if (pdc4030_identify(drive)) {
252                         return 1;
253                 }
254         } else
255 #endif /* CONFIG_BLK_DEV_PDC4030 */
256                 OUT_BYTE(cmd,IDE_COMMAND_REG);          /* ask drive for ID */
257         timeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
258         timeout += jiffies;
259         do {
260                 if (0 < (signed long)(jiffies - timeout)) {
261                         return 1;       /* drive timed-out */
262                 }
263                 ide_delay_50ms();               /* give drive a breather */
264         } while (IN_BYTE(hd_status) & BUSY_STAT);
265
266         ide_delay_50ms();               /* wait for IRQ and DRQ_STAT */
267         if (OK_STAT(GET_STAT(),DRQ_STAT,BAD_R_STAT)) {
268                 unsigned long flags;
269                 __save_flags(flags);    /* local CPU only */
270                 __cli();                /* local CPU only; some systems need this */
271                 do_identify(drive, cmd); /* drive returned ID */
272                 rc = 0;                 /* drive responded with ID */
273                 (void) GET_STAT();      /* clear drive IRQ */
274                 __restore_flags(flags); /* local CPU only */
275         } else
276                 rc = 2;                 /* drive refused ID */
277         return rc;
278 }
279
280 static int try_to_identify (ide_drive_t *drive, byte cmd)
281 {
282         int retval;
283         int autoprobe = 0;
284         unsigned long cookie = 0;
285
286         if (IDE_CONTROL_REG && !drive->channel->irq) {
287                 autoprobe = 1;
288                 cookie = probe_irq_on();
289                 OUT_BYTE(drive->ctl,IDE_CONTROL_REG);   /* enable device irq */
290         }
291
292         retval = actual_try_to_identify(drive, cmd);
293
294         if (autoprobe) {
295                 int irq;
296                 OUT_BYTE(drive->ctl | 0x02, IDE_CONTROL_REG);   /* mask device irq */
297                 GET_STAT();                     /* clear drive IRQ */
298                 udelay(5);
299                 irq = probe_irq_off(cookie);
300                 if (!drive->channel->irq) {
301                         if (irq > 0)
302                                 drive->channel->irq = irq;
303                         else    /* Mmmm.. multiple IRQs.. don't know which was ours */
304                                 printk("%s: IRQ probe failed (0x%lx)\n", drive->name, cookie);
305                 }
306         }
307         return retval;
308 }
309
310
311 /*
312  * do_probe() has the difficult job of finding a drive if it exists,
313  * without getting hung up if it doesn't exist, without trampling on
314  * ethernet cards, and without leaving any IRQs dangling to haunt us later.
315  *
316  * If a drive is "known" to exist (from CMOS or kernel parameters),
317  * but does not respond right away, the probe will "hang in there"
318  * for the maximum wait time (about 30 seconds), otherwise it will
319  * exit much more quickly.
320  *
321  * Returns:     0  device was identified
322  *              1  device timed-out (no response to identify request)
323  *              2  device aborted the command (refused to identify itself)
324  *              3  bad status from device (possible for ATAPI drives)
325  *              4  probe was not attempted because failure was obvious
326  */
327 static int do_probe (ide_drive_t *drive, byte cmd)
328 {
329         int rc;
330         struct ata_channel *hwif = drive->channel;
331         if (drive->present) {   /* avoid waiting for inappropriate probes */
332                 if ((drive->type != ATA_DISK) && (cmd == WIN_IDENTIFY))
333                         return 4;
334         }
335 #ifdef DEBUG
336         printk("probing for %s: present=%d, type=%d, probetype=%s\n",
337                 drive->name, drive->present, drive->type,
338                 (cmd == WIN_IDENTIFY) ? "ATA" : "ATAPI");
339 #endif
340         ide_delay_50ms();       /* needed for some systems (e.g. crw9624 as drive0 with disk as slave) */
341         SELECT_DRIVE(hwif,drive);
342         ide_delay_50ms();
343         if (IN_BYTE(IDE_SELECT_REG) != drive->select.all && !drive->present) {
344                 if (drive->select.b.unit != 0) {
345                         SELECT_DRIVE(hwif,&hwif->drives[0]);    /* exit with drive0 selected */
346                         ide_delay_50ms();               /* allow BUSY_STAT to assert & clear */
347                 }
348                 return 3;    /* no i/f present: mmm.. this should be a 4 -ml */
349         }
350
351         if (OK_STAT(GET_STAT(),READY_STAT,BUSY_STAT)
352          || drive->present || cmd == WIN_PIDENTIFY)
353         {
354                 if ((rc = try_to_identify(drive,cmd)))   /* send cmd and wait */
355                         rc = try_to_identify(drive,cmd); /* failed: try again */
356                 if (rc == 1 && cmd == WIN_PIDENTIFY && drive->autotune != 2) {
357                         unsigned long timeout;
358                         printk("%s: no response (status = 0x%02x), resetting drive\n", drive->name, GET_STAT());
359                         ide_delay_50ms();
360                         OUT_BYTE (drive->select.all, IDE_SELECT_REG);
361                         ide_delay_50ms();
362                         OUT_BYTE(WIN_SRST, IDE_COMMAND_REG);
363                         timeout = jiffies;
364                         while ((GET_STAT() & BUSY_STAT) && time_before(jiffies, timeout + WAIT_WORSTCASE))
365                                 ide_delay_50ms();
366                         rc = try_to_identify(drive, cmd);
367                 }
368                 if (rc == 1)
369                         printk("%s: no response (status = 0x%02x)\n", drive->name, GET_STAT());
370                 (void) GET_STAT();              /* ensure drive irq is clear */
371         } else {
372                 rc = 3;                         /* not present or maybe ATAPI */
373         }
374         if (drive->select.b.unit != 0) {
375                 SELECT_DRIVE(hwif,&hwif->drives[0]);    /* exit with drive0 selected */
376                 ide_delay_50ms();
377                 (void) GET_STAT();              /* ensure drive irq is clear */
378         }
379         return rc;
380 }
381
382 /*
383  *
384  */
385 static void enable_nest(ide_drive_t *drive)
386 {
387         unsigned long timeout;
388
389         printk("%s: enabling %s -- ", drive->channel->name, drive->id->model);
390         SELECT_DRIVE(drive->channel, drive);
391         ide_delay_50ms();
392         OUT_BYTE(EXABYTE_ENABLE_NEST, IDE_COMMAND_REG);
393         timeout = jiffies + WAIT_WORSTCASE;
394         do {
395                 if (jiffies > timeout) {
396                         printk("failed (timeout)\n");
397                         return;
398                 }
399                 ide_delay_50ms();
400         } while (GET_STAT() & BUSY_STAT);
401         ide_delay_50ms();
402         if (!OK_STAT(GET_STAT(), 0, BAD_STAT))
403                 printk("failed (status = 0x%02x)\n", GET_STAT());
404         else
405                 printk("success\n");
406         if (do_probe(drive, WIN_IDENTIFY) >= 2) {       /* if !(success||timed-out) */
407                 (void) do_probe(drive, WIN_PIDENTIFY);  /* look for ATAPI device */
408         }
409 }
410
411 /*
412  * Tests for existence of a given drive using do_probe().
413  */
414 static inline void probe_for_drive (ide_drive_t *drive)
415 {
416         if (drive->noprobe)                     /* skip probing? */
417                 return;
418         if (do_probe(drive, WIN_IDENTIFY) >= 2) { /* if !(success||timed-out) */
419                 do_probe(drive, WIN_PIDENTIFY); /* look for ATAPI device */
420         }
421         if (drive->id && strstr(drive->id->model, "E X A B Y T E N E S T"))
422                 enable_nest(drive);
423         if (!drive->present)
424                 return;                 /* drive not found */
425         if (drive->id == NULL) {                /* identification failed? */
426                 if (drive->type == ATA_DISK) {
427                         printk ("%s: non-IDE drive, CHS=%d/%d/%d\n",
428                          drive->name, drive->cyl, drive->head, drive->sect);
429                 } else if (drive->type == ATA_ROM) {
430                         printk("%s: ATAPI cdrom (?)\n", drive->name);
431                 } else {
432                         drive->present = 0;     /* nuke it */
433                 }
434         }
435 }
436
437 /*
438  * This routine only knows how to look for drive units 0 and 1
439  * on an interface, so any setting of MAX_DRIVES > 2 won't work here.
440  */
441 static void channel_probe(struct ata_channel *ch)
442 {
443         unsigned int unit;
444         unsigned long flags;
445         int error;
446
447         if (ch->noprobe)
448                 return;
449
450         ch->straight8 = 0;
451
452         __save_flags(flags);    /* local CPU only */
453         __sti();                /* local CPU only; needed for jiffies and irq probing */
454
455         /*
456          * Check for the presence of a channel by probing for drives on it.
457          */
458         for (unit = 0; unit < MAX_DRIVES; ++unit) {
459                 struct ata_device *drive = &ch->drives[unit];
460
461                 probe_for_drive(drive);
462
463                 /* drive found, there is a channel it is attached too. */
464                 if (drive->present)
465                         ch->present = 1;
466         }
467
468         if (!ch->present)
469                 goto not_found;
470
471         error = 0;
472
473         if (((unsigned long)ch->io_ports[IDE_DATA_OFFSET] | 7) ==
474                         ((unsigned long)ch->io_ports[IDE_STATUS_OFFSET])) {
475                 error += !request_region(ch->io_ports[IDE_DATA_OFFSET], 8, ch->name);
476                 ch->straight8 = 1;
477         } else {
478                 if (ch->io_ports[IDE_DATA_OFFSET])
479                         error += !request_region(ch->io_ports[IDE_DATA_OFFSET], 1, ch->name);
480                 if (ch->io_ports[IDE_ERROR_OFFSET])
481                         error += !request_region(ch->io_ports[IDE_ERROR_OFFSET], 1, ch->name);
482                 if (ch->io_ports[IDE_NSECTOR_OFFSET])
483                         error += !request_region(ch->io_ports[IDE_NSECTOR_OFFSET], 1, ch->name);
484                 if (ch->io_ports[IDE_SECTOR_OFFSET])
485                         error += !request_region(ch->io_ports[IDE_SECTOR_OFFSET], 1, ch->name);
486                 if (ch->io_ports[IDE_LCYL_OFFSET])
487                         error += !request_region(ch->io_ports[IDE_LCYL_OFFSET], 1, ch->name);
488                 if (ch->io_ports[IDE_HCYL_OFFSET])
489                         error += !request_region(ch->io_ports[IDE_HCYL_OFFSET], 1, ch->name);
490                 if (ch->io_ports[IDE_SELECT_OFFSET])
491                         error += !request_region(ch->io_ports[IDE_SELECT_OFFSET], 1, ch->name);
492                 if (ch->io_ports[IDE_STATUS_OFFSET])
493                         error += !request_region(ch->io_ports[IDE_STATUS_OFFSET], 1, ch->name);
494
495         }
496         if (ch->io_ports[IDE_CONTROL_OFFSET])
497                 error += !request_region(ch->io_ports[IDE_CONTROL_OFFSET], 1, ch->name);
498 #if defined(CONFIG_AMIGA) || defined(CONFIG_MAC)
499         if (ch->io_ports[IDE_IRQ_OFFSET])
500                 error += !request_region(ch->io_ports[IDE_IRQ_OFFSET], 1, ch->name);
501 #endif
502
503         /* Some neccessary register area was already used. Skip this device.
504          */
505
506         if (
507 #if CONFIG_BLK_DEV_PDC4030
508                         (ch->chipset != ide_pdc4030 || ch->unit == 0) &&
509 #endif
510                         error) {
511
512                 /* FIXME: We should be dealing properly with partial IO region
513                  * allocations here.
514                  */
515
516                 ch->present = 0;
517                 printk("%s: error: ports already in use!\n", ch->name);
518         }
519
520         if (!ch->present)
521                 goto not_found;
522
523         /* Register this hardware interface within the global device tree.
524          */
525         sprintf(ch->dev.bus_id, "%04x", ch->io_ports[IDE_DATA_OFFSET]);
526         sprintf(ch->dev.name, "ide");
527         ch->dev.driver_data = ch;
528 #ifdef CONFIG_BLK_DEV_IDEPCI
529         if (ch->pci_dev)
530                 ch->dev.parent = &ch->pci_dev->dev;
531         else
532 #endif
533                 ch->dev.parent = NULL; /* Would like to do = &device_legacy */
534
535         device_register(&ch->dev);
536
537         if (ch->io_ports[IDE_CONTROL_OFFSET] && ch->reset) {
538                 unsigned long timeout = jiffies + WAIT_WORSTCASE;
539                 byte stat;
540
541                 printk("%s: reset\n", ch->name);
542                 OUT_BYTE(12, ch->io_ports[IDE_CONTROL_OFFSET]);
543                 udelay(10);
544                 OUT_BYTE(8, ch->io_ports[IDE_CONTROL_OFFSET]);
545                 do {
546                         ide_delay_50ms();
547                         stat = IN_BYTE(ch->io_ports[IDE_STATUS_OFFSET]);
548                 } while ((stat & BUSY_STAT) && 0 < (signed long)(timeout - jiffies));
549         }
550
551         __restore_flags(flags); /* local CPU only */
552
553         /*
554          * Now setup the PIO transfer modes of the drives on this channel.
555          */
556         for (unit = 0; unit < MAX_DRIVES; ++unit) {
557                 struct ata_device *drive = &ch->drives[unit];
558
559                 if (drive->present && (drive->autotune == 1)) {
560                         if (drive->channel->tuneproc)
561                                 drive->channel->tuneproc(drive, 255);   /* auto-tune PIO mode */
562                 }
563         }
564
565         return;
566
567 not_found:
568         __restore_flags(flags);
569 }
570
571 /*
572  * init request queue
573  */
574 static void init_device_queue(struct ata_device *drive)
575 {
576         request_queue_t *q = &drive->queue;
577         int max_sectors = 255;
578
579         q->queuedata = drive->channel;
580         blk_init_queue(q, do_ide_request, &ide_lock);
581         blk_queue_segment_boundary(q, 0xffff);
582
583         /* IDE can do up to 128K per request, pdc4030 needs smaller limit */
584 #ifdef CONFIG_BLK_DEV_PDC4030
585         if (drive->channel->chipset == ide_pdc4030)
586                 max_sectors = 127;
587 #endif
588         blk_queue_max_sectors(q, max_sectors);
589
590         /* IDE DMA can do PRD_ENTRIES number of segments. */
591         blk_queue_max_hw_segments(q, PRD_SEGMENTS);
592
593         /* This is a driver limit and could be eliminated. */
594         blk_queue_max_phys_segments(q, PRD_SEGMENTS);
595 }
596
597 #if MAX_HWIFS > 1
598
599 /*
600  * This is used to simplify logic in init_irq() below.
601  *
602  * A loophole here is that we may not know about a particular hwif's irq until
603  * after that hwif is actually probed/initialized..  This could be a problem
604  * for the case where an hwif is on a dual interface that requires
605  * serialization (eg. cmd640) and another hwif using one of the same irqs is
606  * initialized beforehand.
607  *
608  * This routine detects and reports such situations, but does not fix them.
609  */
610 static void save_match(struct ata_channel *hwif, struct ata_channel *new,
611                 struct ata_channel **match)
612 {
613         struct ata_channel *m = *match;
614
615         if (m && m->hwgroup && m->hwgroup != new->hwgroup) {
616                 if (!new->hwgroup)
617                         return;
618                 printk("%s: potential irq problem with %s and %s\n", hwif->name, new->name, m->name);
619         }
620         if (!m || m->irq != hwif->irq) /* don't undo a prior perfect match */
621                 *match = new;
622 }
623 #endif
624
625 /*
626  * This routine sets up the irq for an ide interface, and creates a new hwgroup
627  * for the irq/channel if none was previously assigned.
628  *
629  * Much of the code is for correctly detecting/handling irq sharing and irq
630  * serialization situations.  This is somewhat complex because it handles
631  * static as well as dynamic (PCMCIA) IDE interfaces.
632  *
633  * The SA_INTERRUPT in sa_flags means ata_irq_request() is always entered with
634  * interrupts completely disabled.  This can be bad for interrupt latency, but
635  * anything else has led to problems on some machines.  We re-enable interrupts
636  * as much as we can safely do in most places.
637  */
638 static int init_irq(struct ata_channel *ch)
639 {
640         unsigned long flags;
641         int i;
642         ide_hwgroup_t *hwgroup;
643         ide_hwgroup_t *new_hwgroup;
644         struct ata_channel *match = NULL;
645
646
647         /* Allocate the buffer and potentially sleep first */
648
649         new_hwgroup = kmalloc(sizeof(ide_hwgroup_t),GFP_KERNEL);
650
651         spin_lock_irqsave(&ide_lock, flags);
652         ch->hwgroup = NULL;
653
654 #if MAX_HWIFS > 1
655         /*
656          * Group up with any other channels that share our irq(s).
657          */
658         for (i = 0; i < MAX_HWIFS; ++i) {
659                 struct ata_channel *h = &ide_hwifs[i];
660
661                 if (h->hwgroup) {  /* scan only initialized channels */
662                         if (ch->irq == h->irq) {
663                                 ch->sharing_irq = h->sharing_irq = 1;
664                                 if (ch->chipset != ide_pci || h->chipset != ide_pci)
665                                         save_match(ch, h, &match);
666
667                                 /* FIXME: This is still confusing. What would
668                                  * happen if we match-ed two times?
669                                  */
670
671                                 if (ch->serialized || h->serialized)
672                                         save_match(ch, h, &match);
673                         }
674                 }
675         }
676 #endif
677         /*
678          * If we are still without a hwgroup, then form a new one
679          */
680         if (match) {
681                 hwgroup = match->hwgroup;
682                 if(new_hwgroup)
683                         kfree(new_hwgroup);
684         } else {
685                 hwgroup = new_hwgroup;
686                 if (!hwgroup) {
687                         spin_unlock_irqrestore(&ide_lock, flags);
688                         return 1;
689                 }
690                 memset(hwgroup, 0, sizeof(*hwgroup));
691                 init_timer(&hwgroup->timer);
692                 hwgroup->timer.function = &ide_timer_expiry;
693                 hwgroup->timer.data = (unsigned long) hwgroup;
694         }
695
696         /*
697          * Allocate the irq, if not already obtained for another channel
698          */
699         if (!match || match->irq != ch->irq) {
700 #ifdef CONFIG_IDEPCI_SHARE_IRQ
701                 int sa = IDE_CHIPSET_IS_PCI(ch->chipset) ? SA_SHIRQ : SA_INTERRUPT;
702 #else
703                 int sa = IDE_CHIPSET_IS_PCI(ch->chipset) ? SA_INTERRUPT|SA_SHIRQ : SA_INTERRUPT;
704 #endif
705
706                 if (ch->io_ports[IDE_CONTROL_OFFSET])
707                         OUT_BYTE(0x08, ch->io_ports[IDE_CONTROL_OFFSET]); /* clear nIEN */
708
709                 if (request_irq(ch->irq, &ata_irq_request, sa, ch->name, ch)) {
710                         if (!match)
711                                 kfree(hwgroup);
712                         spin_unlock_irqrestore(&ide_lock, flags);
713
714                         return 1;
715                 }
716         }
717
718         /*
719          * Everything is okay. Tag us as member of this hardware group.
720          */
721         ch->hwgroup = hwgroup;
722         for (i = 0; i < MAX_DRIVES; ++i) {
723                 struct ata_device *drive = &ch->drives[i];
724
725                 if (!drive->present)
726                         continue;
727
728                 if (!hwgroup->XXX_drive)
729                         hwgroup->XXX_drive = drive;
730
731                 init_device_queue(drive);
732         }
733         spin_unlock_irqrestore(&ide_lock, flags);
734
735 #if !defined(__mc68000__) && !defined(CONFIG_APUS) && !defined(__sparc__)
736         printk("%s at 0x%03x-0x%03x,0x%03x on irq %d", ch->name,
737                 ch->io_ports[IDE_DATA_OFFSET],
738                 ch->io_ports[IDE_DATA_OFFSET]+7,
739                 ch->io_ports[IDE_CONTROL_OFFSET], ch->irq);
740 #elif defined(__sparc__)
741         printk("%s at 0x%03lx-0x%03lx,0x%03lx on irq %s", ch->name,
742                 ch->io_ports[IDE_DATA_OFFSET],
743                 ch->io_ports[IDE_DATA_OFFSET]+7,
744                 ch->io_ports[IDE_CONTROL_OFFSET], __irq_itoa(ch->irq));
745 #else
746         printk("%s at %p on irq 0x%08x", ch->name,
747                 ch->io_ports[IDE_DATA_OFFSET], ch->irq);
748 #endif
749         if (match)
750                 printk(" (%sed with %s)",
751                         ch->sharing_irq ? "shar" : "serializ", match->name);
752         printk("\n");
753
754         return 0;
755 }
756
757 /*
758  * init_gendisk() (as opposed to ide_geninit) is called for each major device,
759  * after probing for drives, to allocate partition tables and other data
760  * structures needed for the routines in genhd.c.  ide_geninit() gets called
761  * somewhat later, during the partition check.
762  */
763 static void init_gendisk(struct ata_channel *hwif)
764 {
765         struct gendisk *gd;
766         unsigned int unit, minors, i;
767         extern devfs_handle_t ide_devfs_handle;
768
769         minors = MAX_DRIVES * (1 << PARTN_BITS);
770
771         gd = kmalloc (sizeof(struct gendisk), GFP_KERNEL);
772         if (!gd)
773                 goto err_kmalloc_gd;
774
775         gd->sizes = kmalloc (minors * sizeof(int), GFP_KERNEL);
776         if (!gd->sizes)
777                 goto err_kmalloc_gd_sizes;
778
779         gd->part = kmalloc (minors * sizeof(struct hd_struct), GFP_KERNEL);
780         if (!gd->part)
781                 goto err_kmalloc_gd_part;
782         memset(gd->part, 0, minors * sizeof(struct hd_struct));
783
784         for (unit = 0; unit < MAX_DRIVES; ++unit)
785                 hwif->drives[unit].part = &gd->part[unit << PARTN_BITS];
786
787         gd->major       = hwif->major;          /* our major device number */
788         gd->major_name  = IDE_MAJOR_NAME;       /* treated special in genhd.c */
789         gd->minor_shift = PARTN_BITS;           /* num bits for partitions */
790         gd->nr_real     = MAX_DRIVES;           /* current num real drives */
791         gd->next        = NULL;                 /* linked list of major devs */
792         gd->fops        = ide_fops;             /* file operations */
793         gd->de_arr      = kmalloc(sizeof(*gd->de_arr) * MAX_DRIVES, GFP_KERNEL);
794         gd->flags       = kmalloc(sizeof(*gd->flags) * MAX_DRIVES, GFP_KERNEL);
795         if (gd->de_arr)
796                 memset(gd->de_arr, 0, sizeof(*gd->de_arr) * MAX_DRIVES);
797         if (gd->flags)
798                 memset(gd->flags, 0, sizeof(*gd->flags) * MAX_DRIVES);
799
800         hwif->gd = gd;
801         add_gendisk(gd);
802
803         for (unit = 0; unit < MAX_DRIVES; ++unit) {
804                 char name[80];
805
806                 ide_add_generic_settings(hwif->drives + unit);
807                 hwif->drives[unit].dn = ((hwif->unit ? 2 : 0) + unit);
808                 sprintf (name, "host%d/bus%d/target%d/lun%d",
809                         hwif->index, hwif->unit, unit, hwif->drives[unit].lun);
810                 if (hwif->drives[unit].present)
811                         hwif->drives[unit].de = devfs_mk_dir(ide_devfs_handle, name, NULL);
812         }
813         return;
814
815 err_kmalloc_bs:
816         kfree(gd->part);
817 err_kmalloc_gd_part:
818         kfree(gd->sizes);
819 err_kmalloc_gd_sizes:
820         kfree(gd);
821 err_kmalloc_gd:
822         printk(KERN_CRIT "(ide::init_gendisk) Out of memory\n");
823         return;
824 }
825
826 /*
827  * Returns the queue which corresponds to a given device.
828  *
829  * FIXME: this should take struct block_device * as argument in future.
830  */
831
832 static request_queue_t *ata_get_queue(kdev_t dev)
833 {
834         struct ata_channel *ch = (struct ata_channel *)blk_dev[major(dev)].data;
835
836         /* FIXME: ALLERT: This discriminates between master and slave! */
837         return &ch->drives[DEVICE_NR(dev) & 1].queue;
838 }
839
840 static void channel_init(struct ata_channel *ch)
841 {
842         if (!ch->present)
843                 return;
844
845         /* we set it back to 1 if all is ok below */
846         ch->present = 0;
847
848         if (!ch->irq) {
849                 if (!(ch->irq = ide_default_irq(ch->io_ports[IDE_DATA_OFFSET]))) {
850                         printk("%s: DISABLED, NO IRQ\n", ch->name);
851
852                         return;
853                 }
854         }
855 #ifdef CONFIG_BLK_DEV_HD
856         if (ch->irq == HD_IRQ && ch->io_ports[IDE_DATA_OFFSET] != HD_DATA) {
857                 printk("%s: CANNOT SHARE IRQ WITH OLD HARDDISK DRIVER (hd.c)\n", ch->name);
858
859                 return;
860         }
861 #endif
862
863         if (devfs_register_blkdev (ch->major, ch->name, ide_fops)) {
864                 printk("%s: UNABLE TO GET MAJOR NUMBER %d\n", ch->name, ch->major);
865
866                 return;
867         }
868
869         if (init_irq(ch)) {
870                 int irq = ch->irq;
871                 /*
872                  * It failed to initialise. Find the default IRQ for
873                  * this port and try that.
874                  */
875                 if (!(ch->irq = ide_default_irq(ch->io_ports[IDE_DATA_OFFSET]))) {
876                         printk(KERN_INFO "%s: disabled; unable to get IRQ %d.\n", ch->name, irq);
877                         (void) unregister_blkdev (ch->major, ch->name);
878
879                         return;
880                 }
881                 if (init_irq(ch)) {
882                         printk(KERN_INFO "%s: probed IRQ %d and default IRQ %d failed.\n",
883                                 ch->name, irq, ch->irq);
884                         (void) unregister_blkdev(ch->major, ch->name);
885
886                         return;
887                 }
888                 printk(KERN_INFO "%s: probed IRQ %d failed, using default.\n", ch->name, ch->irq);
889         }
890
891         init_gendisk(ch);
892         blk_dev[ch->major].data = ch;
893         blk_dev[ch->major].queue = ata_get_queue;
894
895         /* all went well, flag this channel entry as valid */
896         ch->present = 1;
897
898         return;
899 }
900
901 int ideprobe_init (void)
902 {
903         unsigned int index;
904         int probe[MAX_HWIFS];
905
906         memset(probe, 0, MAX_HWIFS * sizeof(int));
907         for (index = 0; index < MAX_HWIFS; ++index)
908                 probe[index] = !ide_hwifs[index].present;
909
910         /*
911          * Probe for drives in the usual way.. CMOS/BIOS, then poke at ports
912          */
913         for (index = 0; index < MAX_HWIFS; ++index)
914                 if (probe[index])
915                         channel_probe(&ide_hwifs[index]);
916         for (index = 0; index < MAX_HWIFS; ++index)
917                 if (probe[index])
918                         channel_init(&ide_hwifs[index]);
919         return 0;
920 }