This source file includes following definitions.
- read_timer
- input_ide_data
- output_ide_data
- start_ide_timer
- do_ide_reset
- end_drive_cmd
- dump_status
- ide_error
- read_intr
- write_intr
- multwrite
- multwrite_intr
- ide_cmd
- set_multmode_intr
- set_geometry_intr
- recal_intr
- drive_cmd_intr
- timer_expiry
- ide0_timer_expiry
- ide1_timer_expiry
- do_special
- wait_stat
- do_rw_disk
- do_request
- do_ide0_request
- do_ide1_request
- do_ide0_request
- do_shared_request
- unexpected_intr
- ide_seq_intr
- ide0_intr
- ide1_intr
- ide_intr
- ide_shared_intr
- get_info_ptr
- ide_open
- ide_release
- revalidate_disk
- do_drive_cmd
- write_fs_long
- ide_ioctl
- ide_check_media_change
- fixstring
- lba_capacity_is_ok
- do_identify
- delay_10ms
- try_to_identify
- do_probe
- probe_for_drive
- probe_for_drives
- ide_setup
- hda_setup
- hdb_setup
- hdc_setup
- hdd_setup
- probe_cmos_for_drives
- init_ide_data
- setup_irq
- ide_geninit
- ide0_geninit
- ide1_geninit
- sub22
- try_to_init_dtc2278
- ide_init
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131 #include <linux/config.h>
132 #include <linux/errno.h>
133 #include <linux/signal.h>
134 #include <linux/sched.h>
135 #include <linux/timer.h>
136 #include <linux/fs.h>
137 #include <linux/kernel.h>
138 #include <linux/hdreg.h>
139 #include <linux/genhd.h>
140 #include <linux/malloc.h>
141 #include <linux/string.h>
142 #include <linux/delay.h>
143 #include <linux/major.h>
144 #include <linux/ioport.h>
145 #include <linux/interrupt.h>
146 #include <linux/blkdev.h>
147 #include <asm/bitops.h>
148 #include <asm/irq.h>
149 #include <asm/segment.h>
150 #include <asm/system.h>
151
152
153
154
155 #define REALLY_SLOW_IO
156 #include <asm/io.h>
157
158 #undef REALLY_FAST_IO
159 #define INITIAL_MULT_COUNT 0
160 #ifndef SUPPORT_VLB_32BIT
161 #define SUPPORT_VLB_32BIT 1
162 #endif
163 #ifndef SUPPORT_VLB_SYNC
164 #define SUPPORT_VLB_SYNC 1
165 #endif
166 #ifndef DISK_RECOVERY_TIME
167 #define DISK_RECOVERY_TIME 0
168 #endif
169 #ifndef OK_TO_RESET_CONTROLLER
170 #define OK_TO_RESET_CONTROLLER 1
171 #endif
172 #ifndef SUPPORT_TWO_INTERFACES
173 #define SUPPORT_TWO_INTERFACES 1
174 #endif
175 #ifndef OPTIMIZE_IRQS
176 #define OPTIMIZE_IRQS 1
177 #endif
178 #ifndef SUPPORT_SERIALIZE
179 #define SUPPORT_SERIALIZE 1
180 #endif
181 #ifndef SUPPORT_SHARING_IRQ
182 #define SUPPORT_SHARING_IRQ 1
183 #endif
184 #ifndef SUPPORT_DTC2278
185 #define SUPPORT_DTC2278 1
186 #endif
187 #ifndef FANCY_STATUS_DUMPS
188 #define FANCY_STATUS_DUMPS 1
189 #endif
190 #define PROBE_FOR_IRQS 1
191 #define DEFAULT_IDE0_IRQ 14
192 #define DEFAULT_IDE1_IRQ 15
193
194
195 #define IDE_DRIVE_CMD 99
196
197
198
199
200
201
202
203
204
205 #ifndef IDE0_TIMER
206 #define IDE0_TIMER HD_TIMER
207 #define IDE1_TIMER HD_TIMER2
208 #endif
209
210
211
212
213 #ifdef REALLY_SLOW_IO
214 #undef REALLY_FAST_IO
215 #endif
216 #ifdef CONFIG_BLK_DEV_HD
217 #undef SUPPORT_TWO_INTERFACES
218 #define SUPPORT_TWO_INTERFACES 0
219 #endif
220
221 #if SUPPORT_TWO_INTERFACES
222 #define HWIF hwif
223 #define DEV_HWIF (dev->hwif)
224 #if SUPPORT_SERIALIZE
225 #undef SUPPORT_SHARING_IRQ
226 #define SUPPORT_SHARING_IRQ 1
227 #endif
228 #else
229 #undef SUPPORT_SERIALIZE
230 #define SUPPORT_SERIALIZE 0
231 #undef OPTIMIZE_IRQS
232 #define OPTIMIZE_IRQS 0
233 #undef SUPPORT_SHARING_IRQ
234 #define SUPPORT_SHARING_IRQ 0
235 #ifdef CONFIG_BLK_DEV_HD
236 #define HWIF 1
237 #else
238 #define HWIF 0
239 #endif
240 #define DEV_HWIF HWIF
241 #endif
242
243
244
245
246 typedef unsigned char byte;
247 #define IDE_PORT(p,hwif) ((p)^((hwif)<<7))
248
249 #ifdef REALLY_FAST_IO
250 #define OUT_BYTE(b,p) outb((b),IDE_PORT(p,DEV_HWIF))
251 #define IN_BYTE(p,hwif) (byte)inb(IDE_PORT(p,hwif))
252 #else
253 #define OUT_BYTE(b,p) outb_p((b),IDE_PORT(p,DEV_HWIF))
254 #define IN_BYTE(p,hwif) (byte)inb_p(IDE_PORT(p,hwif))
255 #endif
256
257 #if SUPPORT_VLB_32BIT
258 #if SUPPORT_VLB_SYNC
259 #define VLB_SYNC __asm__ __volatile__ ("pusha\n movl $0x01f2,%edx\n inb (%dx),%al\n inb (%dx),%al\n inb (%dx),%al\n popa\n")
260 #endif
261 #endif
262
263 #if SUPPORT_DTC2278
264 static uint probe_dtc2278 = 0;
265 #endif
266
267 #define GET_ERR(hwif) IN_BYTE(HD_ERROR,hwif)
268 #define GET_STAT(hwif) IN_BYTE(HD_STATUS,hwif)
269 #define OK_STAT(stat,good,bad) (((stat)&((good)|(bad)))==(good))
270 #define BAD_R_STAT (BUSY_STAT | ERR_STAT)
271 #define BAD_W_STAT (BUSY_STAT | ERR_STAT | WRERR_STAT)
272 #define BAD_STAT (BAD_R_STAT | DRQ_STAT)
273 #define DRIVE_READY (READY_STAT | SEEK_STAT)
274 #define DATA_READY (DRIVE_READY | DRQ_STAT)
275
276
277
278
279 #define BIOS_SECTORS(dev) (dev->bios_head*dev->bios_sect*dev->bios_cyl)
280 #define HD_NAME "hd"
281 #define PARTN_BITS 6
282 #define PARTN_MASK ((1<<PARTN_BITS)-1)
283 #define MAX_DRIVES 2
284 #define SECTOR_WORDS (512 / 4)
285
286
287
288
289 #define WAIT_DRQ 5
290 #define WAIT_READY 3
291 #define WAIT_PIDENTIFY 100
292 #define WAIT_WORSTCASE 3000
293 #define WAIT_CMD 1000
294
295
296
297
298
299
300
301
302 typedef enum {disk, cdrom} dev_type;
303
304 typedef union {
305 unsigned all : 8;
306 struct {
307 unsigned set_geometry : 1;
308 unsigned recalibrate : 1;
309 unsigned set_multmode : 1;
310 unsigned reserved : 5;
311 } b;
312 } special_t;
313
314 typedef union {
315 unsigned all : 8;
316 struct {
317 unsigned head : 4;
318 unsigned drive : 1;
319 unsigned bit5 : 1;
320 unsigned lba : 1;
321 unsigned bit7 : 1;
322 } b;
323 } select_t;
324
325 typedef struct {
326 byte hwif;
327 byte unmask;
328 dev_type type : 1;
329 unsigned present : 1;
330 unsigned dont_probe : 1;
331 unsigned keep_settings : 1;
332 unsigned busy : 1;
333 unsigned vlb_32bit : 1;
334 unsigned vlb_sync : 1;
335 unsigned reserved0 : 1;
336 special_t special;
337 select_t select;
338 byte mult_count, chipset, reserved2;
339 byte usage, mult_req, wpcom, ctl;
340 byte head, sect, bios_head, bios_sect;
341 unsigned short cyl, bios_cyl;
342 const char *name;
343 struct hd_driveid *id;
344 struct wait_queue *wqueue;
345 } ide_dev_t;
346
347
348
349
350 static const byte ide_major [2] = {IDE0_MAJOR,IDE1_MAJOR};
351 static byte ide_irq [2] = {DEFAULT_IDE0_IRQ,DEFAULT_IDE1_IRQ};
352 static struct hd_struct ide_hd [2][MAX_DRIVES<<PARTN_BITS] = {{{0,0},},};
353 static int ide_sizes [2][MAX_DRIVES<<PARTN_BITS] = {{0,},};
354 static int ide_blksizes [2][MAX_DRIVES<<PARTN_BITS] = {{0,},};
355 static unsigned long ide_capacity [2][MAX_DRIVES] = {{0,},};
356 static ide_dev_t ide_dev [2][MAX_DRIVES] = {{{0,},},};
357 static ide_dev_t *ide_cur_dev [2] = {NULL,NULL};
358 static void (*ide_handler[2])(ide_dev_t *) = {NULL,NULL};
359 static struct request *ide_cur_rq [2] = {NULL,NULL};
360 static struct request ide_write_rq [2];
361 static const int ide_timer [2] = {IDE0_TIMER,IDE1_TIMER};
362 static const int ide_timerbit[2] = {(1<<IDE0_TIMER),(1<<IDE1_TIMER)};
363 static const char *ide_name [2] = {"ide0", "ide1"};
364 static const char *ide_devname [2][MAX_DRIVES] =
365 {{HD_NAME "a", HD_NAME "b"}, {HD_NAME "c", HD_NAME "d"}};
366 static const char *unsupported = " not supported by this kernel\n";
367
368 static byte single_threaded = 0;
369 #if SUPPORT_SHARING_IRQ
370 static byte sharing_single_irq = 0;
371 static volatile byte current_hwif = 0;
372 #endif
373
374
375
376
377 static void ide0_geninit(void), ide1_geninit(void);
378 static struct gendisk ide_gendisk [2] =
379 {{
380 IDE0_MAJOR,
381 HD_NAME,
382 PARTN_BITS,
383 1 << PARTN_BITS,
384 MAX_DRIVES,
385 ide0_geninit,
386 ide_hd[0],
387 ide_sizes[0],
388 0,
389 ide_dev[0],
390 NULL
391 },{
392 IDE1_MAJOR,
393 HD_NAME,
394 PARTN_BITS,
395 1 << PARTN_BITS,
396 MAX_DRIVES,
397 ide1_geninit,
398 ide_hd[1],
399 ide_sizes[1],
400 0,
401 ide_dev[1],
402 NULL
403 }};
404
405
406
407
408 #define IDE_DRIVER
409 #include "blk.h"
410
411
412
413
414 #if (DISK_RECOVERY_TIME > 0)
415 static unsigned long ide_lastreq[] = {0,0};
416 #define SET_DISK_RECOVERY_TIMER ide_lastreq[DEV_HWIF] = read_timer();
417 static unsigned long read_timer(void)
418 {
419 unsigned long t, flags;
420 int i;
421
422 save_flags(flags);
423 cli();
424 t = jiffies * 11932;
425 outb_p(0, 0x43);
426 i = inb_p(0x40);
427 i |= inb(0x40) << 8;
428 restore_flags(flags);
429 return (t - i);
430 }
431 #else
432 #define SET_DISK_RECOVERY_TIMER
433 #endif
434
435
436
437
438 static void do_request (byte hwif);
439 #define DO_REQUEST {SET_DISK_RECOVERY_TIMER do_request(DEV_HWIF);}
440
441
442
443
444
445
446
447
448
449
450 #define WAIT_STAT(dev,good,bad,timeout,msg,label) \
451 { \
452 byte stat; \
453 udelay(1); \
454 if (GET_STAT(DEV_HWIF) & BUSY_STAT) { \
455 unsigned long timer = jiffies + timeout; \
456 do { \
457 if ((GET_STAT(DEV_HWIF) & BUSY_STAT) == 0) \
458 break; \
459 } while (timer > jiffies); \
460 } \
461 udelay(1); \
462 if (!OK_STAT(stat=GET_STAT(DEV_HWIF), good, bad)) { \
463 ide_error(dev, msg " error", stat); \
464 goto label; \
465 } \
466 }
467
468
469
470
471 void input_ide_data (ide_dev_t *dev, void *buffer, uint wcount)
472 {
473 #if SUPPORT_VLB_32BIT
474 if (dev->vlb_32bit) {
475 #if SUPPORT_VLB_SYNC
476 if (dev->vlb_sync) {
477 cli();
478 VLB_SYNC;
479 insl(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount);
480 if (dev->unmask)
481 sti();
482 } else
483 #endif
484 insl(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount);
485 } else
486 #endif
487 insw(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount<<1);
488 }
489
490
491
492
493 void output_ide_data (ide_dev_t *dev, void *buffer, uint wcount)
494 {
495 #if SUPPORT_VLB_32BIT
496 if (dev->vlb_32bit) {
497 #if SUPPORT_VLB_SYNC
498 if (dev->vlb_sync) {
499 cli();
500 VLB_SYNC;
501 outsl(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount);
502 if (dev->unmask)
503 sti();
504 } else
505 outsl(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount);
506 #endif
507 } else
508 #endif
509 outsw(IDE_PORT(HD_DATA,DEV_HWIF), buffer, wcount<<1);
510 }
511
512
513
514
515 static inline void start_ide_timer (byte hwif)
516 {
517 if (ide_handler[HWIF] != NULL) {
518 timer_table[ide_timer[HWIF]].expires = jiffies + WAIT_CMD;
519 timer_active |= ide_timerbit[HWIF];
520 }
521 }
522
523 static void do_ide_reset (ide_dev_t *dev)
524 {
525 byte tmp;
526 unsigned long timer, flags;
527
528 save_flags(flags);
529 sti();
530 for (tmp = 0; tmp < MAX_DRIVES; tmp++) {
531 ide_dev_t *rdev = &ide_dev[DEV_HWIF][tmp];
532 rdev->special.b.set_geometry = 1;
533 rdev->special.b.recalibrate = 1;
534 rdev->special.b.set_multmode = 0;
535 if (OK_TO_RESET_CONTROLLER)
536 rdev->mult_count = 0;
537 if (!rdev->keep_settings) {
538 rdev->mult_req = 0;
539 rdev->unmask = 0;
540 }
541 if (rdev->mult_req != rdev->mult_count)
542 rdev->special.b.set_multmode = 1;
543 }
544
545 #if OK_TO_RESET_CONTROLLER
546 cli();
547 OUT_BYTE(dev->ctl|6,HD_CMD);
548 udelay(10);
549 OUT_BYTE(dev->ctl|2,HD_CMD);
550 udelay(10);
551 sti();
552 for (timer = jiffies + WAIT_WORSTCASE; timer > jiffies;) {
553 if ((GET_STAT(DEV_HWIF) & BUSY_STAT) == 0)
554 break;
555 }
556 printk("%s: do_ide_reset: ", ide_name[DEV_HWIF]);
557
558 if (!OK_STAT(tmp=GET_STAT(DEV_HWIF), 0, BUSY_STAT)) {
559 printk("timed-out, status=0x%02x\n", tmp);
560 } else {
561 if ((tmp = GET_ERR(DEV_HWIF)) == 1)
562 printk("success\n");
563 else {
564 printk("%s: ", ide_devname[DEV_HWIF][0]);
565 switch (tmp & 0x7f) {
566 case 1: printk("passed");
567 break;
568 case 2: printk("formatter device error");
569 break;
570 case 3: printk("sector buffer error");
571 break;
572 case 4: printk("ECC circuitry error");
573 break;
574 case 5: printk("controlling MPU error");
575 break;
576 default:printk("error (0x%02x?)", tmp);
577 }
578 if (tmp & 0x80)
579 printk("; %s: error", ide_devname[DEV_HWIF][1]);
580 printk("\n");
581 }
582 }
583 #endif
584 restore_flags(flags);
585 }
586
587
588
589
590 static void end_drive_cmd (ide_dev_t *dev, byte stat, byte err)
591 {
592 unsigned long flags;
593 struct request *rq = ide_cur_rq[DEV_HWIF];
594 byte *args = (byte *) rq->buffer;
595
596 rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
597 if (args) {
598 args[0] = stat;
599 args[1] = err;
600 args[2] = IN_BYTE(HD_NSECTOR,DEV_HWIF);
601 }
602 save_flags(flags);
603 cli();
604 up(rq->sem);
605 ide_cur_rq[DEV_HWIF] = NULL;
606 restore_flags(flags);
607 }
608
609
610
611
612 static byte dump_status (byte hwif, const char *msg, byte stat)
613 {
614 unsigned long flags;
615 byte err = 0;
616 ide_dev_t *dev = ide_cur_dev[HWIF];
617 const char *name = dev ? dev->name : ide_name[HWIF];
618
619 save_flags (flags);
620 sti();
621 printk("%s: %s: status=0x%02x", name, msg, stat);
622 #if FANCY_STATUS_DUMPS
623 if (dev && dev->type == disk) {
624 printk(" { ");
625 if (stat & BUSY_STAT)
626 printk("Busy ");
627 else {
628 if (stat & READY_STAT) printk("DriveReady ");
629 if (stat & WRERR_STAT) printk("WriteFault ");
630 if (stat & SEEK_STAT) printk("SeekComplete ");
631 if (stat & DRQ_STAT) printk("DataRequest ");
632 if (stat & ECC_STAT) printk("CorrectedError ");
633 if (stat & INDEX_STAT) printk("Index ");
634 if (stat & ERR_STAT) printk("Error ");
635 }
636 printk("}");
637 }
638 #endif
639 printk("\n");
640 if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) {
641 err = GET_ERR(HWIF);
642 printk("%s: %s: error=0x%02x", name, msg, err);
643 #if FANCY_STATUS_DUMPS
644 if (dev && dev->type == disk) {
645 printk(" { ");
646 if (err & BBD_ERR) printk("BadSector ");
647 if (err & ECC_ERR) printk("UncorrectableError ");
648 if (err & ID_ERR) printk("SectorIdNotFound ");
649 if (err & ABRT_ERR) printk("DriveStatusError ");
650 if (err & TRK0_ERR) printk("TrackZeroNotFound ");
651 if (err & MARK_ERR) printk("AddrMarkNotFound ");
652 printk("}");
653 if (err & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
654 byte cur = IN_BYTE(HD_CURRENT,HWIF);
655 if (cur & 0x40) {
656 printk(", LBAsect=%ld", (unsigned long)
657 ((cur&0xf)<<24)
658 |(IN_BYTE(HD_HCYL,HWIF)<<16)
659 |(IN_BYTE(HD_LCYL,HWIF)<<8)
660 | IN_BYTE(HD_SECTOR,HWIF));
661 } else {
662 printk(", CHS=%d/%d/%d",
663 (IN_BYTE(HD_HCYL,HWIF)<<8) +
664 IN_BYTE(HD_LCYL,HWIF),
665 cur & 0xf,
666 IN_BYTE(HD_SECTOR,HWIF));
667 }
668 if (ide_cur_rq[HWIF])
669 printk(", sector=%ld", ide_cur_rq[HWIF]->sector);
670 }
671 }
672 #endif
673 printk("\n");
674 }
675 restore_flags (flags);
676 return err;
677 }
678
679
680
681
682 #define ERROR_MAX 8
683 #define ERROR_RESET 3
684 #define ERROR_RECAL 1
685 static void ide_error (ide_dev_t *dev, const char *msg, byte stat)
686 {
687 struct request *rq;
688 byte err;
689
690 err = dump_status(DEV_HWIF, msg, stat);
691 if ((rq = ide_cur_rq[DEV_HWIF]) == NULL || dev == NULL)
692 return;
693 #ifdef IDE_DRIVE_CMD
694 if (rq->cmd == IDE_DRIVE_CMD) {
695 end_drive_cmd(dev, stat, err);
696 return;
697 }
698 #endif
699 if (stat & BUSY_STAT) {
700 rq->errors |= ERROR_RESET;
701 } else {
702 if (dev->type == disk && (stat & ERR_STAT)) {
703
704 if (err & BBD_ERR)
705 rq->errors = ERROR_MAX;
706 else if (err & TRK0_ERR)
707 rq->errors |= ERROR_RECAL;
708 }
709 if ((stat & DRQ_STAT) && rq->cmd == READ) {
710 int i = dev->mult_count ? dev->mult_count<<8 : 1<<8;
711 while (i-- > 0)
712 (void) IN_BYTE(HD_DATA, dev->hwif);
713 }
714 }
715 if (GET_STAT(dev->hwif) & (BUSY_STAT|DRQ_STAT))
716 rq->errors |= ERROR_RESET;
717
718 if (rq->errors >= ERROR_MAX)
719 end_request(0, DEV_HWIF);
720 else {
721 if ((rq->errors & ERROR_RESET) == ERROR_RESET)
722 do_ide_reset(dev);
723 else if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
724 dev->special.b.recalibrate = 1;
725 ++rq->errors;
726 }
727 }
728
729 static void read_intr (ide_dev_t *dev)
730 {
731 byte stat;
732 int i;
733 unsigned int msect, nsect;
734 struct request *rq;
735
736 if (!OK_STAT(stat=GET_STAT(DEV_HWIF),DATA_READY,BAD_R_STAT)) {
737 sti();
738 ide_error(dev, "read_intr", stat);
739 DO_REQUEST;
740 return;
741 }
742 msect = dev->mult_count;
743 read_next:
744 rq = ide_cur_rq[DEV_HWIF];
745 if (msect) {
746 if ((nsect = rq->current_nr_sectors) > msect)
747 nsect = msect;
748 msect -= nsect;
749 } else
750 nsect = 1;
751 input_ide_data(dev, rq->buffer, nsect * SECTOR_WORDS);
752 #ifdef DEBUG
753 printk("%s: read: sectors(%ld-%ld), buffer=0x%08lx, remaining=%ld\n",
754 dev->name, rq->sector, rq->sector+nsect-1,
755 (unsigned long) rq->buffer+(nsect<<9), rq->nr_sectors-nsect);
756 #endif
757 rq->sector += nsect;
758 rq->buffer += nsect<<9;
759 rq->errors = 0;
760 i = (rq->nr_sectors -= nsect);
761 if ((rq->current_nr_sectors -= nsect) <= 0)
762 end_request(1, DEV_HWIF);
763 if (i > 0) {
764 if (msect)
765 goto read_next;
766 ide_handler[DEV_HWIF] = &read_intr;
767 return;
768 }
769
770 DO_REQUEST;
771 }
772
773 static void write_intr (ide_dev_t *dev)
774 {
775 byte stat;
776 int i;
777 struct request *rq = ide_cur_rq[DEV_HWIF];
778
779 if (OK_STAT(stat=GET_STAT(DEV_HWIF),DRIVE_READY,BAD_W_STAT)) {
780 #ifdef DEBUG
781 printk("%s: write: sector %ld, buffer=0x%08lx, remaining=%ld\n",
782 dev->name, rq->sector, (unsigned long) rq->buffer,
783 rq->nr_sectors-1);
784 #endif
785 if ((rq->nr_sectors == 1) ^ ((stat & DRQ_STAT) != 0)) {
786 rq->sector++;
787 rq->buffer += 512;
788 rq->errors = 0;
789 i = --rq->nr_sectors;
790 --rq->current_nr_sectors;
791 if (rq->current_nr_sectors <= 0)
792 end_request(1, DEV_HWIF);
793 if (i > 0) {
794 ide_handler[DEV_HWIF] = &write_intr;
795 output_ide_data(dev, rq->buffer, SECTOR_WORDS);
796 return;
797 }
798 DO_REQUEST;
799 return;
800 }
801 }
802 sti();
803 ide_error(dev, "write_intr", stat);
804 DO_REQUEST;
805 }
806
807 static void multwrite (ide_dev_t *dev)
808 {
809 struct request *rq = &ide_write_rq[DEV_HWIF];
810 unsigned int mcount = dev->mult_count;
811
812 do {
813 unsigned int nsect = rq->current_nr_sectors;
814 if (nsect > mcount)
815 nsect = mcount;
816 mcount -= nsect;
817
818 output_ide_data(dev, rq->buffer, nsect<<7);
819 #ifdef DEBUG
820 printk("%s: multwrite: sector %ld, buffer=0x%08lx, count=%d, remaining=%ld\n",
821 dev->name, rq->sector, (unsigned long) rq->buffer,
822 nsect, rq->nr_sectors - nsect);
823 #endif
824 if ((rq->nr_sectors -= nsect) <= 0)
825 break;
826 if ((rq->current_nr_sectors -= nsect) == 0) {
827 if ((rq->bh = rq->bh->b_reqnext) != NULL) {
828 rq->current_nr_sectors = rq->bh->b_size>>9;
829 rq->buffer = rq->bh->b_data;
830 } else {
831 panic("%s: buffer list corrupted\n", dev->name);
832 break;
833 }
834 } else {
835 rq->buffer += nsect << 9;
836 }
837 } while (mcount);
838 }
839
840 static void multwrite_intr (ide_dev_t *dev)
841 {
842 byte stat;
843 int i;
844 struct request *rq = &ide_write_rq[DEV_HWIF];
845
846 if (OK_STAT(stat=GET_STAT(DEV_HWIF),DRIVE_READY,BAD_W_STAT)) {
847 if (stat & DRQ_STAT) {
848 if (rq->nr_sectors) {
849 if (dev->mult_count)
850 multwrite(dev);
851 ide_handler[DEV_HWIF] = &multwrite_intr;
852 return;
853 }
854 } else {
855 if (!rq->nr_sectors) {
856 rq = ide_cur_rq[DEV_HWIF];
857 for (i = rq->nr_sectors; i > 0;){
858 i -= rq->current_nr_sectors;
859 end_request(1, DEV_HWIF);
860 }
861 DO_REQUEST;
862 return;
863 }
864 }
865 }
866 sti();
867 ide_error(dev, "multwrite_intr", stat);
868 DO_REQUEST;
869 }
870
871
872
873
874
875 static inline void ide_cmd(ide_dev_t *dev, byte cmd, byte nsect,
876 void (*handler)(ide_dev_t *dev))
877 {
878 OUT_BYTE(dev->ctl,HD_CMD);
879 OUT_BYTE(nsect,HD_NSECTOR);
880 OUT_BYTE(cmd,HD_COMMAND);
881 ide_handler[DEV_HWIF] = handler;
882 }
883
884 static void set_multmode_intr (ide_dev_t *dev)
885 {
886 byte stat = GET_STAT(DEV_HWIF);
887
888 sti();
889 if (!OK_STAT(stat,READY_STAT,BAD_STAT)) {
890 dev->mult_req = dev->mult_count = 0;
891 dev->special.b.recalibrate = 1;
892 (void) dump_status(DEV_HWIF, "set_multmode", stat);
893 } else {
894 if ((dev->mult_count = dev->mult_req))
895 printk (" %s: enabled %d-sector multiple mode\n",
896 dev->name, dev->mult_count);
897 else
898 printk (" %s: multiple mode turned off\n", dev->name);
899 }
900 DO_REQUEST;
901 }
902
903 static void set_geometry_intr (ide_dev_t *dev)
904 {
905 byte stat = GET_STAT(DEV_HWIF);
906
907 sti();
908 if (!OK_STAT(stat,READY_STAT,BAD_STAT))
909 ide_error(dev, "set_geometry_intr", stat);
910 DO_REQUEST;
911 }
912
913 static void recal_intr (ide_dev_t *dev)
914 {
915 byte stat = GET_STAT(DEV_HWIF);
916
917 sti();
918 if (!OK_STAT(stat,READY_STAT,BAD_STAT))
919 ide_error(dev, "recal_intr", stat);
920 DO_REQUEST;
921 }
922
923 static void drive_cmd_intr (ide_dev_t *dev)
924 {
925 byte stat = GET_STAT(DEV_HWIF);
926
927 sti();
928 if (!OK_STAT(stat,READY_STAT,BAD_STAT))
929 ide_error(dev, "drive_cmd", stat);
930 else
931 end_drive_cmd (dev, stat, GET_ERR(DEV_HWIF));
932 DO_REQUEST;
933 }
934
935 static void timer_expiry (byte hwif)
936 {
937 unsigned long flags;
938
939 save_flags(flags);
940 cli();
941
942 if (ide_handler[HWIF] == NULL || (timer_active & ide_timerbit[HWIF])) {
943
944 sti();
945 printk("%s: marginal timeout\n", ide_name[HWIF]);
946 } else {
947 ide_handler[HWIF] = NULL;
948 disable_irq(ide_irq[HWIF]);
949 #if SUPPORT_SERIALIZE
950 if (single_threaded && ide_irq[HWIF] != ide_irq[HWIF^1])
951 disable_irq(ide_irq[HWIF^1]);
952 #endif
953 sti();
954 ide_error(ide_cur_dev[HWIF], "timeout", GET_STAT(HWIF));
955 do_request(HWIF);
956 #if SUPPORT_SHARING_IRQ
957 if (single_threaded)
958 hwif = current_hwif;
959 #endif
960 cli();
961 start_ide_timer(HWIF);
962 enable_irq(ide_irq[HWIF]);
963 #if SUPPORT_SERIALIZE
964 if (single_threaded && ide_irq[HWIF] != ide_irq[HWIF^1])
965 enable_irq(ide_irq[HWIF^1]);
966 #endif
967 }
968 restore_flags(flags);
969 }
970
971 static void ide0_timer_expiry (void)
972 {
973 timer_expiry (0);
974 }
975
976 static void ide1_timer_expiry (void)
977 {
978 timer_expiry (1);
979 }
980
981 static int do_special (ide_dev_t *dev)
982 {
983 special_t *s = &dev->special;
984 #ifdef DEBUG
985 printk("%s: do_special: 0x%02x\n", dev->name, s->all);
986 #endif
987 if (s->b.set_geometry) {
988 s->b.set_geometry = 0;
989 if (dev->type == disk) {
990 OUT_BYTE(dev->sect,HD_SECTOR);
991 OUT_BYTE(dev->cyl,HD_LCYL);
992 OUT_BYTE(dev->cyl>>8,HD_HCYL);
993 OUT_BYTE(((dev->head-1)|dev->select.all)&0xBF,HD_CURRENT);
994 ide_cmd(dev, WIN_SPECIFY, dev->sect, &set_geometry_intr);
995 }
996 } else if (s->b.recalibrate) {
997 s->b.recalibrate = 0;
998 if (dev->type == disk)
999 ide_cmd(dev,WIN_RESTORE,dev->sect,&recal_intr);
1000 } else if (s->b.set_multmode) {
1001 if (dev->type == disk) {
1002 if (dev->id && dev->mult_req > dev->id->max_multsect)
1003 dev->mult_req = dev->id->max_multsect;
1004 ide_cmd(dev,WIN_SETMULT,dev->mult_req,&set_multmode_intr);
1005 } else {
1006 dev->mult_req = 0;
1007 printk("%s: multmode not supported by this device\n", dev->name);
1008 }
1009 s->b.set_multmode = 0;
1010 } else {
1011 if (s->all) {
1012 printk("%s: bad special flag: 0x%02x\n", dev->name, s->all);
1013 s->all = 0;
1014 }
1015 }
1016 return (ide_handler[DEV_HWIF] == NULL) ? 1 : 0;
1017 }
1018
1019 #ifdef CONFIG_BLK_DEV_IDECD
1020 static byte wait_stat (ide_dev_t *dev, byte good, byte bad, unsigned long timeout)
1021 {
1022 unsigned long flags;
1023
1024 save_flags(flags);
1025 sti();
1026 WAIT_STAT(dev, good, bad, timeout, "status", error);
1027 restore_flags(flags);
1028 return 0;
1029 error:
1030 restore_flags(flags);
1031 return 1;
1032 }
1033
1034 #include "ide-cd.c"
1035 #endif
1036
1037 static inline int do_rw_disk (ide_dev_t *dev, struct request *rq, unsigned long block)
1038 {
1039 OUT_BYTE(dev->ctl,HD_CMD);
1040 OUT_BYTE(rq->nr_sectors,HD_NSECTOR);
1041 if (dev->select.b.lba) {
1042 #ifdef DEBUG
1043 printk("%s: %sing: LBAsect=%ld, sectors=%ld, buffer=0x%08lx\n",
1044 dev->name, (rq->cmd==READ)?"read":"writ",
1045 block, rq->nr_sectors, (unsigned long) rq->buffer);
1046 #endif
1047 OUT_BYTE(block,HD_SECTOR);
1048 OUT_BYTE(block>>=8,HD_LCYL);
1049 OUT_BYTE(block>>=8,HD_HCYL);
1050 OUT_BYTE(((block>>8)&0x0f)|dev->select.all,HD_CURRENT);
1051 } else {
1052 unsigned int sect,head,cyl,track;
1053 track = block / dev->sect;
1054 sect = block % dev->sect + 1;
1055 OUT_BYTE(sect,HD_SECTOR);
1056 head = track % dev->head;
1057 cyl = track / dev->head;
1058 OUT_BYTE(cyl,HD_LCYL);
1059 OUT_BYTE(cyl>>8,HD_HCYL);
1060 OUT_BYTE(head|dev->select.all,HD_CURRENT);
1061 #ifdef DEBUG
1062 printk("%s: %sing: CHS=%d/%d/%d, sectors=%ld, buffer=0x%08lx\n",
1063 dev->name, (rq->cmd==READ)?"read":"writ", cyl,
1064 head, sect, rq->nr_sectors, (unsigned long) rq->buffer);
1065 #endif
1066 }
1067 if (rq->cmd == READ) {
1068 OUT_BYTE(dev->mult_count ? WIN_MULTREAD : WIN_READ, HD_COMMAND);
1069 ide_handler[DEV_HWIF] = &read_intr;
1070 return 0;
1071 }
1072 if (rq->cmd == WRITE) {
1073 OUT_BYTE(dev->wpcom,HD_PRECOMP);
1074 OUT_BYTE(dev->mult_count ? WIN_MULTWRITE : WIN_WRITE, HD_COMMAND);
1075 WAIT_STAT(dev, DATA_READY, BAD_W_STAT, WAIT_DRQ, "DRQ", error);
1076 if (!dev->unmask)
1077 cli();
1078 if (dev->mult_count) {
1079 ide_write_rq[DEV_HWIF] = *rq;
1080 multwrite(dev);
1081 ide_handler[DEV_HWIF] = &multwrite_intr;
1082 } else {
1083 output_ide_data(dev, rq->buffer, SECTOR_WORDS);
1084 ide_handler[DEV_HWIF] = &write_intr;
1085 }
1086 return 0;
1087 }
1088 #ifdef IDE_DRIVE_CMD
1089 if (rq->cmd == IDE_DRIVE_CMD) {
1090 byte *args = rq->buffer;
1091 if (args) {
1092 OUT_BYTE(args[2],HD_FEATURE);
1093 ide_cmd(dev, args[0], args[1], &drive_cmd_intr);
1094 printk("%s: DRIVE_CMD cmd=0x%02x sc=0x%02x fr=0x%02x\n",
1095 dev->name, args[0], args[1], args[2]);
1096 return 0;
1097 } else {
1098 #ifdef DEBUG
1099 printk("%s: DRIVE_CMD (null)\n", dev->name);
1100 #endif
1101 end_drive_cmd(dev,GET_STAT(DEV_HWIF),GET_ERR(DEV_HWIF));
1102 return 1;
1103 }
1104 }
1105 #endif
1106 printk("%s: bad command: %d\n", dev->name, rq->cmd);
1107 end_request(0, DEV_HWIF);
1108 error:
1109 return 1;
1110 }
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123 static void do_request (byte hwif)
1124 {
1125 unsigned int minor, drive;
1126 unsigned long block, blockend;
1127 struct request *rq;
1128 ide_dev_t *dev;
1129 repeat:
1130 sti();
1131 #if SUPPORT_SHARING_IRQ
1132 current_hwif = hwif;
1133 #endif
1134 if ((rq = ide_cur_rq[HWIF]) == NULL) {
1135 rq = blk_dev[ide_major[HWIF]].current_request;
1136 if ((rq == NULL) || (rq->dev < 0)) {
1137 #if SUPPORT_SHARING_IRQ
1138 if (single_threaded) {
1139 if (sharing_single_irq && (dev = ide_cur_dev[hwif]))
1140 OUT_BYTE(dev->ctl|2,HD_CMD);
1141 rq = blk_dev[ide_major[hwif^=1]].current_request;
1142 if ((rq != NULL) && (rq->dev >= 0))
1143 goto repeat;
1144 }
1145 #endif
1146 return;
1147 }
1148 blk_dev[ide_major[HWIF]].current_request = rq->next;
1149 ide_cur_rq[HWIF] = rq;
1150 }
1151 #ifdef DEBUG
1152 printk("%s: do_request: current=0x%08lx\n",ide_name[HWIF],(unsigned long)rq);
1153 #endif
1154 minor = MINOR(rq->dev);
1155 drive = minor >> PARTN_BITS;
1156 ide_cur_dev[HWIF] = dev = &ide_dev[HWIF][drive];
1157 if ((MAJOR(rq->dev) != ide_major[HWIF]) || (drive >= MAX_DRIVES)) {
1158 printk("%s: bad device number: 0x%04x\n", ide_name[HWIF], rq->dev);
1159 end_request(0, HWIF);
1160 goto repeat;
1161 }
1162 if (rq->bh && !rq->bh->b_lock) {
1163 printk("%s: block not locked\n", ide_name[HWIF]);
1164 end_request(0, HWIF);
1165 goto repeat;
1166 }
1167 block = rq->sector;
1168 blockend = block + rq->nr_sectors;
1169 if ((blockend < block) || (blockend > ide_hd[HWIF][minor].nr_sects)) {
1170 printk("%s: bad access: block=%ld, count=%ld\n",
1171 dev->name, block, rq->nr_sectors);
1172 end_request(0, HWIF);
1173 goto repeat;
1174 }
1175 block += ide_hd[HWIF][minor].start_sect;
1176 #if (DISK_RECOVERY_TIME > 0)
1177 while ((read_timer() - ide_lastreq[HWIF]) < DISK_RECOVERY_TIME);
1178 #endif
1179 OUT_BYTE(dev->select.all,HD_CURRENT);
1180 #ifdef CONFIG_BLK_DEV_IDECD
1181 WAIT_STAT(dev, (dev->type == cdrom) ? 0 : READY_STAT,
1182 BUSY_STAT|DRQ_STAT, WAIT_READY, "DRDY", repeat);
1183 #else
1184 WAIT_STAT(dev, READY_STAT, BUSY_STAT|DRQ_STAT, WAIT_READY, "DRDY", repeat);
1185 #endif
1186 if (!dev->special.all) {
1187 #ifdef CONFIG_BLK_DEV_IDECD
1188 if (dev->type == disk) {
1189 #endif
1190 if (do_rw_disk(dev, rq, block))
1191 goto repeat;
1192 #ifdef CONFIG_BLK_DEV_IDECD
1193 } else {
1194 if (do_rw_cdrom(dev, block))
1195 goto repeat;
1196 }
1197 #endif
1198 } else {
1199 if (do_special(dev))
1200 goto repeat;
1201 }
1202 }
1203
1204
1205
1206
1207
1208
1209 #define DO_IDE_REQUEST(hwif) \
1210 { \
1211 if (ide_handler[hwif] == NULL) { \
1212 disable_irq(ide_irq[hwif]); \
1213 if (single_threaded && ide_irq[hwif] != ide_irq[hwif^1]) \
1214 disable_irq(ide_irq[hwif^1]); \
1215 do_request(hwif); \
1216 cli(); \
1217 start_ide_timer(hwif); \
1218 enable_irq(ide_irq[hwif]); \
1219 if (single_threaded && ide_irq[hwif] != ide_irq[hwif^1]) \
1220 enable_irq(ide_irq[hwif^1]); \
1221 } \
1222 }
1223
1224 #if SUPPORT_TWO_INTERFACES
1225 static void do_ide0_request (void)
1226 {
1227 DO_IDE_REQUEST(0);
1228 }
1229
1230 static void do_ide1_request (void)
1231 {
1232 DO_IDE_REQUEST(1);
1233 }
1234 #else
1235 #define do_ide1_request do_ide0_request
1236 static void do_ide0_request (void)
1237 {
1238 DO_IDE_REQUEST(HWIF);
1239 }
1240 #endif
1241
1242 #if SUPPORT_SHARING_IRQ
1243 static void do_shared_request (void)
1244 {
1245 DO_IDE_REQUEST(current_hwif);
1246 }
1247 #endif
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259 static void unexpected_intr (byte hwif)
1260 {
1261 byte stat;
1262
1263 if (!OK_STAT(stat=GET_STAT(HWIF), DRIVE_READY, BAD_STAT))
1264 (void) dump_status(HWIF, "unexpected_intr", stat);
1265 outb_p(2,IDE_PORT(HD_CMD,hwif));
1266 #if SUPPORT_SHARING_IRQ
1267 if (single_threaded && ide_irq[hwif] == ide_irq[hwif^1]) {
1268 if (!OK_STAT(stat=GET_STAT(hwif^1), DRIVE_READY, BAD_STAT))
1269 (void) dump_status(hwif^1, "unexpected_intr", stat);
1270 outb_p(2,IDE_PORT(HD_CMD,hwif^1));
1271 }
1272 #endif
1273 }
1274
1275
1276
1277
1278
1279
1280 #define IDE_INTR(hwif) \
1281 { \
1282 ide_dev_t *dev; \
1283 void (*handler)(ide_dev_t *); \
1284 \
1285 timer_active &= ~ide_timerbit[hwif]; \
1286 if ((handler = ide_handler[hwif]) != NULL) { \
1287 ide_handler[hwif] = NULL; \
1288 dev = ide_cur_dev[hwif]; \
1289 if (dev->unmask) \
1290 sti(); \
1291 handler(dev); \
1292 } else \
1293 unexpected_intr(hwif); \
1294 cli(); \
1295 }
1296
1297 #if SUPPORT_SERIALIZE
1298
1299 static void ide_seq_intr (int irq, struct pt_regs *regs)
1300 {
1301 byte hwif = (irq != ide_irq[0]);
1302 IDE_INTR(HWIF);
1303 start_ide_timer(current_hwif);
1304 }
1305 #endif
1306
1307 #if OPTIMIZE_IRQS
1308
1309
1310 static void ide0_intr (int irq, struct pt_regs *regs)
1311 {
1312 IDE_INTR(0);
1313 start_ide_timer(0);
1314 }
1315
1316
1317 static void ide1_intr (int irq, struct pt_regs *regs)
1318 {
1319 IDE_INTR(1);
1320 start_ide_timer(1);
1321 }
1322
1323 #else
1324
1325 #define ide0_intr ide_intr
1326 #define ide1_intr ide_intr
1327
1328
1329 static void ide_intr (int irq, struct pt_regs *regs)
1330 {
1331 #if SUPPORT_TWO_INTERFACES
1332 byte hwif = (irq != ide_irq[0]);
1333 #endif
1334 IDE_INTR(HWIF);
1335 start_ide_timer(HWIF);
1336 }
1337
1338 #endif
1339
1340 #if SUPPORT_SHARING_IRQ
1341
1342 static void ide_shared_intr (int irq, struct pt_regs * regs)
1343 {
1344 IDE_INTR(current_hwif);
1345 start_ide_timer(current_hwif);
1346 }
1347 #endif
1348
1349 static ide_dev_t *get_info_ptr (int i_rdev)
1350 {
1351 unsigned int drive = DEVICE_NR(i_rdev);
1352 ide_dev_t *dev;
1353
1354 if (drive < MAX_DRIVES) {
1355 switch (MAJOR(i_rdev)) {
1356 case IDE0_MAJOR: dev = &ide_dev[0][drive];
1357 if (dev->present) return dev;
1358 break;
1359 case IDE1_MAJOR: dev = &ide_dev[1][drive];
1360 if (dev->present) return dev;
1361 break;
1362 }
1363 }
1364 return NULL;
1365 }
1366
1367 static int ide_open(struct inode * inode, struct file * filp)
1368 {
1369 ide_dev_t *dev;
1370 unsigned long flags;
1371
1372 if ((dev = get_info_ptr(inode->i_rdev)) == NULL)
1373 return -ENODEV;
1374 save_flags(flags);
1375 cli();
1376 while (dev->busy)
1377 sleep_on(&dev->wqueue);
1378 dev->usage++;
1379 restore_flags(flags);
1380 #ifdef CONFIG_BLK_DEV_IDECD
1381 if (dev->type == cdrom)
1382 return cdrom_open (inode, filp, dev);
1383 #endif
1384 return 0;
1385 }
1386
1387
1388
1389
1390
1391 static void ide_release(struct inode * inode, struct file * file)
1392 {
1393 ide_dev_t *dev;
1394
1395 if ((dev = get_info_ptr(inode->i_rdev)) != NULL) {
1396 sync_dev(inode->i_rdev);
1397 dev->usage--;
1398 #ifdef CONFIG_BLK_DEV_IDECD
1399 if (dev->type == cdrom)
1400 cdrom_release (inode, file, dev);
1401 #endif
1402 }
1403 }
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413 static int revalidate_disk(int i_rdev)
1414 {
1415 unsigned int i, major, start, drive = DEVICE_NR(i_rdev);
1416 ide_dev_t *dev;
1417 struct gendisk *gd;
1418 long flags;
1419
1420 if ((dev = get_info_ptr(i_rdev)) == NULL)
1421 return -ENODEV;
1422
1423 save_flags(flags);
1424 cli();
1425 if (dev->busy || (dev->usage > 1)) {
1426 restore_flags(flags);
1427 return -EBUSY;
1428 };
1429 dev->busy = 1;
1430 restore_flags(flags);
1431
1432 gd = &ide_gendisk[DEV_HWIF];
1433 major = ide_major[DEV_HWIF] << 8;
1434 start = drive << PARTN_BITS;
1435
1436 for (i = 0; i < (1<<PARTN_BITS); i++) {
1437 unsigned int minor = start + i;
1438 sync_dev (major | minor);
1439 invalidate_inodes (major | minor);
1440 invalidate_buffers (major | minor);
1441 gd->part[minor].start_sect = 0;
1442 gd->part[minor].nr_sects = 0;
1443 };
1444
1445 gd->part[start].nr_sects = ide_capacity[DEV_HWIF][drive];
1446 resetup_one_dev(gd, drive);
1447
1448 dev->busy = 0;
1449 wake_up(&dev->wqueue);
1450 return 0;
1451 }
1452
1453 #ifdef IDE_DRIVE_CMD
1454
1455
1456
1457
1458
1459
1460 static int do_drive_cmd(int dev, char *args)
1461 {
1462 unsigned long flags;
1463 unsigned int major = MAJOR(dev);
1464 struct request rq, *cur_rq;
1465 struct blk_dev_struct *bdev;
1466 struct semaphore sem = MUTEX_LOCKED;
1467
1468
1469 rq.buffer = args;
1470 rq.cmd = IDE_DRIVE_CMD;
1471 rq.errors = 0;
1472 rq.sector = 0;
1473 rq.nr_sectors = 0;
1474 rq.current_nr_sectors = 0;
1475 rq.sem = &sem;
1476 rq.bh = NULL;
1477 rq.bhtail = NULL;
1478 rq.next = NULL;
1479 rq.dev = dev;
1480 bdev = &blk_dev[major];
1481
1482 save_flags(flags);
1483 cli();
1484 cur_rq = bdev->current_request;
1485 if (cur_rq == NULL) {
1486 bdev->current_request = &rq;
1487 bdev->request_fn();
1488 } else {
1489 while (cur_rq->next != NULL)
1490 cur_rq = cur_rq->next;
1491 cur_rq->next = &rq;
1492 }
1493
1494 down(&sem);
1495 restore_flags(flags);
1496 return rq.errors ? -EIO : 0;
1497 }
1498 #endif
1499
1500 static int write_fs_long (unsigned long useraddr, long value)
1501 {
1502 int err;
1503
1504 if (NULL == (long *)useraddr)
1505 return -EINVAL;
1506 if ((err = verify_area(VERIFY_WRITE, (long *)useraddr, sizeof(long))))
1507 return err;
1508 put_fs_long((unsigned)value, (long *) useraddr);
1509 return 0;
1510 }
1511
1512 static int ide_ioctl (struct inode *inode, struct file *file,
1513 unsigned int cmd, unsigned long arg)
1514 {
1515 struct hd_geometry *loc = (struct hd_geometry *) arg;
1516 int err;
1517 ide_dev_t *dev;
1518 unsigned long flags;
1519
1520 if (!inode || !inode->i_rdev)
1521 return -EINVAL;
1522 if ((dev = get_info_ptr(inode->i_rdev)) == NULL)
1523 return -ENODEV;
1524 switch (cmd) {
1525 case HDIO_GETGEO:
1526 if (!loc || dev->type != disk) return -EINVAL;
1527 err = verify_area(VERIFY_WRITE, loc, sizeof(*loc));
1528 if (err) return err;
1529 put_fs_byte(dev->bios_head,
1530 (char *) &loc->heads);
1531 put_fs_byte(dev->bios_sect,
1532 (char *) &loc->sectors);
1533 put_fs_word(dev->bios_cyl,
1534 (short *) &loc->cylinders);
1535 put_fs_long((unsigned)ide_hd[DEV_HWIF][MINOR(inode->i_rdev)].start_sect,
1536 (long *) &loc->start);
1537 return 0;
1538
1539 case BLKFLSBUF:
1540 if(!suser()) return -EACCES;
1541 fsync_dev(inode->i_rdev);
1542 invalidate_buffers(inode->i_rdev);
1543 return 0;
1544
1545 case BLKRASET:
1546 if(!suser()) return -EACCES;
1547 if(arg > 0xff) return -EINVAL;
1548 read_ahead[MAJOR(inode->i_rdev)] = arg;
1549 return 0;
1550
1551 case BLKRAGET:
1552 return write_fs_long(arg, read_ahead[MAJOR(inode->i_rdev)]);
1553
1554 case BLKGETSIZE:
1555 return write_fs_long(arg, ide_hd[DEV_HWIF][MINOR(inode->i_rdev)].nr_sects);
1556 case BLKRRPART:
1557 return revalidate_disk(inode->i_rdev);
1558
1559 case HDIO_GET_KEEPSETTINGS:
1560 return write_fs_long(arg, dev->keep_settings);
1561
1562 case HDIO_GET_UNMASKINTR:
1563 return write_fs_long(arg, dev->unmask);
1564
1565 case HDIO_GET_CHIPSET:
1566 return write_fs_long(arg, dev->chipset);
1567
1568 case HDIO_GET_MULTCOUNT:
1569 return write_fs_long(arg, dev->mult_count);
1570
1571 case HDIO_GET_IDENTITY:
1572 if (!arg || (MINOR(inode->i_rdev) & PARTN_MASK))
1573 return -EINVAL;
1574 if (dev->id == NULL)
1575 return -ENOMSG;
1576 err = verify_area(VERIFY_WRITE, (char *)arg, sizeof(*dev->id));
1577 if (err) return err;
1578 memcpy_tofs((char *)arg, (char *)dev->id, sizeof(*dev->id));
1579 return 0;
1580
1581 case HDIO_SET_KEEPSETTINGS:
1582 case HDIO_SET_UNMASKINTR:
1583 if (!suser()) return -EACCES;
1584 if ((arg > 1) || (MINOR(inode->i_rdev) & PARTN_MASK))
1585 return -EINVAL;
1586 save_flags(flags);
1587 cli();
1588 if (cmd == HDIO_SET_KEEPSETTINGS)
1589 dev->keep_settings = arg;
1590 else
1591 dev->unmask = arg;
1592 restore_flags(flags);
1593 return 0;
1594
1595 case HDIO_SET_CHIPSET:
1596 if (!suser()) return -EACCES;
1597 if ((arg > 3) || (MINOR(inode->i_rdev) & PARTN_MASK))
1598 return -EINVAL;
1599 save_flags(flags);
1600 cli();
1601 dev->chipset = arg;
1602 dev->vlb_sync = (arg & 2) >> 1;
1603 dev->vlb_32bit = (arg & 1);
1604 restore_flags(flags);
1605 return 0;
1606
1607 case HDIO_SET_MULTCOUNT:
1608 if (!suser()) return -EACCES;
1609 if (MINOR(inode->i_rdev) & PARTN_MASK)
1610 return -EINVAL;
1611 if ((dev->id != NULL) && (arg > dev->id->max_multsect))
1612 return -EINVAL;
1613 save_flags(flags);
1614 cli();
1615 if (dev->special.b.set_multmode) {
1616 restore_flags(flags);
1617 return -EBUSY;
1618 }
1619 dev->mult_req = arg;
1620 dev->special.b.set_multmode = 1;
1621 restore_flags(flags);
1622 #ifdef IDE_DRIVE_CMD
1623 do_drive_cmd (inode->i_rdev, NULL);
1624 return (dev->mult_count == arg) ? 0 : -EIO;
1625 #else
1626 return 0;
1627 #endif
1628
1629 #ifdef IDE_DRIVE_CMD
1630 case HDIO_DRIVE_CMD:
1631 {
1632 unsigned long args;
1633
1634 if (NULL == (long *) arg)
1635 err = do_drive_cmd(inode->i_rdev,NULL);
1636 else {
1637 if (!(err = verify_area(VERIFY_WRITE,(long *)arg,sizeof(long))))
1638 {
1639 args = get_fs_long((long *)arg);
1640 err = do_drive_cmd(inode->i_rdev,(char *)&args);
1641 put_fs_long(args,(long *)arg);
1642 }
1643 }
1644 return err;
1645 }
1646 #endif
1647
1648 RO_IOCTLS(inode->i_rdev, arg);
1649
1650 default:
1651 #ifdef CONFIG_BLK_DEV_IDECD
1652 if (dev->type == cdrom)
1653 return ide_cdrom_ioctl(dev, inode, file, cmd, arg);
1654 #endif
1655 return -EPERM;
1656 }
1657 }
1658
1659 #ifdef CONFIG_BLK_DEV_IDECD
1660 static int ide_check_media_change (dev_t full_dev)
1661 {
1662 ide_dev_t *dev;
1663
1664 if ((dev = get_info_ptr(full_dev)) == NULL)
1665 return -ENODEV;
1666 if (dev->type != cdrom)
1667 return 0;
1668 return cdrom_check_media_change (dev);
1669 }
1670 #endif
1671
1672
1673 static void fixstring (byte *s, int bytecount, int byteswap)
1674 {
1675 byte *p, *end = &s[bytecount &= ~1];
1676
1677 if (byteswap) {
1678
1679 for (p = end ; p != s;) {
1680 unsigned short *pp = (unsigned short *) (p -= 2);
1681 *pp = (*pp >> 8) | (*pp << 8);
1682 }
1683 }
1684 p = s;
1685
1686
1687 while (s != end && *s == ' ')
1688 ++s;
1689
1690
1691 while (s != end && *s) {
1692 if (*s++ != ' ' || (s != end && *s && *s != ' '))
1693 *p++ = *(s-1);
1694 }
1695
1696
1697 while (p != end)
1698 *p++ = '\0';
1699 }
1700
1701 static int lba_capacity_is_ok (struct hd_driveid *id)
1702
1703
1704
1705
1706 {
1707 unsigned long lba_sects = id->lba_capacity;
1708 unsigned long chs_sects = id->cyls * id->heads * id->sectors;
1709 unsigned long _10_percent = chs_sects / 10;
1710
1711
1712 if ((lba_sects - chs_sects) < _10_percent)
1713 return 1;
1714
1715
1716 lba_sects = (lba_sects << 16) | (lba_sects >> 16);
1717 if ((lba_sects - chs_sects) < _10_percent) {
1718 id->lba_capacity = lba_sects;
1719 return 1;
1720 }
1721 return 0;
1722 }
1723
1724 static unsigned long probe_mem_start;
1725
1726 static void do_identify (ide_dev_t *dev, byte cmd)
1727 {
1728 int bswap;
1729 struct hd_driveid *id;
1730 unsigned long capacity, check;
1731
1732 id = dev->id = (struct hd_driveid *) probe_mem_start;
1733 probe_mem_start += 512;
1734 input_ide_data(dev, id, SECTOR_WORDS);
1735 sti();
1736
1737
1738
1739
1740 if ((id->model[0] == 'P' && id->model[1] == 'M')
1741 || (id->model[0] == 'S' && id->model[1] == 'K')) {
1742 printk("%s: EATA SCSI HBA %.10s\n", dev->name, id->model);
1743 dev->present = 0;
1744 return;
1745 }
1746
1747
1748
1749
1750
1751 bswap = 1;
1752 if (cmd == WIN_PIDENTIFY) {
1753 if ((id->model[0] == 'N' && id->model[1] == 'E')
1754 || (id->model[0] == 'F' && id->model[1] == 'X'))
1755 bswap = 0;
1756 }
1757 fixstring (id->model, sizeof(id->model), bswap);
1758 fixstring (id->fw_rev, sizeof(id->fw_rev), bswap);
1759 fixstring (id->serial_no, sizeof(id->serial_no), bswap);
1760
1761
1762
1763
1764 if (cmd == WIN_PIDENTIFY) {
1765 #ifdef CONFIG_BLK_DEV_IDECD
1766 byte type = (id->config >> 8) & 0x0f;
1767 #endif
1768 printk("%s: %s, ATAPI,", dev->name, id->model);
1769 #ifdef CONFIG_BLK_DEV_IDECD
1770 if (type == 0 || type == 5)
1771 printk(" CDROM drive\n");
1772 else
1773 printk(" UNKNOWN device\n");
1774 dev->type = cdrom;
1775 dev->present = 1;
1776 #else
1777 printk(unsupported);
1778 #endif
1779 return;
1780 }
1781
1782 dev->type = disk;
1783
1784 if (!dev->present) {
1785 dev->present = 1;
1786 dev->cyl = dev->bios_cyl = id->cyls;
1787 dev->head = dev->bios_head = id->heads;
1788 dev->sect = dev->bios_sect = id->sectors;
1789 }
1790
1791 if ((id->field_valid & 1) && id->cur_cyls && id->cur_heads
1792 && (id->cur_heads <= 16) && id->cur_sectors)
1793 {
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804 dev->cyl = id->cur_cyls;
1805 dev->head = id->cur_heads;
1806 dev->sect = id->cur_sectors;
1807 capacity = dev->cyl * dev->head * dev->sect;
1808
1809
1810 check = (id->cur_capacity0 << 16) | id->cur_capacity1;
1811 if (check == capacity)
1812 *((int *)&id->cur_capacity0) = capacity;
1813 }
1814
1815 if ((!dev->head || dev->head > 16) && id->heads && id->heads <= 16) {
1816 dev->cyl = id->cyls;
1817 dev->head = id->heads;
1818 dev->sect = id->sectors;
1819 }
1820
1821 if (dev->sect == dev->bios_sect && dev->head == dev->bios_head) {
1822 if (dev->cyl > dev->bios_cyl)
1823 dev->bios_cyl = dev->cyl;
1824 }
1825
1826 if ((id->capability & 2) && lba_capacity_is_ok(id)) {
1827 dev->select.b.lba = 1;
1828 capacity = id->lba_capacity;
1829 } else {
1830 capacity = dev->cyl * dev->head * dev->sect;
1831 }
1832
1833 ide_capacity[DEV_HWIF][dev->select.b.drive] = capacity;
1834 printk ("%s: %.40s, %ldMB w/%dKB Cache, %sCHS=%d/%d/%d",
1835 dev->name, id->model, capacity/2048L, id->buf_size/2,
1836 dev->select.b.lba ? "LBA, " : "",
1837 dev->bios_cyl, dev->bios_head, dev->bios_sect);
1838
1839 dev->mult_count = 0;
1840 if (id->max_multsect) {
1841 dev->mult_req = INITIAL_MULT_COUNT;
1842 if (dev->mult_req > id->max_multsect)
1843 dev->mult_req = id->max_multsect;
1844 if (dev->mult_req || ((id->multsect_valid & 1) && id->multsect))
1845 dev->special.b.set_multmode = 1;
1846 printk(", MaxMult=%d", id->max_multsect);
1847 }
1848 printk("\n");
1849 }
1850
1851 static void delay_10ms (void)
1852 {
1853 unsigned long timer = jiffies + 2;
1854 while (timer > jiffies);
1855 }
1856
1857
1858 static int try_to_identify (ide_dev_t *dev, byte cmd)
1859
1860
1861
1862
1863
1864 {
1865 int hd_status, rc;
1866 unsigned long timeout;
1867 #if PROBE_FOR_IRQS
1868 int irqs = 0;
1869 static byte irq_probed[2] = {0,0};
1870 #endif
1871
1872 OUT_BYTE(dev->ctl|2,HD_CMD);
1873 #if PROBE_FOR_IRQS
1874 if (!irq_probed[DEV_HWIF]) {
1875 irqs = probe_irq_on();
1876 OUT_BYTE(dev->ctl,HD_CMD);
1877 }
1878 #endif
1879 delay_10ms();
1880 if ((IN_BYTE(HD_ALTSTATUS,DEV_HWIF) ^ IN_BYTE(HD_STATUS,DEV_HWIF)) & ~INDEX_STAT) {
1881 hd_status = HD_STATUS;
1882 printk("%s: probing with STATUS instead of ALTSTATUS\n", dev->name);
1883 } else
1884 hd_status = HD_ALTSTATUS;
1885 OUT_BYTE(cmd,HD_COMMAND);
1886 timeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
1887 timeout += jiffies;
1888 do {
1889 if (jiffies > timeout) {
1890 #if PROBE_FOR_IRQS
1891 if (!irq_probed[DEV_HWIF])
1892 (void) probe_irq_off(irqs);
1893 #endif
1894 return 1;
1895 }
1896 delay_10ms();
1897 } while (IN_BYTE(hd_status,DEV_HWIF) & BUSY_STAT);
1898 delay_10ms();
1899 if (OK_STAT(GET_STAT(DEV_HWIF),DRQ_STAT,BAD_R_STAT)) {
1900 cli();
1901 do_identify(dev, cmd);
1902 rc = 0;
1903 } else
1904 rc = 2;
1905 #if PROBE_FOR_IRQS
1906 if (!irq_probed[DEV_HWIF]) {
1907 irqs = probe_irq_off(irqs);
1908 if (irqs > 0) {
1909 irq_probed[DEV_HWIF] = 1;
1910 ide_irq[DEV_HWIF] = irqs;
1911 } else
1912 printk("%s: IRQ probe failed (%d)\n", dev->name, irqs);
1913 }
1914 #endif
1915 return rc;
1916 }
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928 static int do_probe (ide_dev_t *dev, byte cmd)
1929
1930
1931
1932
1933
1934
1935
1936 {
1937 int rc;
1938
1939 #ifdef CONFIG_BLK_DEV_IDECD
1940 if (dev->present) {
1941 if ((dev->type == disk) ^ (cmd == WIN_IDENTIFY))
1942 return 4;
1943 }
1944 #endif
1945 #if DEBUG
1946 printk("probing for %s: present=%d, type=%s, probetype=%s\n",
1947 dev->name, dev->present, dev->type ? "cdrom":"disk",
1948 (cmd == WIN_IDENTIFY) ? "ATA" : "ATAPI");
1949 #endif
1950 OUT_BYTE(dev->select.all,HD_CURRENT);
1951 delay_10ms();
1952 if (IN_BYTE(HD_CURRENT,DEV_HWIF) != dev->select.all && !dev->present) {
1953 OUT_BYTE(0xa0,HD_CURRENT);
1954 return 3;
1955 }
1956
1957 if (OK_STAT(GET_STAT(DEV_HWIF),READY_STAT,BUSY_STAT)
1958 || dev->present || cmd == WIN_PIDENTIFY)
1959 {
1960 if ((rc = try_to_identify(dev, cmd)))
1961 rc = try_to_identify(dev, cmd);
1962 if (rc == 1)
1963 printk("%s: no response (status = 0x%02x)\n",
1964 dev->name, GET_STAT(DEV_HWIF));
1965 OUT_BYTE(dev->ctl|2,HD_CMD);
1966 delay_10ms();
1967 (void) GET_STAT(DEV_HWIF);
1968 } else {
1969 rc = 3;
1970 }
1971 if (dev->select.b.drive == 1) {
1972 OUT_BYTE(0xa0,HD_CURRENT);
1973 delay_10ms();
1974 OUT_BYTE(dev->ctl|2,HD_CMD);
1975 delay_10ms();
1976 (void) GET_STAT(DEV_HWIF);
1977 }
1978 return rc;
1979 }
1980
1981 static byte probe_for_drive (ide_dev_t *dev)
1982
1983
1984
1985
1986 {
1987 if (dev->dont_probe)
1988 return dev->present;
1989 if (do_probe(dev, WIN_IDENTIFY) >= 2) {
1990 #ifdef CONFIG_BLK_DEV_IDECD
1991 (void) do_probe(dev, WIN_PIDENTIFY);
1992 #endif
1993 }
1994 if (!dev->present)
1995 return 0;
1996 if (dev->id == NULL) {
1997 if (dev->type == disk) {
1998 printk ("%s: non-IDE device, CHS=%d/%d/%d\n",
1999 dev->name, dev->cyl, dev->head, dev->sect);
2000 }
2001 #ifdef CONFIG_BLK_DEV_IDECD
2002 else if (dev->type == cdrom) {
2003 printk("%s: ATAPI cdrom (?)\n", dev->name);
2004 }
2005 #endif
2006 else {
2007 dev->present = 0;
2008 return 1;
2009 }
2010 }
2011 #ifdef CONFIG_BLK_DEV_IDECD
2012 if (dev->type == cdrom)
2013 cdrom_setup(dev);
2014 #endif
2015 if (dev->type == disk && !dev->select.b.lba) {
2016 if (!dev->head || dev->head > 16) {
2017 printk("%s: cannot handle disk with %d physical heads\n",
2018 dev->name, dev->head);
2019 dev->present = 0;
2020 }
2021 }
2022 return 1;
2023 }
2024
2025 static void probe_for_drives (byte hwif)
2026 {
2027 ide_dev_t *devs = &ide_dev[HWIF][0];
2028
2029 if (check_region(IDE_PORT(HD_DATA,HWIF),8)
2030 || check_region(IDE_PORT(HD_CMD,HWIF),1))
2031 {
2032 if (devs[0].present || devs[1].present)
2033 printk("ERROR: ");
2034 printk("%s: port(s) already in use\n", ide_name[HWIF]);
2035 devs[0].present = 0;
2036 devs[1].present = 0;
2037 } else {
2038 unsigned long flags;
2039 save_flags(flags);
2040 sti();
2041
2042
2043 if (probe_for_drive(&devs[0]) || devs[1].present)
2044 (void) probe_for_drive(&devs[1]);
2045 #if PROBE_FOR_IRQS
2046 (void) probe_irq_off(probe_irq_on());
2047 #endif
2048 if (devs[0].present || devs[1].present) {
2049 request_region(IDE_PORT(HD_DATA,HWIF),8,ide_name[HWIF]);
2050 request_region(IDE_PORT(HD_CMD,HWIF),1,ide_name[HWIF]);
2051 }
2052 restore_flags(flags);
2053 }
2054 }
2055
2056 static int next_drive = 0;
2057
2058 void ide_setup(char *str, int *ints)
2059 {
2060 ide_dev_t *dev;
2061 const char *p[] = {"cyls","heads","sects","wpcom","irq"};
2062 int i, hwif, drive = next_drive++;
2063 #ifdef CONFIG_BLK_DEV_HD
2064 extern void hd_setup(char *, int *);
2065
2066 if (drive < 2) {
2067 hd_setup (str, ints);
2068 return;
2069 }
2070 #endif
2071 hwif = (drive > 1);
2072 printk("%s: ", ide_name[hwif]);
2073 if (drive > 3) {
2074 printk("too many drives defined\n");
2075 return;
2076 }
2077 drive = drive & 1;
2078 printk("%s: ", ide_devname[hwif][drive]);
2079 if (!SUPPORT_TWO_INTERFACES && hwif != HWIF) {
2080 printk(unsupported);
2081 return;
2082 }
2083 dev = &ide_dev[hwif][drive];
2084 if (dev->present)
2085 printk("(redefined) ");
2086 if (ints[0] == 0) {
2087 #if SUPPORT_DTC2278
2088 if (!strcmp(str,"dtc2278")) {
2089 printk("%s\n",str);
2090 probe_dtc2278 = 1;
2091 return;
2092 }
2093 #endif
2094 #if SUPPORT_SERIALIZE
2095 if (!strcmp(str,"serialize") || !strcmp(str,"cmd")) {
2096 printk("%s\n",str);
2097 single_threaded = 1;
2098 return;
2099 }
2100 #endif
2101 if (!strcmp(str,"noprobe")) {
2102 printk("%s\n",str);
2103 dev->dont_probe = 1;
2104 return;
2105 }
2106 #ifdef CONFIG_BLK_DEV_IDECD
2107 if (!strcmp(str,"cdrom")) {
2108 printk("cdrom\n");
2109 dev->present = 1;
2110 dev->type = cdrom;
2111 return;
2112 }
2113 #endif
2114 }
2115 if (ints[0] < 3 || ints[0] > 5) {
2116 printk("bad parms, expected: cyls,heads,sects[,wpcom[,irq]]\n");
2117 } else {
2118 for (i=0; i++ < ints[0];)
2119 printk("%s=%d%c",p[i-1],ints[i],i<ints[0]?',':'\n');
2120 dev->type = disk;
2121 dev->cyl = dev->bios_cyl = ints[1];
2122 dev->head = dev->bios_head = ints[2];
2123 dev->ctl = (ints[2] > 8 ? 8 : 0);
2124 dev->sect = dev->bios_sect = ints[3];
2125 dev->wpcom = (ints[0] >= 4) ? ints[4] : 0;
2126 if (ints[0] >= 5)
2127 ide_irq[HWIF] = ints[5];
2128 ide_capacity[HWIF][drive] = BIOS_SECTORS(dev);
2129 dev->present = 1;
2130 }
2131 }
2132
2133 void hda_setup(char *str, int *ints)
2134 {
2135 next_drive = 0;
2136 ide_setup (str, ints);
2137 }
2138
2139 void hdb_setup(char *str, int *ints)
2140 {
2141 next_drive = 1;
2142 ide_setup (str, ints);
2143 }
2144
2145 void hdc_setup(char *str, int *ints)
2146 {
2147 next_drive = 2;
2148 ide_setup (str, ints);
2149 }
2150
2151 void hdd_setup(char *str, int *ints)
2152 {
2153 next_drive = 3;
2154 ide_setup (str, ints);
2155 }
2156
2157 #ifndef CONFIG_BLK_DEV_HD
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170 extern struct drive_info_struct drive_info;
2171 static void probe_cmos_for_drives (void)
2172 {
2173 byte drive, cmos_disks, *BIOS = (byte *) &drive_info;
2174
2175 outb_p(0x12,0x70);
2176 cmos_disks = inb_p(0x71);
2177
2178 for (drive = 0; drive < MAX_DRIVES; drive++) {
2179 ide_dev_t *dev = &ide_dev[0][drive];
2180 if ((cmos_disks & (0xf0 >> (drive*4))) && !dev->present) {
2181 dev->cyl = dev->bios_cyl = *(unsigned short *)BIOS;
2182 dev->head = dev->bios_head = * (BIOS+2);
2183 dev->sect = dev->bios_sect = * (BIOS+14);
2184 dev->wpcom = (*(unsigned short *)(BIOS+5))>>2;
2185 dev->ctl = *(BIOS+8);
2186 dev->wpcom = 0;
2187 dev->type = disk;
2188 dev->present = 1;
2189 ide_capacity[0][drive] = BIOS_SECTORS(dev);
2190 }
2191 BIOS += 16;
2192 }
2193 }
2194 #endif
2195
2196 static void init_ide_data (byte hwif)
2197 {
2198 int drive;
2199
2200 for (drive = 0; drive < (MAX_DRIVES<<PARTN_BITS); drive++)
2201 ide_blksizes[hwif][drive] = 1024;
2202 blksize_size[ide_major[hwif]] = ide_blksizes[hwif];
2203
2204
2205 for (drive = 0; drive < MAX_DRIVES; drive++) {
2206 ide_dev_t *dev = &ide_dev[hwif][drive];
2207 dev->select.all = (drive<<4)|0xa0;
2208 dev->hwif = hwif;
2209 dev->unmask = 0;
2210 dev->busy = 0;
2211 dev->mult_count = 0;
2212 dev->mult_req = 0;
2213 dev->usage = 0;
2214 dev->vlb_32bit = 0;
2215 dev->vlb_sync = 0;
2216 dev->id = NULL;
2217 dev->ctl = 0x08;
2218 dev->wqueue = NULL;
2219 dev->special.all = 0;
2220 dev->special.b.recalibrate = 1;
2221 dev->special.b.set_geometry = 1;
2222 dev->keep_settings = 0;
2223 ide_hd[hwif][drive<<PARTN_BITS].start_sect = 0;
2224 dev->name = ide_devname[hwif][drive];
2225 }
2226 }
2227
2228
2229
2230
2231
2232
2233
2234 static byte setup_irq (byte hwif)
2235 {
2236 static byte rc = 0;
2237 unsigned long flags;
2238 const char *msg = "", *primary_secondary[] = {"primary", "secondary"};
2239 void (*handler)(int, struct pt_regs *) = HWIF ? &ide1_intr : &ide0_intr;
2240
2241 #if SUPPORT_SHARING_IRQ
2242 if (sharing_single_irq) {
2243 if (HWIF != 0 && !rc) {
2244 msg = " (shared with ide0)";
2245 goto done;
2246 }
2247 handler = &ide_shared_intr;
2248 }
2249 #if SUPPORT_SERIALIZE
2250 else if (single_threaded) {
2251 handler = &ide_seq_intr;
2252 if (HWIF != 0)
2253 msg = " (single-threaded with ide0)";
2254 }
2255 #endif
2256 #endif
2257 save_flags(flags);
2258 cli();
2259 if ((rc = request_irq(ide_irq[HWIF],handler,SA_INTERRUPT,ide_name[HWIF])))
2260 msg = ": FAILED! unable to allocate IRQ";
2261 restore_flags(flags);
2262 #if SUPPORT_SHARING_IRQ
2263 done:
2264 #endif
2265 printk("%s: %s interface on irq %d%s\n",
2266 ide_name[HWIF], primary_secondary[HWIF], ide_irq[HWIF], msg);
2267 return rc;
2268 }
2269
2270 static void ide_geninit(byte hwif)
2271 {
2272 static int drive;
2273
2274 for (drive = 0; drive < MAX_DRIVES; drive++) {
2275 ide_dev_t *dev = &ide_dev[HWIF][drive];
2276 if (dev->present) {
2277 ide_hd[HWIF][drive<<PARTN_BITS].nr_sects = ide_capacity[HWIF][drive];
2278
2279 if (dev->type == cdrom)
2280 ide_hd[HWIF][drive<<PARTN_BITS].start_sect = -1;
2281 }
2282 }
2283 }
2284
2285 static void ide0_geninit(void)
2286 {
2287 ide_geninit(0);
2288 }
2289
2290 static void ide1_geninit(void)
2291 {
2292 ide_geninit(1);
2293 }
2294
2295 static struct file_operations ide_fops = {
2296 NULL,
2297 block_read,
2298 block_write,
2299 NULL,
2300 NULL,
2301 ide_ioctl,
2302 NULL,
2303 ide_open,
2304 ide_release,
2305 block_fsync
2306 #ifdef CONFIG_BLK_DEV_IDECD
2307 ,NULL,
2308 ide_check_media_change,
2309 NULL
2310 #endif CONFIG_BLK_DEV_IDECD
2311 };
2312
2313
2314 #if SUPPORT_DTC2278
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326 static void sub22 (char b, char c)
2327 {
2328 int i;
2329
2330 for(i = 0; i < 3; i++) {
2331 __inb(0x3f6);
2332 outb_p(b,0xb0);
2333 __inb(0x3f6);
2334 outb_p(c,0xb4);
2335 __inb(0x3f6);
2336 if(__inb(0xb4) == c) {
2337 outb_p(7,0xb0);
2338 __inb(0x3f6);
2339 return;
2340 }
2341 }
2342 }
2343
2344 static void try_to_init_dtc2278 (void)
2345 {
2346
2347 cli();
2348 sub22(1,0xc3);
2349 sub22(0,0xa0);
2350 sti();
2351
2352
2353
2354 outb_p(4,0xb0);
2355 __inb(0x3f6);
2356 outb_p(0x20,0xb4);
2357 __inb(0x3f6);
2358 }
2359 #endif
2360
2361
2362
2363
2364 unsigned long ide_init (unsigned long mem_start, unsigned long mem_end)
2365 {
2366 byte hwif;
2367
2368 #if SUPPORT_DTC2278
2369 if (probe_dtc2278)
2370 try_to_init_dtc2278();
2371 #endif
2372
2373 for (hwif = 0; hwif < 2; hwif++) {
2374 init_ide_data (hwif);
2375 if (SUPPORT_TWO_INTERFACES || hwif == HWIF) {
2376 if (hwif == 0)
2377 #ifdef CONFIG_BLK_DEV_HD
2378 continue;
2379 #else
2380 probe_cmos_for_drives ();
2381 #endif
2382 probe_mem_start = (mem_start + 3uL) & ~3uL;
2383 probe_for_drives (hwif);
2384 mem_start = probe_mem_start;
2385 }
2386 }
2387
2388
2389 ide_gendisk[0].nr_real = ide_dev[0][0].present + ide_dev[0][1].present;
2390 ide_gendisk[1].nr_real = ide_dev[1][0].present + ide_dev[1][1].present;
2391 if (ide_gendisk[1].nr_real && (ide_irq[0] == ide_irq[1])) {
2392 if (!ide_gendisk[0].nr_real) {
2393 ide_irq[0] = 0;
2394 } else {
2395 #if SUPPORT_SHARING_IRQ
2396 sharing_single_irq = 1;
2397 single_threaded = 1;
2398 #else
2399 printk("%s: ide irq-sharing%s", ide_name[1], unsupported);
2400 return mem_start;
2401 #endif
2402 }
2403 }
2404 #ifdef CONFIG_BLK_DEV_HD
2405 #if SUPPORT_SHARING_IRQ
2406 if (ide_irq[1] == 14 || sharing_single_irq) {
2407 #else
2408 if (ide_irq[1] == 14) {
2409 #endif
2410 printk("%s: irq-sharing not possible with old harddisk driver (hd.c)\n", ide_name[1]);
2411 return mem_start;
2412 }
2413 #endif
2414
2415 for (hwif = 2; hwif-- > 0;) {
2416 if (ide_gendisk[hwif].nr_real != 0 && !setup_irq(hwif)) {
2417 const char *name = ide_name[HWIF];
2418 unsigned int major = ide_major[HWIF];
2419 if (register_blkdev(major, name, &ide_fops)) {
2420 printk("%s: unable to get major number %d\n", name, major);
2421 } else {
2422 timer_table[ide_timer[HWIF]].fn
2423 = HWIF ? ide1_timer_expiry : ide0_timer_expiry;
2424 #if SUPPORT_SHARING_IRQ
2425 if (single_threaded)
2426 blk_dev[major].request_fn = &do_shared_request;
2427 else
2428 #endif
2429 blk_dev[major].request_fn =
2430 HWIF ? &do_ide1_request : &do_ide0_request;
2431 read_ahead[major] = 8;
2432 ide_gendisk[HWIF].next = gendisk_head;
2433 gendisk_head = &ide_gendisk[HWIF];
2434 }
2435 }
2436 }
2437 return mem_start;
2438 }