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