This source file includes following definitions.
- read_timer
- set_recovery_timer
- init_hwif_data
- init_ide_data
- do_vlb_sync
- ide_input_data
- ide_output_data
- ide_set_handler
- lba_capacity_is_ok
- current_capacity
- ide_geninit
- init_gendisk
- atapi_reset_pollfunc
- reset_pollfunc
- do_reset1
- ide_do_reset
- ide_end_drive_cmd
- ide_dump_status
- try_to_flush_leftover_data
- ide_error
- read_intr
- write_intr
- ide_multwrite
- multwrite_intr
- ide_cmd
- set_multmode_intr
- set_geometry_intr
- recal_intr
- drive_cmd_intr
- do_special
- ide_wait_stat
- do_rw_disk
- execute_drive_cmd
- do_request
- ide_do_request
- do_hwgroup_request
- do_ide0_request
- do_ide1_request
- do_ide2_request
- do_ide3_request
- timer_expiry
- unexpected_intr
- ide_intr
- get_info_ptr
- ide_init_drive_cmd
- ide_do_drive_cmd
- ide_open
- ide_release
- revalidate_disk
- write_fs_long
- ide_ioctl
- ide_check_media_change
- ide_fixstring
- do_identify
- delay_10ms
- try_to_identify
- do_probe
- probe_for_drive
- probe_hwif
- stridx
- match_parm
- ide_setup
- ide_xlate_1024
- probe_cmos_for_drives
- init_irq
- ide_probe_pci
- probe_for_hwifs
- hwif_init
- ide_init
- ide_register
- ide_unregister
1
2
3
4
5
6 #define _IDE_C
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231 #undef REALLY_SLOW_IO
232
233 #include <linux/config.h>
234 #include <linux/types.h>
235 #include <linux/string.h>
236 #include <linux/kernel.h>
237 #include <linux/delay.h>
238 #include <linux/timer.h>
239 #include <linux/mm.h>
240 #include <linux/ioport.h>
241 #include <linux/interrupt.h>
242 #include <linux/major.h>
243 #include <linux/blkdev.h>
244 #include <linux/errno.h>
245 #include <linux/hdreg.h>
246 #include <linux/genhd.h>
247 #include <linux/malloc.h>
248
249 #include <asm/byteorder.h>
250 #include <asm/irq.h>
251 #include <asm/segment.h>
252 #include <asm/io.h>
253
254 #ifdef CONFIG_PCI
255 #include <linux/bios32.h>
256 #include <linux/pci.h>
257 #endif
258
259 #include "ide.h"
260 #include "ide_modes.h"
261
262 #ifdef CONFIG_BLK_DEV_PROMISE
263 #include "promise.h"
264 #define IS_PROMISE_DRIVE (HWIF(drive)->chipset == ide_promise)
265 #else
266 #define IS_PROMISE_DRIVE (0)
267 #endif
268
269 static const byte ide_hwif_to_major[MAX_HWIFS] = {IDE0_MAJOR, IDE1_MAJOR, IDE2_MAJOR, IDE3_MAJOR};
270
271 static const unsigned short default_io_base[MAX_HWIFS] = {0x1f0, 0x170, 0x1e8, 0x168};
272 static const byte default_irqs[MAX_HWIFS] = {14, 15, 11, 10};
273
274 #if (DISK_RECOVERY_TIME > 0)
275
276
277
278
279 static unsigned long read_timer(void)
280 {
281 unsigned long t, flags;
282 int i;
283
284 save_flags(flags);
285 cli();
286 t = jiffies * 11932;
287 outb_p(0, 0x43);
288 i = inb_p(0x40);
289 i |= inb(0x40) << 8;
290 restore_flags(flags);
291 return (t - i);
292 }
293
294 static void set_recovery_timer (ide_hwif_t *hwif)
295 {
296 hwif->last_time = read_timer();
297 }
298 #define SET_RECOVERY_TIMER(drive) set_recovery_timer (drive)
299
300 #else
301
302 #define SET_RECOVERY_TIMER(drive)
303
304 #endif
305
306
307
308
309
310 static void init_hwif_data (unsigned int index)
311 {
312 byte *p;
313 unsigned int unit;
314 ide_hwif_t *hwif = &ide_hwifs[index];
315
316
317 p = ((byte *) hwif) + sizeof(ide_hwif_t);
318 do {
319 *--p = 0;
320 } while (p > (byte *) hwif);
321
322
323 hwif->index = index;
324 hwif->noprobe = (index > 1);
325 hwif->io_base = default_io_base[index];
326 hwif->ctl_port = hwif->io_base ? hwif->io_base+0x206 : 0x000;
327 #ifdef CONFIG_BLK_DEV_HD
328 if (hwif->io_base == HD_DATA)
329 hwif->noprobe = 1;
330 #endif
331 hwif->major = ide_hwif_to_major[index];
332 hwif->name[0] = 'i';
333 hwif->name[1] = 'd';
334 hwif->name[2] = 'e';
335 hwif->name[3] = '0' + index;
336 #ifdef CONFIG_BLK_DEV_IDETAPE
337 hwif->tape_drive = NULL;
338 #endif
339 for (unit = 0; unit < MAX_DRIVES; ++unit) {
340 ide_drive_t *drive = &hwif->drives[unit];
341
342 drive->select.all = (unit<<4)|0xa0;
343 drive->hwif = hwif;
344 drive->ctl = 0x08;
345 drive->ready_stat = READY_STAT;
346 drive->bad_wstat = BAD_W_STAT;
347 drive->special.b.recalibrate = 1;
348 drive->special.b.set_geometry = 1;
349 drive->name[0] = 'h';
350 drive->name[1] = 'd';
351 drive->name[2] = 'a' + (index * MAX_DRIVES) + unit;
352 }
353 }
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369 #define MAGIC_COOKIE 0x12345678
370 static void init_ide_data (void)
371 {
372 unsigned int index;
373 static unsigned long magic_cookie = MAGIC_COOKIE;
374
375 if (magic_cookie != MAGIC_COOKIE)
376 return;
377 magic_cookie = 0;
378
379 for (index = 0; index < MAX_HWIFS; ++index)
380 init_hwif_data(index);
381 }
382
383 #if SUPPORT_VLB_SYNC
384
385
386
387
388
389
390
391 static inline void do_vlb_sync (unsigned short port) {
392 (void) inb (port);
393 (void) inb (port);
394 (void) inb (port);
395 }
396 #endif
397
398
399
400
401 void ide_input_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
402 {
403 unsigned short io_base = HWIF(drive)->io_base;
404 unsigned short data_reg = io_base+IDE_DATA_OFFSET;
405 byte io_32bit = drive->io_32bit;
406
407 if (io_32bit) {
408 #if SUPPORT_VLB_SYNC
409 if (io_32bit & 2) {
410 cli();
411 do_vlb_sync(io_base+IDE_NSECTOR_OFFSET);
412 insl(data_reg, buffer, wcount);
413 if (drive->unmask)
414 sti();
415 } else
416 #endif
417 insl(data_reg, buffer, wcount);
418 } else
419 insw(data_reg, buffer, wcount<<1);
420 }
421
422
423
424
425 void ide_output_data (ide_drive_t *drive, void *buffer, unsigned int wcount)
426 {
427 unsigned short io_base = HWIF(drive)->io_base;
428 unsigned short data_reg = io_base+IDE_DATA_OFFSET;
429 byte io_32bit = drive->io_32bit;
430
431 if (io_32bit) {
432 #if SUPPORT_VLB_SYNC
433 if (io_32bit & 2) {
434 cli();
435 do_vlb_sync(io_base+IDE_NSECTOR_OFFSET);
436 outsl(data_reg, buffer, wcount);
437 if (drive->unmask)
438 sti();
439 } else
440 #endif
441 outsl(data_reg, buffer, wcount);
442 } else
443 outsw(data_reg, buffer, wcount<<1);
444 }
445
446
447
448
449
450
451
452
453 void ide_set_handler (ide_drive_t *drive, ide_handler_t *handler, unsigned int timeout)
454 {
455 ide_hwgroup_t *hwgroup = HWGROUP(drive);
456 #ifdef DEBUG
457 if (hwgroup->handler != NULL) {
458 printk("%s: ide_set_handler: handler not null; old=%p, new=%p\n",
459 drive->name, hwgroup->handler, handler);
460 }
461 #endif
462 hwgroup->handler = handler;
463 hwgroup->timer.expires = jiffies + timeout;
464 add_timer(&(hwgroup->timer));
465 }
466
467
468
469
470
471
472
473
474 static int lba_capacity_is_ok (struct hd_driveid *id)
475 {
476 unsigned long lba_sects = id->lba_capacity;
477 unsigned long chs_sects = id->cyls * id->heads * id->sectors;
478 unsigned long _10_percent = chs_sects / 10;
479
480
481 if ((lba_sects - chs_sects) < _10_percent)
482 return 1;
483
484
485 lba_sects = (lba_sects << 16) | (lba_sects >> 16);
486 if ((lba_sects - chs_sects) < _10_percent) {
487 id->lba_capacity = lba_sects;
488 return 1;
489 }
490 return 0;
491 }
492
493
494
495
496
497 static unsigned long current_capacity (ide_drive_t *drive)
498 {
499 struct hd_driveid *id = drive->id;
500 unsigned long capacity = drive->cyl * drive->head * drive->sect;
501
502 if (!drive->present)
503 return 0;
504 if (drive->media != ide_disk)
505 return 0x7fffffff;
506 if (!IS_PROMISE_DRIVE) {
507 drive->select.b.lba = 0;
508
509 if (id != NULL && (id->capability & 2) && lba_capacity_is_ok(id)) {
510 if (id->lba_capacity >= capacity) {
511 capacity = id->lba_capacity;
512 drive->select.b.lba = 1;
513 }
514 }
515 }
516 return (capacity - drive->sect0);
517 }
518
519
520
521
522
523 static void ide_geninit (struct gendisk *gd)
524 {
525 unsigned int unit;
526 ide_hwif_t *hwif = gd->real_devices;
527
528 for (unit = 0; unit < gd->nr_real; ++unit) {
529 ide_drive_t *drive = &hwif->drives[unit];
530 #ifdef CONFIG_BLK_DEV_IDECD
531 if (drive->present && drive->media == ide_cdrom)
532 ide_cdrom_setup(drive);
533 #endif
534 #ifdef CONFIG_BLK_DEV_IDETAPE
535 if (drive->present && drive->media == ide_tape)
536 idetape_setup(drive);
537 #endif
538 drive->part[0].nr_sects = current_capacity(drive);
539 if (!drive->present || drive->media != ide_disk) {
540 drive->part[0].start_sect = -1;
541 }
542 }
543 }
544
545
546
547
548
549
550
551 static void init_gendisk (ide_hwif_t *hwif)
552 {
553 struct gendisk *gd, **gdp;
554 unsigned int unit, units, minors;
555 int *bs;
556
557
558 for (units = MAX_DRIVES; units > 0; --units) {
559 if (hwif->drives[units-1].present)
560 break;
561 }
562 minors = units * (1<<PARTN_BITS);
563 gd = kmalloc (sizeof(struct gendisk), GFP_KERNEL);
564 gd->sizes = kmalloc (minors * sizeof(int), GFP_KERNEL);
565 gd->part = kmalloc (minors * sizeof(struct hd_struct), GFP_KERNEL);
566 bs = kmalloc (minors*sizeof(int), GFP_KERNEL);
567
568
569 blksize_size[hwif->major] = bs;
570 for (unit = 0; unit < minors; ++unit)
571 *bs++ = BLOCK_SIZE;
572
573 for (unit = 0; unit < units; ++unit)
574 hwif->drives[unit].part = &gd->part[unit << PARTN_BITS];
575
576 gd->major = hwif->major;
577 gd->major_name = IDE_MAJOR_NAME;
578 gd->minor_shift = PARTN_BITS;
579 gd->max_p = 1<<PARTN_BITS;
580 gd->max_nr = units;
581 gd->nr_real = units;
582 gd->init = ide_geninit;
583 gd->real_devices= hwif;
584 gd->next = NULL;
585
586 for (gdp = &gendisk_head; *gdp; gdp = &((*gdp)->next)) ;
587 hwif->gd = *gdp = gd;
588 }
589
590 static void do_reset1 (ide_drive_t *, int);
591
592 #ifdef CONFIG_BLK_DEV_IDEATAPI
593
594
595
596
597
598
599 static void atapi_reset_pollfunc (ide_drive_t *drive)
600 {
601 ide_hwgroup_t *hwgroup = HWGROUP(drive);
602 byte stat;
603
604 OUT_BYTE (drive->select.all, IDE_SELECT_REG);
605 udelay (10);
606
607 if (OK_STAT(stat=GET_STAT(), 0, BUSY_STAT)) {
608 printk("%s: ATAPI reset complete\n", drive->name);
609 } else {
610 if (jiffies < hwgroup->poll_timeout) {
611 ide_set_handler (drive, &atapi_reset_pollfunc, HZ/20);
612 return;
613 }
614 hwgroup->poll_timeout = 0;
615 printk("%s: ATAPI reset timed-out, status=0x%02x\n", drive->name, stat);
616 do_reset1 (drive, 1);
617 }
618 hwgroup->poll_timeout = 0;
619 }
620 #endif
621
622
623
624
625
626
627
628 static void reset_pollfunc (ide_drive_t *drive)
629 {
630 ide_hwgroup_t *hwgroup = HWGROUP(drive);
631 ide_hwif_t *hwif = HWIF(drive);
632 byte tmp;
633
634 if (!OK_STAT(tmp=GET_STAT(), 0, BUSY_STAT)) {
635 if (jiffies < hwgroup->poll_timeout) {
636 ide_set_handler (drive, &reset_pollfunc, HZ/20);
637 return;
638 }
639 printk("%s: reset timed-out, status=0x%02x\n", hwif->name, tmp);
640 } else {
641 printk("%s: reset: ", hwif->name);
642 if ((tmp = GET_ERR()) == 1)
643 printk("success\n");
644 else {
645 #if FANCY_STATUS_DUMPS
646 printk("master: ");
647 switch (tmp & 0x7f) {
648 case 1: printk("passed");
649 break;
650 case 2: printk("formatter device error");
651 break;
652 case 3: printk("sector buffer error");
653 break;
654 case 4: printk("ECC circuitry error");
655 break;
656 case 5: printk("controlling MPU error");
657 break;
658 default:printk("error (0x%02x?)", tmp);
659 }
660 if (tmp & 0x80)
661 printk("; slave: failed");
662 printk("\n");
663 #else
664 printk("failed\n");
665 #endif
666 }
667 }
668 hwgroup->poll_timeout = 0;
669 }
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686 static void do_reset1 (ide_drive_t *drive, int do_not_try_atapi)
687 {
688 unsigned int unit;
689 unsigned long flags;
690 ide_hwif_t *hwif = HWIF(drive);
691 ide_hwgroup_t *hwgroup = HWGROUP(drive);
692
693 save_flags(flags);
694 cli();
695
696 #ifdef CONFIG_BLK_DEV_IDEATAPI
697
698 if (drive->media != ide_disk) {
699 if (!do_not_try_atapi) {
700 if (!drive->keep_settings)
701 drive->unmask = 0;
702 OUT_BYTE (drive->select.all, IDE_SELECT_REG);
703 udelay (20);
704 OUT_BYTE (WIN_SRST, IDE_COMMAND_REG);
705 hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
706 ide_set_handler (drive, &atapi_reset_pollfunc, HZ/20);
707 restore_flags (flags);
708 return;
709 }
710 }
711 #endif
712
713
714
715
716
717 for (unit = 0; unit < MAX_DRIVES; ++unit) {
718 ide_drive_t *rdrive = &hwif->drives[unit];
719 rdrive->special.all = 0;
720 rdrive->special.b.set_geometry = 1;
721 rdrive->special.b.recalibrate = 1;
722 if (OK_TO_RESET_CONTROLLER)
723 rdrive->mult_count = 0;
724 if (!rdrive->keep_settings) {
725 rdrive->mult_req = 0;
726 rdrive->unmask = 0;
727 if (rdrive->using_dma) {
728 rdrive->using_dma = 0;
729 printk("%s: disabled DMA\n", rdrive->name);
730 }
731 }
732 if (rdrive->mult_req != rdrive->mult_count)
733 rdrive->special.b.set_multmode = 1;
734 }
735
736 #if OK_TO_RESET_CONTROLLER
737
738
739
740
741
742
743
744
745 OUT_BYTE(drive->ctl|6,IDE_CONTROL_REG);
746 udelay(5);
747 OUT_BYTE(drive->ctl|2,IDE_CONTROL_REG);
748 hwgroup->poll_timeout = jiffies + WAIT_WORSTCASE;
749 ide_set_handler (drive, &reset_pollfunc, HZ/20);
750 #endif
751
752 restore_flags (flags);
753 }
754
755
756
757
758 void ide_do_reset (ide_drive_t *drive)
759 {
760 do_reset1 (drive, 0);
761 #ifdef CONFIG_BLK_DEV_IDETAPE
762 if (drive->media == ide_tape)
763 drive->tape.reset_issued=1;
764 #endif
765 }
766
767
768
769
770 void ide_end_drive_cmd (ide_drive_t *drive, byte stat, byte err)
771 {
772 unsigned long flags;
773 struct request *rq = HWGROUP(drive)->rq;
774
775 if (rq->cmd == IDE_DRIVE_CMD) {
776 byte *args = (byte *) rq->buffer;
777 rq->errors = !OK_STAT(stat,READY_STAT,BAD_STAT);
778 if (args) {
779 args[0] = stat;
780 args[1] = err;
781 args[2] = IN_BYTE(IDE_NSECTOR_REG);
782 }
783 }
784 save_flags(flags);
785 cli();
786 blk_dev[MAJOR(rq->rq_dev)].current_request = rq->next;
787 HWGROUP(drive)->rq = NULL;
788 rq->rq_status = RQ_INACTIVE;
789 if (rq->sem != NULL)
790 up(rq->sem);
791 restore_flags(flags);
792 }
793
794
795
796
797 byte ide_dump_status (ide_drive_t *drive, const char *msg, byte stat)
798 {
799 unsigned long flags;
800 byte err = 0;
801
802 save_flags (flags);
803 sti();
804 printk("%s: %s: status=0x%02x", drive->name, msg, stat);
805 #if FANCY_STATUS_DUMPS
806 if (drive->media == ide_disk) {
807 printk(" { ");
808 if (stat & BUSY_STAT)
809 printk("Busy ");
810 else {
811 if (stat & READY_STAT) printk("DriveReady ");
812 if (stat & WRERR_STAT) printk("DeviceFault ");
813 if (stat & SEEK_STAT) printk("SeekComplete ");
814 if (stat & DRQ_STAT) printk("DataRequest ");
815 if (stat & ECC_STAT) printk("CorrectedError ");
816 if (stat & INDEX_STAT) printk("Index ");
817 if (stat & ERR_STAT) printk("Error ");
818 }
819 printk("}");
820 }
821 #endif
822 printk("\n");
823 if ((stat & (BUSY_STAT|ERR_STAT)) == ERR_STAT) {
824 err = GET_ERR();
825 printk("%s: %s: error=0x%02x", drive->name, msg, err);
826 #if FANCY_STATUS_DUMPS
827 if (drive->media == ide_disk) {
828 printk(" { ");
829 if (err & BBD_ERR) printk("BadSector ");
830 if (err & ECC_ERR) printk("UncorrectableError ");
831 if (err & ID_ERR) printk("SectorIdNotFound ");
832 if (err & ABRT_ERR) printk("DriveStatusError ");
833 if (err & TRK0_ERR) printk("TrackZeroNotFound ");
834 if (err & MARK_ERR) printk("AddrMarkNotFound ");
835 printk("}");
836 if (err & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
837 byte cur = IN_BYTE(IDE_SELECT_REG);
838 if (cur & 0x40) {
839 printk(", LBAsect=%ld", (unsigned long)
840 ((cur&0xf)<<24)
841 |(IN_BYTE(IDE_HCYL_REG)<<16)
842 |(IN_BYTE(IDE_LCYL_REG)<<8)
843 | IN_BYTE(IDE_SECTOR_REG));
844 } else {
845 printk(", CHS=%d/%d/%d",
846 (IN_BYTE(IDE_HCYL_REG)<<8) +
847 IN_BYTE(IDE_LCYL_REG),
848 cur & 0xf,
849 IN_BYTE(IDE_SECTOR_REG));
850 }
851 if (HWGROUP(drive)->rq)
852 printk(", sector=%ld", HWGROUP(drive)->rq->sector);
853 }
854 }
855 #endif
856 printk("\n");
857 }
858 restore_flags (flags);
859 return err;
860 }
861
862
863
864
865
866
867
868
869 static void try_to_flush_leftover_data (ide_drive_t *drive)
870 {
871 int i = (drive->mult_count ? drive->mult_count : 1) * SECTOR_WORDS;
872
873 while (i > 0) {
874 unsigned long buffer[16];
875 unsigned int wcount = (i > 16) ? 16 : i;
876 i -= wcount;
877 ide_input_data (drive, buffer, wcount);
878 }
879 }
880
881
882
883
884 void ide_error (ide_drive_t *drive, const char *msg, byte stat)
885 {
886 struct request *rq;
887 byte err;
888
889 err = ide_dump_status(drive, msg, stat);
890 if ((rq = HWGROUP(drive)->rq) == NULL || drive == NULL)
891 return;
892
893 if (rq->cmd == IDE_DRIVE_CMD) {
894 rq->errors = 1;
895 ide_end_drive_cmd(drive, stat, err);
896 return;
897 }
898 if (stat & BUSY_STAT) {
899 rq->errors |= ERROR_RESET;
900 } else {
901 if (drive->media == ide_disk && (stat & ERR_STAT)) {
902
903 if (err & (BBD_ERR | ECC_ERR))
904 rq->errors = ERROR_MAX;
905 else if (err & TRK0_ERR)
906 rq->errors |= ERROR_RECAL;
907 }
908 if ((stat & DRQ_STAT) && rq->cmd != WRITE)
909 try_to_flush_leftover_data(drive);
910 }
911 if (GET_STAT() & (BUSY_STAT|DRQ_STAT))
912 rq->errors |= ERROR_RESET;
913
914 if (rq->errors >= ERROR_MAX) {
915 #ifdef CONFIG_BLK_DEV_IDETAPE
916 if (drive->media == ide_tape) {
917 rq->errors = 0;
918 idetape_end_request(0, HWGROUP(drive));
919 }
920 else
921 #endif
922 ide_end_request(0, HWGROUP(drive));
923 }
924 else {
925 if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
926 ++rq->errors;
927 ide_do_reset(drive);
928 return;
929 } else if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
930 drive->special.b.recalibrate = 1;
931 ++rq->errors;
932 }
933 }
934
935
936
937
938 static void read_intr (ide_drive_t *drive)
939 {
940 byte stat;
941 int i;
942 unsigned int msect, nsect;
943 struct request *rq;
944
945 if (!OK_STAT(stat=GET_STAT(),DATA_READY,BAD_R_STAT)) {
946 ide_error(drive, "read_intr", stat);
947 return;
948 }
949 msect = drive->mult_count;
950 read_next:
951 rq = HWGROUP(drive)->rq;
952 if (msect) {
953 if ((nsect = rq->current_nr_sectors) > msect)
954 nsect = msect;
955 msect -= nsect;
956 } else
957 nsect = 1;
958 ide_input_data(drive, rq->buffer, nsect * SECTOR_WORDS);
959 #ifdef DEBUG
960 printk("%s: read: sectors(%ld-%ld), buffer=0x%08lx, remaining=%ld\n",
961 drive->name, rq->sector, rq->sector+nsect-1,
962 (unsigned long) rq->buffer+(nsect<<9), rq->nr_sectors-nsect);
963 #endif
964 rq->sector += nsect;
965 rq->buffer += nsect<<9;
966 rq->errors = 0;
967 i = (rq->nr_sectors -= nsect);
968 if ((rq->current_nr_sectors -= nsect) <= 0)
969 ide_end_request(1, HWGROUP(drive));
970 if (i > 0) {
971 if (msect)
972 goto read_next;
973 ide_set_handler (drive, &read_intr, WAIT_CMD);
974 }
975 }
976
977
978
979
980 static void write_intr (ide_drive_t *drive)
981 {
982 byte stat;
983 int i;
984 ide_hwgroup_t *hwgroup = HWGROUP(drive);
985 struct request *rq = hwgroup->rq;
986
987 if (OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
988 #ifdef DEBUG
989 printk("%s: write: sector %ld, buffer=0x%08lx, remaining=%ld\n",
990 drive->name, rq->sector, (unsigned long) rq->buffer,
991 rq->nr_sectors-1);
992 #endif
993 if ((rq->nr_sectors == 1) ^ ((stat & DRQ_STAT) != 0)) {
994 rq->sector++;
995 rq->buffer += 512;
996 rq->errors = 0;
997 i = --rq->nr_sectors;
998 --rq->current_nr_sectors;
999 if (rq->current_nr_sectors <= 0)
1000 ide_end_request(1, hwgroup);
1001 if (i > 0) {
1002 ide_output_data (drive, rq->buffer, SECTOR_WORDS);
1003 ide_set_handler (drive, &write_intr, WAIT_CMD);
1004 }
1005 return;
1006 }
1007 }
1008 ide_error(drive, "write_intr", stat);
1009 }
1010
1011
1012
1013
1014
1015 void ide_multwrite (ide_drive_t *drive, unsigned int mcount)
1016 {
1017 struct request *rq = &HWGROUP(drive)->wrq;
1018
1019 do {
1020 unsigned int nsect = rq->current_nr_sectors;
1021 if (nsect > mcount)
1022 nsect = mcount;
1023 mcount -= nsect;
1024
1025 ide_output_data(drive, rq->buffer, nsect<<7);
1026 #ifdef DEBUG
1027 printk("%s: multwrite: sector %ld, buffer=0x%08lx, count=%d, remaining=%ld\n",
1028 drive->name, rq->sector, (unsigned long) rq->buffer,
1029 nsect, rq->nr_sectors - nsect);
1030 #endif
1031 if ((rq->nr_sectors -= nsect) <= 0)
1032 break;
1033 if ((rq->current_nr_sectors -= nsect) == 0) {
1034 if ((rq->bh = rq->bh->b_reqnext) != NULL) {
1035 rq->current_nr_sectors = rq->bh->b_size>>9;
1036 rq->buffer = rq->bh->b_data;
1037 } else {
1038 panic("%s: buffer list corrupted\n", drive->name);
1039 break;
1040 }
1041 } else {
1042 rq->buffer += nsect << 9;
1043 }
1044 } while (mcount);
1045 }
1046
1047
1048
1049
1050 static void multwrite_intr (ide_drive_t *drive)
1051 {
1052 byte stat;
1053 int i;
1054 ide_hwgroup_t *hwgroup = HWGROUP(drive);
1055 struct request *rq = &hwgroup->wrq;
1056
1057 if (OK_STAT(stat=GET_STAT(),DRIVE_READY,drive->bad_wstat)) {
1058 if (stat & DRQ_STAT) {
1059 if (rq->nr_sectors) {
1060 ide_multwrite(drive, drive->mult_count);
1061 ide_set_handler (drive, &multwrite_intr, WAIT_CMD);
1062 return;
1063 }
1064 } else {
1065 if (!rq->nr_sectors) {
1066 rq = hwgroup->rq;
1067 for (i = rq->nr_sectors; i > 0;){
1068 i -= rq->current_nr_sectors;
1069 ide_end_request(1, hwgroup);
1070 }
1071 return;
1072 }
1073 }
1074 }
1075 ide_error(drive, "multwrite_intr", stat);
1076 }
1077
1078
1079
1080
1081
1082 static void ide_cmd(ide_drive_t *drive, byte cmd, byte nsect, ide_handler_t *handler)
1083 {
1084 ide_set_handler (drive, handler, WAIT_CMD);
1085 OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
1086 OUT_BYTE(nsect,IDE_NSECTOR_REG);
1087 OUT_BYTE(cmd,IDE_COMMAND_REG);
1088 }
1089
1090
1091
1092
1093 static void set_multmode_intr (ide_drive_t *drive)
1094 {
1095 byte stat = GET_STAT();
1096
1097 sti();
1098 if (OK_STAT(stat,READY_STAT,BAD_STAT)) {
1099 drive->mult_count = drive->mult_req;
1100 } else {
1101 drive->mult_req = drive->mult_count = 0;
1102 drive->special.b.recalibrate = 1;
1103 (void) ide_dump_status(drive, "set_multmode", stat);
1104 }
1105 }
1106
1107
1108
1109
1110 static void set_geometry_intr (ide_drive_t *drive)
1111 {
1112 byte stat = GET_STAT();
1113
1114 sti();
1115 if (!OK_STAT(stat,READY_STAT,BAD_STAT))
1116 ide_error(drive, "set_geometry_intr", stat);
1117 }
1118
1119
1120
1121
1122 static void recal_intr (ide_drive_t *drive)
1123 {
1124 byte stat = GET_STAT();
1125
1126 sti();
1127 if (!OK_STAT(stat,READY_STAT,BAD_STAT))
1128 ide_error(drive, "recal_intr", stat);
1129 }
1130
1131
1132
1133
1134 static void drive_cmd_intr (ide_drive_t *drive)
1135 {
1136 struct request *rq = HWGROUP(drive)->rq;
1137 byte *args = (byte *) rq->buffer;
1138 byte stat = GET_STAT();
1139
1140 sti();
1141 if ((stat & DRQ_STAT) && args && args[3]) {
1142 ide_input_data(drive, &args[4], args[3] * SECTOR_WORDS);
1143 stat = GET_STAT();
1144 }
1145 if (OK_STAT(stat,READY_STAT,BAD_STAT))
1146 ide_end_drive_cmd (drive, stat, GET_ERR());
1147 else
1148 ide_error(drive, "drive_cmd", stat);
1149 }
1150
1151
1152
1153
1154
1155 static inline void do_special (ide_drive_t *drive)
1156 {
1157 special_t *s = &drive->special;
1158 next:
1159 #ifdef DEBUG
1160 printk("%s: do_special: 0x%02x\n", drive->name, s->all);
1161 #endif
1162 if (s->b.set_geometry) {
1163 s->b.set_geometry = 0;
1164 if (drive->media == ide_disk) {
1165 OUT_BYTE(drive->sect,IDE_SECTOR_REG);
1166 OUT_BYTE(drive->cyl,IDE_LCYL_REG);
1167 OUT_BYTE(drive->cyl>>8,IDE_HCYL_REG);
1168 OUT_BYTE(((drive->head-1)|drive->select.all)&0xBF,IDE_SELECT_REG);
1169 if (!IS_PROMISE_DRIVE)
1170 ide_cmd(drive, WIN_SPECIFY, drive->sect, &set_geometry_intr);
1171 }
1172 } else if (s->b.recalibrate) {
1173 s->b.recalibrate = 0;
1174 if (drive->media == ide_disk && !IS_PROMISE_DRIVE)
1175 ide_cmd(drive, WIN_RESTORE, drive->sect, &recal_intr);
1176 } else if (s->b.set_pio) {
1177 ide_tuneproc_t *tuneproc = HWIF(drive)->tuneproc;
1178 s->b.set_pio = 0;
1179 if (tuneproc != NULL)
1180 tuneproc(drive, drive->pio_req);
1181 goto next;
1182 } else if (s->b.set_multmode) {
1183 s->b.set_multmode = 0;
1184 if (drive->media == ide_disk) {
1185 if (drive->id && drive->mult_req > drive->id->max_multsect)
1186 drive->mult_req = drive->id->max_multsect;
1187 if (!IS_PROMISE_DRIVE)
1188 ide_cmd(drive, WIN_SETMULT, drive->mult_req, &set_multmode_intr);
1189 } else
1190 drive->mult_req = 0;
1191 } else if (s->all) {
1192 int special = s->all;
1193 s->all = 0;
1194 printk("%s: bad special flag: 0x%02x\n", drive->name, special);
1195 }
1196 }
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209 int ide_wait_stat (ide_drive_t *drive, byte good, byte bad, unsigned long timeout)
1210 {
1211 byte stat;
1212 unsigned long flags;
1213
1214 test:
1215 udelay(1);
1216 if (OK_STAT((stat = GET_STAT()), good, bad))
1217 return 0;
1218 if (!(stat & BUSY_STAT)) {
1219 ide_error(drive, "status error", stat);
1220 return 1;
1221 }
1222
1223 save_flags(flags);
1224 sti();
1225 timeout += jiffies;
1226 do {
1227 if (!((stat = GET_STAT()) & BUSY_STAT)) {
1228 restore_flags(flags);
1229 goto test;
1230 }
1231 } while (jiffies <= timeout);
1232
1233 restore_flags(flags);
1234 ide_error(drive, "status timeout", GET_STAT());
1235 return 1;
1236 }
1237
1238
1239
1240
1241
1242
1243 static inline void do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
1244 {
1245 ide_hwif_t *hwif = HWIF(drive);
1246 unsigned short io_base = hwif->io_base;
1247
1248 OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
1249 OUT_BYTE(rq->nr_sectors,io_base+IDE_NSECTOR_OFFSET);
1250 if (drive->select.b.lba) {
1251 #ifdef DEBUG
1252 printk("%s: %sing: LBAsect=%ld, sectors=%ld, buffer=0x%08lx\n",
1253 drive->name, (rq->cmd==READ)?"read":"writ",
1254 block, rq->nr_sectors, (unsigned long) rq->buffer);
1255 #endif
1256 OUT_BYTE(block,io_base+IDE_SECTOR_OFFSET);
1257 OUT_BYTE(block>>=8,io_base+IDE_LCYL_OFFSET);
1258 OUT_BYTE(block>>=8,io_base+IDE_HCYL_OFFSET);
1259 OUT_BYTE(((block>>8)&0x0f)|drive->select.all,io_base+IDE_SELECT_OFFSET);
1260 } else {
1261 unsigned int sect,head,cyl,track;
1262 track = block / drive->sect;
1263 sect = block % drive->sect + 1;
1264 OUT_BYTE(sect,io_base+IDE_SECTOR_OFFSET);
1265 head = track % drive->head;
1266 cyl = track / drive->head;
1267 OUT_BYTE(cyl,io_base+IDE_LCYL_OFFSET);
1268 OUT_BYTE(cyl>>8,io_base+IDE_HCYL_OFFSET);
1269 OUT_BYTE(head|drive->select.all,io_base+IDE_SELECT_OFFSET);
1270 #ifdef DEBUG
1271 printk("%s: %sing: CHS=%d/%d/%d, sectors=%ld, buffer=0x%08lx\n",
1272 drive->name, (rq->cmd==READ)?"read":"writ", cyl,
1273 head, sect, rq->nr_sectors, (unsigned long) rq->buffer);
1274 #endif
1275 }
1276 #ifdef CONFIG_BLK_DEV_PROMISE
1277 if (IS_PROMISE_DRIVE) {
1278 if (hwif->is_promise2 || rq->cmd == READ) {
1279 do_promise_io (drive, rq);
1280 return;
1281 }
1282 }
1283 #endif
1284 if (rq->cmd == READ) {
1285 #ifdef CONFIG_BLK_DEV_TRITON
1286 if (drive->using_dma && !(HWIF(drive)->dmaproc(ide_dma_read, drive)))
1287 return;
1288 #endif
1289 ide_set_handler(drive, &read_intr, WAIT_CMD);
1290 OUT_BYTE(drive->mult_count ? WIN_MULTREAD : WIN_READ, io_base+IDE_COMMAND_OFFSET);
1291 return;
1292 }
1293 if (rq->cmd == WRITE) {
1294 #ifdef CONFIG_BLK_DEV_TRITON
1295 if (drive->using_dma && !(HWIF(drive)->dmaproc(ide_dma_write, drive)))
1296 return;
1297 #endif
1298 OUT_BYTE(drive->mult_count ? WIN_MULTWRITE : WIN_WRITE, io_base+IDE_COMMAND_OFFSET);
1299 if (ide_wait_stat(drive, DATA_READY, drive->bad_wstat, WAIT_DRQ)) {
1300 printk("%s: no DRQ after issuing %s\n", drive->name,
1301 drive->mult_count ? "MULTWRITE" : "WRITE");
1302 return;
1303 }
1304 if (!drive->unmask)
1305 cli();
1306 if (drive->mult_count) {
1307 HWGROUP(drive)->wrq = *rq;
1308 ide_set_handler (drive, &multwrite_intr, WAIT_CMD);
1309 ide_multwrite(drive, drive->mult_count);
1310 } else {
1311 ide_set_handler (drive, &write_intr, WAIT_CMD);
1312 ide_output_data(drive, rq->buffer, SECTOR_WORDS);
1313 }
1314 return;
1315 }
1316 printk("%s: bad command: %d\n", drive->name, rq->cmd);
1317 ide_end_request(0, HWGROUP(drive));
1318 }
1319
1320
1321
1322
1323
1324 static void execute_drive_cmd (ide_drive_t *drive, struct request *rq)
1325 {
1326 byte *args = rq->buffer;
1327 if (args) {
1328 #ifdef DEBUG
1329 printk("%s: DRIVE_CMD cmd=0x%02x sc=0x%02x fr=0x%02x xx=0x%02x\n",
1330 drive->name, args[0], args[1], args[2], args[3]);
1331 #endif
1332 OUT_BYTE(args[2],IDE_FEATURE_REG);
1333 ide_cmd(drive, args[0], args[1], &drive_cmd_intr);
1334 return;
1335 } else {
1336
1337
1338
1339
1340 #ifdef DEBUG
1341 printk("%s: DRIVE_CMD (null)\n", drive->name);
1342 #endif
1343 ide_end_drive_cmd(drive, GET_STAT(), GET_ERR());
1344 return;
1345 }
1346 }
1347
1348
1349
1350
1351 static inline void do_request (ide_hwif_t *hwif, struct request *rq)
1352 {
1353 unsigned int minor, unit;
1354 unsigned long block, blockend;
1355 ide_drive_t *drive;
1356
1357 sti();
1358 #ifdef DEBUG
1359 printk("%s: do_request: current=0x%08lx\n", hwif->name, (unsigned long) rq);
1360 #endif
1361 minor = MINOR(rq->rq_dev);
1362 unit = minor >> PARTN_BITS;
1363 if (MAJOR(rq->rq_dev) != hwif->major || unit >= MAX_DRIVES) {
1364 printk("%s: bad device number: %s\n",
1365 hwif->name, kdevname(rq->rq_dev));
1366 goto kill_rq;
1367 }
1368 drive = &hwif->drives[unit];
1369 #ifdef DEBUG
1370 if (rq->bh && !buffer_locked(rq->bh)) {
1371 printk("%s: block not locked\n", drive->name);
1372 goto kill_rq;
1373 }
1374 #endif
1375 block = rq->sector;
1376 blockend = block + rq->nr_sectors;
1377 if ((blockend < block) || (blockend > drive->part[minor&PARTN_MASK].nr_sects)) {
1378 printk("%s%c: bad access: block=%ld, count=%ld\n", drive->name,
1379 (minor&PARTN_MASK)?'0'+(minor&PARTN_MASK):' ', block, rq->nr_sectors);
1380 goto kill_rq;
1381 }
1382 block += drive->part[minor&PARTN_MASK].start_sect + drive->sect0;
1383 #if FAKE_FDISK_FOR_EZDRIVE
1384 if (block == 0 && drive->remap_0_to_1)
1385 block = 1;
1386 #endif
1387 ((ide_hwgroup_t *)hwif->hwgroup)->drive = drive;
1388 #if (DISK_RECOVERY_TIME > 0)
1389 while ((read_timer() - hwif->last_time) < DISK_RECOVERY_TIME);
1390 #endif
1391
1392 #ifdef CONFIG_BLK_DEV_IDETAPE
1393 POLL_HWIF_TAPE_DRIVE;
1394 #endif
1395
1396 SELECT_DRIVE(hwif,drive);
1397 if (ide_wait_stat(drive, drive->ready_stat, BUSY_STAT|DRQ_STAT, WAIT_READY)) {
1398 printk("%s: drive not ready for command\n", drive->name);
1399 return;
1400 }
1401
1402 if (!drive->special.all) {
1403 if (rq->cmd == IDE_DRIVE_CMD) {
1404 execute_drive_cmd(drive, rq);
1405 return;
1406 }
1407 #ifdef CONFIG_BLK_DEV_IDEATAPI
1408 switch (drive->media) {
1409 case ide_disk:
1410 do_rw_disk (drive, rq, block);
1411 return;
1412 #ifdef CONFIG_BLK_DEV_IDECD
1413 case ide_cdrom:
1414 ide_do_rw_cdrom (drive, block);
1415 return;
1416 #endif
1417 #ifdef CONFIG_BLK_DEV_IDETAPE
1418 case ide_tape:
1419 idetape_do_request (drive, rq, block);
1420 return;
1421 #endif
1422
1423 default:
1424 printk("%s: media type %d not supported\n",
1425 drive->name, drive->media);
1426 goto kill_rq;
1427 }
1428 #else
1429 do_rw_disk (drive, rq, block);
1430 return;
1431 #endif ;
1432 }
1433 do_special(drive);
1434 return;
1435 kill_rq:
1436 ide_end_request(0, hwif->hwgroup);
1437 }
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454 void ide_do_request (ide_hwgroup_t *hwgroup)
1455 {
1456 cli();
1457 if (hwgroup->handler != NULL) {
1458 printk("%s: EEeekk!! handler not NULL in ide_do_request()\n", hwgroup->hwif->name);
1459 return;
1460 }
1461 do {
1462 ide_hwif_t *hwif = hwgroup->hwif;
1463 struct request *rq;
1464 if ((rq = hwgroup->rq) == NULL) {
1465
1466
1467
1468
1469
1470 hwif = hwgroup->next_hwif;
1471 do {
1472 if (IS_PLUGGED(blk_dev + hwif->major))
1473 continue;
1474 rq = blk_dev[hwif->major].current_request;
1475 if (rq != NULL && rq->rq_status != RQ_INACTIVE)
1476 goto got_rq;
1477 } while ((hwif = hwif->next) != hwgroup->next_hwif);
1478 return;
1479 }
1480 got_rq:
1481 do_request(hwgroup->hwif = hwgroup->next_hwif = hwif, hwgroup->rq = rq);
1482 cli();
1483 } while (hwgroup->handler == NULL);
1484 }
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497 static void do_hwgroup_request (ide_hwgroup_t *hwgroup)
1498 {
1499 if (hwgroup->handler == NULL) {
1500 ide_hwif_t *hgif = hwgroup->hwif;
1501 ide_hwif_t *hwif = hgif;
1502 do {
1503 disable_irq(hwif->irq);
1504 } while ((hwif = hwif->next) != hgif);
1505 ide_do_request (hwgroup);
1506 do {
1507 enable_irq(hwif->irq);
1508 } while ((hwif = hwif->next) != hgif);
1509 }
1510 }
1511
1512 static void do_ide0_request (void)
1513 {
1514 do_hwgroup_request (ide_hwifs[0].hwgroup);
1515 }
1516
1517 #if MAX_HWIFS > 1
1518 static void do_ide1_request (void)
1519 {
1520 do_hwgroup_request (ide_hwifs[1].hwgroup);
1521 }
1522 #endif
1523
1524 #if MAX_HWIFS > 2
1525 static void do_ide2_request (void)
1526 {
1527 do_hwgroup_request (ide_hwifs[2].hwgroup);
1528 }
1529 #endif
1530
1531 #if MAX_HWIFS > 3
1532 static void do_ide3_request (void)
1533 {
1534 do_hwgroup_request (ide_hwifs[3].hwgroup);
1535 }
1536 #endif
1537
1538 static void timer_expiry (unsigned long data)
1539 {
1540 ide_hwgroup_t *hwgroup = (ide_hwgroup_t *) data;
1541 ide_drive_t *drive = hwgroup->drive;
1542 unsigned long flags;
1543
1544 save_flags(flags);
1545 cli();
1546
1547 if (hwgroup->poll_timeout != 0) {
1548 ide_handler_t *handler = hwgroup->handler;
1549 hwgroup->handler = NULL;
1550 handler(drive);
1551 } else if (hwgroup->handler == NULL) {
1552 sti();
1553 printk("%s: marginal timeout\n", drive->name);
1554 } else {
1555 hwgroup->handler = NULL;
1556 if (hwgroup->hwif->dmaproc)
1557 (void) hwgroup->hwif->dmaproc (ide_dma_abort, drive);
1558 ide_error(drive, "irq timeout", GET_STAT());
1559 }
1560 if (hwgroup->handler == NULL)
1561 do_hwgroup_request (hwgroup);
1562 restore_flags(flags);
1563 }
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588 static void unexpected_intr (int irq, ide_hwgroup_t *hwgroup)
1589 {
1590 byte stat;
1591 unsigned int unit;
1592 ide_hwif_t *hwif = hwgroup->hwif;
1593
1594
1595
1596
1597 do {
1598 if (hwif->irq == irq) {
1599 for (unit = 0; unit < MAX_DRIVES; ++unit) {
1600 ide_drive_t *drive = &hwif->drives[unit];
1601 if (!drive->present)
1602 continue;
1603 SELECT_DRIVE(hwif,drive);
1604 if (!OK_STAT(stat=GET_STAT(), drive->ready_stat, BAD_STAT))
1605 (void) ide_dump_status(drive, "unexpected_intr", stat);
1606 if ((stat & DRQ_STAT))
1607 try_to_flush_leftover_data(drive);
1608 }
1609 }
1610 } while ((hwif = hwif->next) != hwgroup->hwif);
1611 SELECT_DRIVE(hwif,hwgroup->drive);
1612 }
1613
1614
1615
1616
1617 void ide_intr (int irq, void *dev_id, struct pt_regs *regs)
1618 {
1619 ide_hwgroup_t *hwgroup = dev_id;
1620 ide_handler_t *handler;
1621
1622 if (irq == hwgroup->hwif->irq && (handler = hwgroup->handler) != NULL) {
1623 ide_drive_t *drive = hwgroup->drive;
1624 hwgroup->handler = NULL;
1625 del_timer(&(hwgroup->timer));
1626 if (drive->unmask)
1627 sti();
1628 handler(drive);
1629 cli();
1630 if (hwgroup->handler == NULL) {
1631 SET_RECOVERY_TIMER(HWIF(drive));
1632 ide_do_request(hwgroup);
1633 }
1634 } else {
1635 unexpected_intr(irq, hwgroup);
1636 }
1637 cli();
1638 }
1639
1640
1641
1642
1643
1644 static ide_drive_t *get_info_ptr (kdev_t i_rdev)
1645 {
1646 int major = MAJOR(i_rdev);
1647 unsigned int h;
1648
1649 for (h = 0; h < MAX_HWIFS; ++h) {
1650 ide_hwif_t *hwif = &ide_hwifs[h];
1651 if (hwif->present && major == hwif->major) {
1652 unsigned unit = DEVICE_NR(i_rdev);
1653 if (unit < MAX_DRIVES) {
1654 ide_drive_t *drive = &hwif->drives[unit];
1655 if (drive->present)
1656 return drive;
1657 } else if (major == IDE0_MAJOR && unit < 4) {
1658 printk("ide: probable bad entry for /dev/hd%c\n", 'a'+unit);
1659 printk("ide: to fix it, run: /usr/src/linux/drivers/block/MAKEDEV.ide\n");
1660 }
1661 break;
1662 }
1663 }
1664 return NULL;
1665 }
1666
1667
1668
1669
1670 void ide_init_drive_cmd (struct request *rq)
1671 {
1672 rq->buffer = NULL;
1673 rq->cmd = IDE_DRIVE_CMD;
1674 rq->sector = 0;
1675 rq->nr_sectors = 0;
1676 rq->current_nr_sectors = 0;
1677 rq->sem = NULL;
1678 rq->bh = NULL;
1679 rq->bhtail = NULL;
1680 rq->next = NULL;
1681
1682 #if 0
1683 rq->errors = 0;
1684 rq->rq_status = RQ_ACTIVE;
1685 rq->rq_dev = ????;
1686 #endif
1687 }
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715 int ide_do_drive_cmd (ide_drive_t *drive, struct request *rq, ide_action_t action)
1716 {
1717 unsigned long flags;
1718 unsigned int major = HWIF(drive)->major;
1719 struct request *cur_rq;
1720 struct blk_dev_struct *bdev = &blk_dev[major];
1721 struct semaphore sem = MUTEX_LOCKED;
1722
1723 if (IS_PROMISE_DRIVE && rq->buffer != NULL)
1724 return -ENOSYS;
1725 rq->errors = 0;
1726 rq->rq_status = RQ_ACTIVE;
1727 rq->rq_dev = MKDEV(major,(drive->select.b.unit)<<PARTN_BITS);
1728 if (action == ide_wait)
1729 rq->sem = &sem;
1730
1731 save_flags(flags);
1732 cli();
1733 if (action == ide_next)
1734 HWGROUP(drive)->next_hwif = HWIF(drive);
1735 cur_rq = bdev->current_request;
1736
1737 if (cur_rq == NULL || action == ide_preempt) {
1738 rq->next = cur_rq;
1739 bdev->current_request = rq;
1740 if (action == ide_preempt) {
1741 HWGROUP(drive)->rq = NULL;
1742 } else
1743 if (HWGROUP(drive)->rq == NULL) {
1744 bdev->request_fn();
1745 cli();
1746 }
1747 } else {
1748 if (action == ide_wait || action == ide_end) {
1749 while (cur_rq->next != NULL)
1750 cur_rq = cur_rq->next;
1751 }
1752 rq->next = cur_rq->next;
1753 cur_rq->next = rq;
1754 }
1755 if (action == ide_wait && rq->rq_status != RQ_INACTIVE)
1756 down(&sem);
1757 restore_flags(flags);
1758 return rq->errors ? -EIO : 0;
1759 }
1760
1761 static int ide_open(struct inode * inode, struct file * filp)
1762 {
1763 ide_drive_t *drive;
1764 unsigned long flags;
1765
1766 if ((drive = get_info_ptr(inode->i_rdev)) == NULL)
1767 return -ENODEV;
1768 save_flags(flags);
1769 cli();
1770 while (drive->busy)
1771 sleep_on(&drive->wqueue);
1772 drive->usage++;
1773 restore_flags(flags);
1774 #ifdef CONFIG_BLK_DEV_IDECD
1775 if (drive->media == ide_cdrom)
1776 return ide_cdrom_open (inode, filp, drive);
1777 #endif
1778 #ifdef CONFIG_BLK_DEV_IDETAPE
1779 if (drive->media == ide_tape)
1780 return idetape_blkdev_open (inode, filp, drive);
1781 #endif
1782 if (drive->removeable) {
1783 byte door_lock[] = {WIN_DOORLOCK,0,0,0};
1784 struct request rq;
1785 check_disk_change(inode->i_rdev);
1786 ide_init_drive_cmd (&rq);
1787 rq.buffer = door_lock;
1788
1789
1790
1791
1792
1793 (void) ide_do_drive_cmd(drive, &rq, ide_wait);
1794 }
1795 return 0;
1796 }
1797
1798
1799
1800
1801
1802 static void ide_release(struct inode * inode, struct file * file)
1803 {
1804 ide_drive_t *drive;
1805
1806 if ((drive = get_info_ptr(inode->i_rdev)) != NULL) {
1807 sync_dev(inode->i_rdev);
1808 drive->usage--;
1809 #ifdef CONFIG_BLK_DEV_IDECD
1810 if (drive->media == ide_cdrom) {
1811 ide_cdrom_release (inode, file, drive);
1812 return;
1813 }
1814 #endif
1815 #ifdef CONFIG_BLK_DEV_IDETAPE
1816 if (drive->media == ide_tape) {
1817 idetape_blkdev_release (inode, file, drive);
1818 return;
1819 }
1820 #endif
1821 if (drive->removeable) {
1822 byte door_unlock[] = {WIN_DOORUNLOCK,0,0,0};
1823 struct request rq;
1824 invalidate_buffers(inode->i_rdev);
1825 ide_init_drive_cmd (&rq);
1826 rq.buffer = door_unlock;
1827 (void) ide_do_drive_cmd(drive, &rq, ide_wait);
1828 }
1829 }
1830 }
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840 static int revalidate_disk(kdev_t i_rdev)
1841 {
1842 ide_drive_t *drive;
1843 unsigned int p, major, minor;
1844 long flags;
1845
1846 if ((drive = get_info_ptr(i_rdev)) == NULL)
1847 return -ENODEV;
1848
1849 major = MAJOR(i_rdev);
1850 minor = drive->select.b.unit << PARTN_BITS;
1851 save_flags(flags);
1852 cli();
1853 if (drive->busy || (drive->usage > 1)) {
1854 restore_flags(flags);
1855 return -EBUSY;
1856 };
1857 drive->busy = 1;
1858 restore_flags(flags);
1859
1860 for (p = 0; p < (1<<PARTN_BITS); ++p) {
1861 if (drive->part[p].nr_sects > 0) {
1862 kdev_t devp = MKDEV(major, minor+p);
1863 sync_dev (devp);
1864 invalidate_inodes (devp);
1865 invalidate_buffers (devp);
1866 }
1867 drive->part[p].start_sect = 0;
1868 drive->part[p].nr_sects = 0;
1869 };
1870
1871 drive->part[0].nr_sects = current_capacity(drive);
1872 if (drive->media == ide_disk)
1873 resetup_one_dev(HWIF(drive)->gd, drive->select.b.unit);
1874
1875 drive->busy = 0;
1876 wake_up(&drive->wqueue);
1877 return 0;
1878 }
1879
1880 static int write_fs_long (unsigned long useraddr, long value)
1881 {
1882 int err;
1883
1884 if (NULL == (long *)useraddr)
1885 return -EINVAL;
1886 if ((err = verify_area(VERIFY_WRITE, (long *)useraddr, sizeof(long))))
1887 return err;
1888 put_user((unsigned)value, (long *) useraddr);
1889 return 0;
1890 }
1891
1892 static int ide_ioctl (struct inode *inode, struct file *file,
1893 unsigned int cmd, unsigned long arg)
1894 {
1895 int err;
1896 ide_drive_t *drive;
1897 unsigned long flags;
1898 struct request rq;
1899
1900 if (!inode || !(inode->i_rdev))
1901 return -EINVAL;
1902 if ((drive = get_info_ptr(inode->i_rdev)) == NULL)
1903 return -ENODEV;
1904 ide_init_drive_cmd (&rq);
1905 switch (cmd) {
1906 case HDIO_GETGEO:
1907 {
1908 struct hd_geometry *loc = (struct hd_geometry *) arg;
1909 if (!loc || drive->media != ide_disk) return -EINVAL;
1910 err = verify_area(VERIFY_WRITE, loc, sizeof(*loc));
1911 if (err) return err;
1912 put_user(drive->bios_head, (byte *) &loc->heads);
1913 put_user(drive->bios_sect, (byte *) &loc->sectors);
1914 put_user(drive->bios_cyl, (unsigned short *) &loc->cylinders);
1915 put_user((unsigned)drive->part[MINOR(inode->i_rdev)&PARTN_MASK].start_sect,
1916 (unsigned long *) &loc->start);
1917 return 0;
1918 }
1919 case BLKFLSBUF:
1920 if (!suser()) return -EACCES;
1921 fsync_dev(inode->i_rdev);
1922 invalidate_buffers(inode->i_rdev);
1923 return 0;
1924
1925 case BLKRASET:
1926 if (!suser()) return -EACCES;
1927 if(arg > 0xff) return -EINVAL;
1928 read_ahead[MAJOR(inode->i_rdev)] = arg;
1929 return 0;
1930
1931 case BLKRAGET:
1932 return write_fs_long(arg, read_ahead[MAJOR(inode->i_rdev)]);
1933
1934 case BLKGETSIZE:
1935 return write_fs_long(arg, drive->part[MINOR(inode->i_rdev)&PARTN_MASK].nr_sects);
1936 case BLKRRPART:
1937 if (!suser()) return -EACCES;
1938 return revalidate_disk(inode->i_rdev);
1939
1940 case HDIO_GET_KEEPSETTINGS:
1941 return write_fs_long(arg, drive->keep_settings);
1942
1943 case HDIO_GET_UNMASKINTR:
1944 return write_fs_long(arg, drive->unmask);
1945
1946 case HDIO_GET_DMA:
1947 return write_fs_long(arg, drive->using_dma);
1948
1949 case HDIO_GET_32BIT:
1950 return write_fs_long(arg, drive->io_32bit);
1951
1952 case HDIO_GET_MULTCOUNT:
1953 return write_fs_long(arg, drive->mult_count);
1954
1955 case HDIO_GET_IDENTITY:
1956 if (!arg || (MINOR(inode->i_rdev) & PARTN_MASK))
1957 return -EINVAL;
1958 if (drive->id == NULL)
1959 return -ENOMSG;
1960 err = verify_area(VERIFY_WRITE, (char *)arg, sizeof(*drive->id));
1961 if (!err)
1962 memcpy_tofs((char *)arg, (char *)drive->id, sizeof(*drive->id));
1963 return err;
1964
1965 case HDIO_GET_NOWERR:
1966 return write_fs_long(arg, drive->bad_wstat == BAD_R_STAT);
1967
1968 case HDIO_SET_DMA:
1969 if (!suser()) return -EACCES;
1970 #ifdef CONFIG_BLK_DEV_IDECD
1971 if (drive->media == ide_cdrom)
1972 return -EPERM;
1973 #endif
1974 if (!drive->id || !(drive->id->capability & 1) || !HWIF(drive)->dmaproc)
1975 return -EPERM;
1976 case HDIO_SET_KEEPSETTINGS:
1977 case HDIO_SET_UNMASKINTR:
1978 case HDIO_SET_NOWERR:
1979 if (arg > 1)
1980 return -EINVAL;
1981 case HDIO_SET_32BIT:
1982 if (!suser()) return -EACCES;
1983 if ((MINOR(inode->i_rdev) & PARTN_MASK))
1984 return -EINVAL;
1985 save_flags(flags);
1986 cli();
1987 switch (cmd) {
1988 case HDIO_SET_DMA:
1989 if (!(HWIF(drive)->dmaproc)) {
1990 restore_flags(flags);
1991 return -EPERM;
1992 }
1993 drive->using_dma = arg;
1994 break;
1995 case HDIO_SET_KEEPSETTINGS:
1996 drive->keep_settings = arg;
1997 break;
1998 case HDIO_SET_UNMASKINTR:
1999 if (arg && HWIF(drive)->no_unmask) {
2000 restore_flags(flags);
2001 return -EPERM;
2002 }
2003 drive->unmask = arg;
2004 break;
2005 case HDIO_SET_NOWERR:
2006 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
2007 break;
2008 case HDIO_SET_32BIT:
2009 if (arg > (1 + (SUPPORT_VLB_SYNC<<1)))
2010 return -EINVAL;
2011 drive->io_32bit = arg;
2012 #ifdef CONFIG_BLK_DEV_DTC2278
2013 if (HWIF(drive)->chipset == ide_dtc2278)
2014 HWIF(drive)->drives[!drive->select.b.unit].io_32bit = arg;
2015 #endif
2016 break;
2017 }
2018 restore_flags(flags);
2019 return 0;
2020
2021 case HDIO_SET_MULTCOUNT:
2022 if (!suser()) return -EACCES;
2023 if (MINOR(inode->i_rdev) & PARTN_MASK)
2024 return -EINVAL;
2025 if (drive->id && arg > drive->id->max_multsect)
2026 return -EINVAL;
2027 save_flags(flags);
2028 cli();
2029 if (drive->special.b.set_multmode) {
2030 restore_flags(flags);
2031 return -EBUSY;
2032 }
2033 drive->mult_req = arg;
2034 drive->special.b.set_multmode = 1;
2035 restore_flags(flags);
2036 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
2037 return (drive->mult_count == arg) ? 0 : -EIO;
2038
2039 case HDIO_DRIVE_CMD:
2040 {
2041 byte args[4], *argbuf = args;
2042 int argsize = 4;
2043 if (!suser()) return -EACCES;
2044 if (NULL == (void *) arg) {
2045 err = ide_do_drive_cmd(drive, &rq, ide_wait);
2046 } else if (!(err = verify_area(VERIFY_READ,(void *)arg, 4))) {
2047 memcpy_fromfs(args, (void *)arg, 4);
2048 if (args[3]) {
2049 argsize = 4 + (SECTOR_WORDS * 4 * args[3]);
2050 argbuf = kmalloc(argsize, GFP_KERNEL);
2051 if (argbuf == NULL)
2052 return -ENOMEM;
2053 argbuf[0] = args[0];
2054 argbuf[1] = args[1];
2055 argbuf[2] = args[2];
2056 argbuf[3] = args[3];
2057 }
2058 if (!(err = verify_area(VERIFY_WRITE,(void *)arg, argsize))) {
2059 rq.buffer = argbuf;
2060 err = ide_do_drive_cmd(drive, &rq, ide_wait);
2061 memcpy_tofs((void *)arg, argbuf, argsize);
2062 }
2063 if (argsize > 4)
2064 kfree(argbuf);
2065 }
2066 return err;
2067 }
2068 case HDIO_SET_PIO_MODE:
2069 if (!suser()) return -EACCES;
2070 if (MINOR(inode->i_rdev) & PARTN_MASK)
2071 return -EINVAL;
2072 if (!HWIF(drive)->tuneproc)
2073 return -ENOSYS;
2074 save_flags(flags);
2075 cli();
2076 drive->pio_req = (int) arg;
2077 drive->special.b.set_pio = 1;
2078 restore_flags(flags);
2079 return 0;
2080
2081 RO_IOCTLS(inode->i_rdev, arg);
2082
2083 default:
2084 #ifdef CONFIG_BLK_DEV_IDECD
2085 if (drive->media == ide_cdrom)
2086 return ide_cdrom_ioctl(drive, inode, file, cmd, arg);
2087 #endif
2088 #ifdef CONFIG_BLK_DEV_IDETAPE
2089 if (drive->media == ide_tape)
2090 return idetape_blkdev_ioctl(drive, inode, file, cmd, arg);
2091 #endif
2092 return -EPERM;
2093 }
2094 }
2095
2096 static int ide_check_media_change (kdev_t i_rdev)
2097 {
2098 ide_drive_t *drive;
2099
2100 if ((drive = get_info_ptr(i_rdev)) == NULL)
2101 return -ENODEV;
2102 #ifdef CONFIG_BLK_DEV_IDECD
2103 if (drive->media == ide_cdrom)
2104 return ide_cdrom_check_media_change (drive);
2105 #endif
2106 if (drive->removeable)
2107 return 1;
2108 return 0;
2109 }
2110
2111 void ide_fixstring (byte *s, const int bytecount, const int byteswap)
2112 {
2113 byte *p = s, *end = &s[bytecount & ~1];
2114
2115 if (byteswap) {
2116
2117 for (p = end ; p != s;) {
2118 unsigned short *pp = (unsigned short *) (p -= 2);
2119 *pp = ntohs(*pp);
2120 }
2121 }
2122
2123
2124 while (s != end && *s == ' ')
2125 ++s;
2126
2127
2128 while (s != end && *s) {
2129 if (*s++ != ' ' || (s != end && *s && *s != ' '))
2130 *p++ = *(s-1);
2131 }
2132
2133
2134 while (p != end)
2135 *p++ = '\0';
2136 }
2137
2138 static inline void do_identify (ide_drive_t *drive, byte cmd)
2139 {
2140 int bswap;
2141 struct hd_driveid *id;
2142 unsigned long capacity, check;
2143
2144 id = drive->id = kmalloc (SECTOR_WORDS*4, GFP_KERNEL);
2145 ide_input_data(drive, id, SECTOR_WORDS);
2146 sti();
2147
2148
2149
2150
2151 if ((id->model[0] == 'P' && id->model[1] == 'M')
2152 || (id->model[0] == 'S' && id->model[1] == 'K')) {
2153 printk("%s: EATA SCSI HBA %.10s\n", drive->name, id->model);
2154 drive->present = 0;
2155 return;
2156 }
2157
2158
2159
2160
2161
2162 bswap = 1;
2163 if (cmd == WIN_PIDENTIFY) {
2164 if ((id->model[0] == 'N' && id->model[1] == 'E')
2165 || (id->model[0] == 'F' && id->model[1] == 'X')
2166 || (id->model[0] == 'P' && id->model[1] == 'i'))
2167 bswap = 0;
2168 }
2169 ide_fixstring (id->model, sizeof(id->model), bswap);
2170 ide_fixstring (id->fw_rev, sizeof(id->fw_rev), bswap);
2171 ide_fixstring (id->serial_no, sizeof(id->serial_no), bswap);
2172
2173 #ifdef CONFIG_BLK_DEV_IDEATAPI
2174
2175
2176
2177 if (cmd == WIN_PIDENTIFY) {
2178 byte type = (id->config >> 8) & 0x1f;
2179 printk("%s: %s, ATAPI ", drive->name, id->model);
2180 #ifdef CONFIG_BLK_DEV_PROMISE
2181 if (HWIF(drive)->is_promise2) {
2182 printk(" -- not supported on 2nd Promise port\n");
2183 drive->present = 0;
2184 return;
2185 }
2186 #endif
2187 switch (type) {
2188 case 0:
2189 case 5:
2190 #ifdef CONFIG_BLK_DEV_IDECD
2191 printk ("CDROM drive\n");
2192 drive->media = ide_cdrom;
2193 drive->present = 1;
2194 drive->removeable = 1;
2195 return;
2196 #else
2197 printk ("CDROM ");
2198 break;
2199 #endif
2200 case 1:
2201 #ifdef CONFIG_BLK_DEV_IDETAPE
2202 printk ("TAPE drive");
2203 if (idetape_identify_device (drive,id)) {
2204 drive->media = ide_tape;
2205 drive->present = 1;
2206 drive->removeable = 1;
2207 if (HWIF(drive)->dmaproc != NULL &&
2208 !HWIF(drive)->dmaproc(ide_dma_check, drive))
2209 printk(", DMA");
2210 printk("\n");
2211 }
2212 else {
2213 drive->present = 0;
2214 printk ("\nide-tape: the tape is not supported by this version of the driver\n");
2215 }
2216 return;
2217 #else
2218 printk ("TAPE ");
2219 break;
2220 #endif
2221 default:
2222 drive->present = 0;
2223 printk("Type %d - Unknown device\n", type);
2224 return;
2225 }
2226 drive->present = 0;
2227 printk("- not supported by this kernel\n");
2228 return;
2229 }
2230 #endif
2231
2232
2233 if (id->config & (1<<7)) {
2234 if (id->model[0] != 'W' || id->model[1] != 'D')
2235 drive->removeable = 1;
2236 }
2237
2238
2239 if (id->model[0] == 'S' && id->model[1] == 'u') {
2240 drive->removeable = 0;
2241 if (drive->select.all & (1<<4)) {
2242 drive->present = 0;
2243 return;
2244 }
2245 }
2246
2247 drive->media = ide_disk;
2248
2249 if (!drive->present) {
2250 drive->present = 1;
2251 drive->cyl = drive->bios_cyl = id->cyls;
2252 drive->head = drive->bios_head = id->heads;
2253 drive->sect = drive->bios_sect = id->sectors;
2254 }
2255
2256 if ((id->field_valid & 1) && id->cur_cyls && id->cur_heads
2257 && (id->cur_heads <= 16) && id->cur_sectors)
2258 {
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269 drive->cyl = id->cur_cyls;
2270 drive->head = id->cur_heads;
2271 drive->sect = id->cur_sectors;
2272
2273
2274 capacity = drive->cyl * drive->head * drive->sect;
2275 check = (id->cur_capacity0 << 16) | id->cur_capacity1;
2276 if (check == capacity) {
2277
2278 id->cur_capacity0 = (capacity >> 0) & 0xffff;
2279 id->cur_capacity1 = (capacity >> 16) & 0xffff;
2280 }
2281 }
2282
2283 if ((!drive->head || drive->head > 16) && id->heads && id->heads <= 16) {
2284 drive->cyl = id->cyls;
2285 drive->head = id->heads;
2286 drive->sect = id->sectors;
2287 }
2288
2289 if (drive->sect == drive->bios_sect && drive->head == drive->bios_head) {
2290 if (drive->cyl > drive->bios_cyl)
2291 drive->bios_cyl = drive->cyl;
2292 }
2293
2294 (void) current_capacity (drive);
2295
2296 printk ("%s: %.40s, %ldMB w/%dkB Cache, %sCHS=%d/%d/%d",
2297 drive->name, id->model, current_capacity(drive)/2048L, id->buf_size/2,
2298 drive->select.b.lba ? "LBA, " : "",
2299 drive->bios_cyl, drive->bios_head, drive->bios_sect);
2300
2301 drive->mult_count = 0;
2302 if (id->max_multsect) {
2303 drive->mult_req = INITIAL_MULT_COUNT;
2304 if (drive->mult_req > id->max_multsect)
2305 drive->mult_req = id->max_multsect;
2306 if (drive->mult_req || ((id->multsect_valid & 1) && id->multsect))
2307 drive->special.b.set_multmode = 1;
2308 }
2309 if (HWIF(drive)->dmaproc != NULL) {
2310 if (!(HWIF(drive)->dmaproc(ide_dma_check, drive)))
2311 printk(", DMA");
2312 }
2313 printk("\n");
2314 }
2315
2316
2317
2318
2319
2320
2321 static void delay_10ms (void)
2322 {
2323 unsigned long timer = jiffies + (HZ + 99)/100 + 1;
2324 while (timer > jiffies);
2325 }
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337 static int try_to_identify (ide_drive_t *drive, byte cmd)
2338 {
2339 int hd_status, rc;
2340 unsigned long timeout;
2341 int irqs = 0;
2342
2343 if (!HWIF(drive)->irq) {
2344 probe_irq_off(probe_irq_on());
2345 irqs = probe_irq_on();
2346 OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
2347 }
2348
2349 delay_10ms();
2350 if ((IN_BYTE(IDE_ALTSTATUS_REG) ^ IN_BYTE(IDE_STATUS_REG)) & ~INDEX_STAT) {
2351 printk("%s: probing with STATUS instead of ALTSTATUS\n", drive->name);
2352 hd_status = IDE_STATUS_REG;
2353 } else
2354 hd_status = IDE_ALTSTATUS_REG;
2355
2356 #if CONFIG_BLK_DEV_PROMISE
2357 if (IS_PROMISE_DRIVE) {
2358 if(promise_cmd(drive,PROMISE_IDENTIFY))
2359 return 1;
2360 } else
2361 #endif
2362 OUT_BYTE(cmd,IDE_COMMAND_REG);
2363 timeout = ((cmd == WIN_IDENTIFY) ? WAIT_WORSTCASE : WAIT_PIDENTIFY) / 2;
2364 timeout += jiffies;
2365 do {
2366 if (jiffies > timeout) {
2367 if (!HWIF(drive)->irq)
2368 (void) probe_irq_off(irqs);
2369 return 1;
2370 }
2371 delay_10ms();
2372 } while (IN_BYTE(hd_status) & BUSY_STAT);
2373
2374 delay_10ms();
2375 if (OK_STAT(GET_STAT(),DRQ_STAT,BAD_R_STAT)) {
2376 cli();
2377 do_identify(drive, cmd);
2378 if (drive->present && drive->media != ide_tape) {
2379 ide_tuneproc_t *tuneproc = HWIF(drive)->tuneproc;
2380 if (tuneproc != NULL && drive->autotune == 1)
2381 tuneproc(drive, 255);
2382 }
2383 rc = 0;
2384 } else
2385 rc = 2;
2386 if (!HWIF(drive)->irq) {
2387 irqs = probe_irq_off(irqs);
2388 if (irqs > 0)
2389 HWIF(drive)->irq = irqs;
2390 else
2391 printk("%s: IRQ probe failed (%d)\n", drive->name, irqs);
2392 }
2393 return rc;
2394 }
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412 static int do_probe (ide_drive_t *drive, byte cmd)
2413 {
2414 int rc;
2415 ide_hwif_t *hwif;
2416 #ifdef CONFIG_BLK_DEV_IDEATAPI
2417 if (drive->present) {
2418 if ((drive->media != ide_disk) && (cmd == WIN_IDENTIFY))
2419 return 4;
2420 }
2421 #endif
2422 #ifdef DEBUG
2423 printk("probing for %s: present=%d, media=%d, probetype=%s\n",
2424 drive->name, drive->present, drive->media,
2425 (cmd == WIN_IDENTIFY) ? "ATA" : "ATAPI");
2426 #endif
2427 hwif = HWIF(drive);
2428 SELECT_DRIVE(hwif,drive);
2429 OUT_BYTE(drive->select.all,IDE_SELECT_REG);
2430 delay_10ms();
2431 if (IN_BYTE(IDE_SELECT_REG) != drive->select.all && !drive->present) {
2432 OUT_BYTE(0xa0,IDE_SELECT_REG);
2433 return 3;
2434 }
2435
2436 if (OK_STAT(GET_STAT(),READY_STAT,BUSY_STAT)
2437 || drive->present || cmd == WIN_PIDENTIFY)
2438 {
2439 if ((rc = try_to_identify(drive,cmd)))
2440 rc = try_to_identify(drive,cmd);
2441 if (rc == 1)
2442 printk("%s: no response (status = 0x%02x)\n", drive->name, GET_STAT());
2443 (void) GET_STAT();
2444 } else {
2445 rc = 3;
2446 }
2447 if (drive->select.b.unit != 0) {
2448 OUT_BYTE(0xa0,IDE_SELECT_REG);
2449 delay_10ms();
2450 (void) GET_STAT();
2451 }
2452 return rc;
2453 }
2454
2455
2456
2457
2458
2459
2460
2461 static inline byte probe_for_drive (ide_drive_t *drive)
2462 {
2463 if (drive->noprobe)
2464 return drive->present;
2465 if (do_probe(drive, WIN_IDENTIFY) >= 2) {
2466 #ifdef CONFIG_BLK_DEV_IDEATAPI
2467 (void) do_probe(drive, WIN_PIDENTIFY);
2468 #endif
2469 }
2470 if (!drive->present)
2471 return 0;
2472 if (drive->id == NULL) {
2473 if (drive->media == ide_disk) {
2474 printk ("%s: non-IDE drive, CHS=%d/%d/%d\n",
2475 drive->name, drive->cyl, drive->head, drive->sect);
2476 }
2477 #ifdef CONFIG_BLK_DEV_IDECD
2478 else if (drive->media == ide_cdrom) {
2479 printk("%s: ATAPI cdrom (?)\n", drive->name);
2480 }
2481 #endif
2482 else {
2483 drive->present = 0;
2484 }
2485 }
2486 return 1;
2487 }
2488
2489
2490
2491
2492
2493 static void probe_hwif (ide_hwif_t *hwif)
2494 {
2495 unsigned int unit;
2496
2497 #if CONFIG_BLK_DEV_PROMISE
2498 if (!hwif->is_promise2 &&
2499 (check_region(hwif->io_base,8) || check_region(hwif->ctl_port,1))) {
2500 #else
2501 if (check_region(hwif->io_base,8) || check_region(hwif->ctl_port,1)) {
2502 #endif
2503 int msgout = 0;
2504 for (unit = 0; unit < MAX_DRIVES; ++unit) {
2505 ide_drive_t *drive = &hwif->drives[unit];
2506 if (drive->present) {
2507 drive->present = 0;
2508 printk("%s: ERROR, PORTS ALREADY IN USE\n", drive->name);
2509 msgout = 1;
2510 }
2511 }
2512 if (!msgout)
2513 printk("%s: ports already in use, skipping probe\n", hwif->name);
2514 } else {
2515 unsigned long flags;
2516 save_flags(flags);
2517
2518 sti();
2519
2520
2521
2522
2523 for (unit = 0; unit < MAX_DRIVES; ++unit) {
2524 ide_drive_t *drive = &hwif->drives[unit];
2525 (void) probe_for_drive (drive);
2526 if (drive->present && drive->media == ide_disk) {
2527 if (IS_PROMISE_DRIVE)
2528 drive->select.b.lba = 1;
2529 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
2530 printk("%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
2531 drive->name, drive->head);
2532 drive->present = 0;
2533 }
2534 }
2535 if (drive->present && !hwif->present) {
2536 hwif->present = 1;
2537 request_region(hwif->io_base, 8, hwif->name);
2538 request_region(hwif->ctl_port, 1, hwif->name);
2539 }
2540 }
2541 restore_flags(flags);
2542 }
2543 }
2544
2545
2546
2547
2548
2549 static int stridx (const char *s, char c)
2550 {
2551 char *i = strchr(s, c);
2552 return (i && c) ? i - s : -1;
2553 }
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567 static int match_parm (char *s, const char *keywords[], int vals[], int max_vals)
2568 {
2569 static const char *decimal = "0123456789";
2570 static const char *hex = "0123456789abcdef";
2571 int i, n;
2572
2573 if (*s++ == '=') {
2574
2575
2576
2577
2578 for (i = 0; *keywords != NULL; ++i) {
2579 if (!strcmp(s, *keywords++))
2580 return -(i+1);
2581 }
2582
2583
2584
2585
2586
2587
2588 for (n = 0; (i = stridx(decimal, *s)) >= 0;) {
2589 vals[n] = i;
2590 while ((i = stridx(decimal, *++s)) >= 0)
2591 vals[n] = (vals[n] * 10) + i;
2592 if (*s == 'x' && !vals[n]) {
2593 while ((i = stridx(hex, *++s)) >= 0)
2594 vals[n] = (vals[n] * 0x10) + i;
2595 }
2596 if (++n == max_vals)
2597 break;
2598 if (*s == ',')
2599 ++s;
2600 }
2601 if (!*s)
2602 return n;
2603 }
2604 return 0;
2605 }
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654 void ide_setup (char *s)
2655 {
2656 int i, vals[3];
2657 ide_hwif_t *hwif;
2658 ide_drive_t *drive;
2659 unsigned int hw, unit;
2660 const char max_drive = 'a' + ((MAX_HWIFS * MAX_DRIVES) - 1);
2661 const char max_hwif = '0' + (MAX_HWIFS - 1);
2662
2663 printk("ide_setup: %s", s);
2664 init_ide_data ();
2665
2666
2667
2668
2669 if (s[0] == 'h' && s[1] == 'd' && s[2] >= 'a' && s[2] <= max_drive) {
2670 const char *hd_words[] = {"noprobe", "nowerr", "cdrom", "serialize",
2671 "autotune", "noautotune", NULL};
2672 unit = s[2] - 'a';
2673 hw = unit / MAX_DRIVES;
2674 unit = unit % MAX_DRIVES;
2675 hwif = &ide_hwifs[hw];
2676 drive = &hwif->drives[unit];
2677 switch (match_parm(&s[3], hd_words, vals, 3)) {
2678 case -1:
2679 drive->noprobe = 1;
2680 goto done;
2681 case -2:
2682 drive->bad_wstat = BAD_R_STAT;
2683 hwif->noprobe = 0;
2684 goto done;
2685 case -3:
2686 drive->present = 1;
2687 drive->media = ide_cdrom;
2688 hwif->noprobe = 0;
2689 goto done;
2690 case -4:
2691 printk(" -- USE \"ide%d=serialize\" INSTEAD", hw);
2692 goto do_serialize;
2693 case -5:
2694 drive->autotune = 1;
2695 goto done;
2696 case -6:
2697 drive->autotune = 2;
2698 goto done;
2699 case 3:
2700 drive->media = ide_disk;
2701 drive->cyl = drive->bios_cyl = vals[0];
2702 drive->head = drive->bios_head = vals[1];
2703 drive->sect = drive->bios_sect = vals[2];
2704 drive->present = 1;
2705 drive->forced_geom = 1;
2706 hwif->noprobe = 0;
2707 goto done;
2708 default:
2709 goto bad_option;
2710 }
2711 }
2712
2713
2714
2715 if (s[0] == 'i' && s[1] == 'd' && s[2] == 'e' && s[3] >= '0' && s[3] <= max_hwif) {
2716
2717
2718
2719 const char *ide_words[] = {"noprobe", "serialize", "autotune", "noautotune",
2720 "qd6580", "ht6560b", "cmd640_vlb", "dtc2278", "umc8672", "ali14xx", "dc4030", NULL};
2721 hw = s[3] - '0';
2722 hwif = &ide_hwifs[hw];
2723 i = match_parm(&s[4], ide_words, vals, 3);
2724
2725
2726
2727
2728 if (i != -1 && i != -2) {
2729 if (hwif->chipset != ide_unknown)
2730 goto bad_option;
2731 if (i < 0 && ide_hwifs[1].chipset != ide_unknown)
2732 goto bad_option;
2733 }
2734
2735
2736
2737 if (i <= -6 && hw != 0)
2738 goto bad_hwif;
2739
2740 switch (i) {
2741 #ifdef CONFIG_BLK_DEV_PROMISE
2742 case -11:
2743 {
2744 setup_dc4030(hwif);
2745 goto done;
2746 }
2747 #endif
2748 #ifdef CONFIG_BLK_DEV_ALI14XX
2749 case -10:
2750 {
2751 extern void init_ali14xx (void);
2752 init_ali14xx();
2753 goto done;
2754 }
2755 #endif
2756 #ifdef CONFIG_BLK_DEV_UMC8672
2757 case -9:
2758 {
2759 extern void init_umc8672 (void);
2760 init_umc8672();
2761 goto done;
2762 }
2763 #endif
2764 #ifdef CONFIG_BLK_DEV_DTC2278
2765 case -8:
2766 {
2767 extern void init_dtc2278 (void);
2768 init_dtc2278();
2769 goto done;
2770 }
2771 #endif
2772 #ifdef CONFIG_BLK_DEV_CMD640
2773 case -7:
2774 {
2775 extern int cmd640_vlb;
2776 cmd640_vlb = 1;
2777 goto done;
2778 }
2779 #endif
2780 #ifdef CONFIG_BLK_DEV_HT6560B
2781 case -6:
2782 {
2783 extern void init_ht6560b (void);
2784 init_ht6560b();
2785 goto done;
2786 }
2787 #endif
2788 #if CONFIG_BLK_DEV_QD6580
2789 case -5:
2790 {
2791 extern void init_qd6580 (void);
2792 init_qd6580();
2793 goto done;
2794 }
2795 #endif
2796 case -4:
2797 hwif->drives[0].autotune = 2;
2798 hwif->drives[1].autotune = 2;
2799 goto done;
2800 case -3:
2801 hwif->drives[0].autotune = 1;
2802 hwif->drives[1].autotune = 1;
2803 goto done;
2804 case -2:
2805 do_serialize:
2806 ide_hwifs[hw].serialized = 1;
2807 ide_hwifs[hw^1].serialized = 1;
2808 goto done;
2809
2810 case -1:
2811 hwif->noprobe = 1;
2812 goto done;
2813
2814 case 1:
2815 vals[1] = vals[0] + 0x206;
2816 case 2:
2817 vals[2] = 0;
2818 case 3:
2819 hwif->io_base = vals[0];
2820 hwif->ctl_port = vals[1];
2821 hwif->irq = vals[2];
2822 hwif->noprobe = 0;
2823 hwif->chipset = ide_generic;
2824 goto done;
2825
2826 case 0: goto bad_option;
2827 default:
2828 printk(" -- SUPPORT NOT CONFIGURED IN THIS KERNEL\n");
2829 return;
2830 }
2831 }
2832 bad_option:
2833 printk(" -- BAD OPTION\n");
2834 return;
2835 bad_hwif:
2836 printk("-- NOT SUPPORTED ON ide%d", hw);
2837 done:
2838 printk("\n");
2839 }
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857 int ide_xlate_1024 (kdev_t i_rdev, int xparm, const char *msg)
2858 {
2859 ide_drive_t *drive;
2860 static const byte head_vals[] = {4, 8, 16, 32, 64, 128, 255, 0};
2861 const byte *heads = head_vals;
2862 unsigned long tracks;
2863
2864 if ((drive = get_info_ptr(i_rdev)) == NULL || drive->forced_geom)
2865 return 0;
2866
2867 if (xparm > 1 && xparm <= drive->bios_head && drive->bios_sect == 63)
2868 return 0;
2869
2870 printk("%s ", msg);
2871
2872 if (drive->id) {
2873 drive->cyl = drive->id->cyls;
2874 drive->head = drive->id->heads;
2875 drive->sect = drive->id->sectors;
2876 }
2877 drive->bios_cyl = drive->cyl;
2878 drive->bios_head = drive->head;
2879 drive->bios_sect = drive->sect;
2880 drive->special.b.set_geometry = 1;
2881
2882 tracks = drive->bios_cyl * drive->bios_head * drive->bios_sect / 63;
2883 drive->bios_sect = 63;
2884 if (xparm > 1) {
2885 drive->bios_head = xparm;
2886 drive->bios_cyl = tracks / drive->bios_head;
2887 } else {
2888 while (drive->bios_cyl >= 1024) {
2889 drive->bios_head = *heads;
2890 drive->bios_cyl = tracks / drive->bios_head;
2891 if (0 == *++heads)
2892 break;
2893 }
2894 #if FAKE_FDISK_FOR_EZDRIVE
2895 if (xparm == -1) {
2896 drive->remap_0_to_1 = 1;
2897 msg = "0->1";
2898 } else
2899 #endif
2900 if (xparm == 1) {
2901 drive->sect0 = 63;
2902 drive->bios_cyl = (tracks - 1) / drive->bios_head;
2903 msg = "+63";
2904 }
2905 printk("[remap %s] ", msg);
2906 }
2907 drive->part[0].nr_sects = current_capacity(drive);
2908 printk("[%d/%d/%d]", drive->bios_cyl, drive->bios_head, drive->bios_sect);
2909 return 1;
2910 }
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935 static void probe_cmos_for_drives (ide_hwif_t *hwif)
2936 {
2937 #ifdef __i386__
2938 extern struct drive_info_struct drive_info;
2939 byte cmos_disks, *BIOS = (byte *) &drive_info;
2940 int unit;
2941
2942 #ifdef CONFIG_BLK_DEV_PROMISE
2943 if (hwif->is_promise2)
2944 return;
2945 #endif
2946 outb_p(0x12,0x70);
2947 cmos_disks = inb_p(0x71);
2948
2949 for (unit = 0; unit < MAX_DRIVES; ++unit) {
2950 ide_drive_t *drive = &hwif->drives[unit];
2951 if ((cmos_disks & (0xf0 >> (unit*4))) && !drive->present) {
2952 drive->cyl = drive->bios_cyl = *(unsigned short *)BIOS;
2953 drive->head = drive->bios_head = *(BIOS+2);
2954 drive->sect = drive->bios_sect = *(BIOS+14);
2955 drive->ctl = *(BIOS+8);
2956 drive->present = 1;
2957 }
2958 BIOS += 16;
2959 }
2960 #endif
2961 }
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972 static int init_irq (ide_hwif_t *hwif)
2973 {
2974 unsigned long flags;
2975 ide_hwgroup_t *hwgroup = hwif->hwgroup;
2976 ide_hwif_t *mate_hwif;
2977 unsigned int index, mate_irq = hwif->irq;
2978
2979 save_flags(flags);
2980 cli();
2981
2982
2983
2984
2985 mate_hwif = &ide_hwifs[hwif->index ^ 1];
2986 if (hwif->serialized && mate_hwif->present)
2987 mate_irq = mate_hwif->irq;
2988
2989
2990
2991
2992 for (index = 0; index < MAX_HWIFS; index++) {
2993 if (index != hwif->index) {
2994 ide_hwif_t *g = &ide_hwifs[index];
2995 if (g->irq == hwif->irq || g->irq == mate_irq) {
2996 if (hwgroup && !g->hwgroup)
2997 g->hwgroup = hwgroup;
2998 else if (!hwgroup)
2999 hwgroup = g->hwgroup;
3000 }
3001 }
3002 }
3003
3004
3005
3006
3007 if (hwgroup == NULL) {
3008 hwgroup = kmalloc (sizeof(ide_hwgroup_t), GFP_KERNEL);
3009 hwgroup->hwif = hwgroup->next_hwif = hwif->next = hwif;
3010 hwgroup->rq = NULL;
3011 hwgroup->handler = NULL;
3012 if (hwif->drives[0].present)
3013 hwgroup->drive = &hwif->drives[0];
3014 else
3015 hwgroup->drive = &hwif->drives[1];
3016 hwgroup->poll_timeout = 0;
3017 init_timer(&hwgroup->timer);
3018 hwgroup->timer.function = &timer_expiry;
3019 hwgroup->timer.data = (unsigned long) hwgroup;
3020 }
3021
3022
3023
3024
3025 if (!hwif->got_irq) {
3026 if (request_irq(hwif->irq, ide_intr, SA_INTERRUPT|SA_SAMPLE_RANDOM, hwif->name, hwgroup)) {
3027 restore_flags(flags);
3028 return 1;
3029 }
3030 for (index = 0; index < MAX_HWIFS; index++) {
3031 ide_hwif_t *g = &ide_hwifs[index];
3032 if (g->irq == hwif->irq)
3033 g->got_irq = 1;
3034 }
3035 }
3036
3037
3038
3039
3040 hwif->hwgroup = hwgroup;
3041 hwif->next = hwgroup->hwif->next;
3042 hwgroup->hwif->next = hwif;
3043
3044 restore_flags(flags);
3045
3046 printk("%s at 0x%03x-0x%03x,0x%03x on irq %d", hwif->name,
3047 hwif->io_base, hwif->io_base+7, hwif->ctl_port, hwif->irq);
3048 if (hwgroup->hwif != hwif)
3049 printk(" (serialized with %s)", hwgroup->hwif->name);
3050 printk("\n");
3051 return 0;
3052 }
3053
3054 static struct file_operations ide_fops = {
3055 NULL,
3056 block_read,
3057 block_write,
3058 NULL,
3059 NULL,
3060 ide_ioctl,
3061 NULL,
3062 ide_open,
3063 ide_release,
3064 block_fsync
3065 ,NULL,
3066 ide_check_media_change,
3067 revalidate_disk
3068 };
3069
3070 #ifdef CONFIG_PCI
3071 #if defined(CONFIG_BLK_DEV_RZ1000) || defined(CONFIG_BLK_DEV_TRITON)
3072
3073 typedef void (ide_pci_init_proc_t)(byte, byte);
3074
3075
3076
3077
3078
3079 static void ide_probe_pci (unsigned short vendor, unsigned short device, ide_pci_init_proc_t *init, int func_adj)
3080 {
3081 unsigned long flags;
3082 unsigned index;
3083 byte fn, bus;
3084
3085 save_flags(flags);
3086 cli();
3087 for (index = 0; !pcibios_find_device (vendor, device, index, &bus, &fn); ++index) {
3088 init (bus, fn + func_adj);
3089 }
3090 restore_flags(flags);
3091 }
3092
3093 #endif
3094 #endif
3095
3096
3097
3098
3099
3100
3101
3102 static void probe_for_hwifs (void)
3103 {
3104 #ifdef CONFIG_PCI
3105
3106
3107
3108 if (pcibios_present()) {
3109 #ifdef CONFIG_BLK_DEV_RZ1000
3110 ide_pci_init_proc_t init_rz1000;
3111 ide_probe_pci (PCI_VENDOR_ID_PCTECH, PCI_DEVICE_ID_PCTECH_RZ1000, &init_rz1000, 0);
3112 ide_probe_pci (PCI_VENDOR_ID_PCTECH, PCI_DEVICE_ID_PCTECH_RZ1001, &init_rz1000, 0);
3113 #endif
3114 #ifdef CONFIG_BLK_DEV_TRITON
3115
3116
3117
3118
3119
3120
3121 ide_probe_pci (PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371_0, &ide_init_triton, 1);
3122 #endif
3123 }
3124 #endif
3125 #ifdef CONFIG_BLK_DEV_CMD640
3126 {
3127 extern void ide_probe_for_cmd640x (void);
3128 ide_probe_for_cmd640x();
3129 }
3130 #endif
3131 #ifdef CONFIG_BLK_DEV_PROMISE
3132 init_dc4030();
3133 #endif
3134 }
3135
3136 static int hwif_init (int h)
3137 {
3138 ide_hwif_t *hwif = &ide_hwifs[h];
3139 void (*rfn)(void);
3140
3141 if (hwif->noprobe)
3142 return 0;
3143 else {
3144 if (hwif->io_base == HD_DATA)
3145 probe_cmos_for_drives (hwif);
3146 probe_hwif (hwif);
3147 if (!hwif->present)
3148 return 0;
3149 }
3150 if (!hwif->irq) {
3151 if (!(hwif->irq = default_irqs[h])) {
3152 printk("%s: DISABLED, NO IRQ\n", hwif->name);
3153 return (hwif->present = 0);
3154 }
3155 }
3156 #ifdef CONFIG_BLK_DEV_HD
3157 if (hwif->irq == HD_IRQ && hwif->io_base != HD_DATA) {
3158 printk("%s: CANNOT SHARE IRQ WITH OLD HARDDISK DRIVER (hd.c)\n", hwif->name);
3159 return (hwif->present = 0);
3160 }
3161 #endif
3162
3163 hwif->present = 0;
3164 switch (hwif->major) {
3165 case IDE0_MAJOR: rfn = &do_ide0_request; break;
3166 #if MAX_HWIFS > 1
3167 case IDE1_MAJOR: rfn = &do_ide1_request; break;
3168 #endif
3169 #if MAX_HWIFS > 2
3170 case IDE2_MAJOR: rfn = &do_ide2_request; break;
3171 #endif
3172 #if MAX_HWIFS > 3
3173 case IDE3_MAJOR: rfn = &do_ide3_request; break;
3174 #endif
3175 default:
3176 printk("%s: request_fn NOT DEFINED\n", hwif->name);
3177 return (hwif->present = 0);
3178 }
3179 if (register_blkdev (hwif->major, hwif->name, &ide_fops)) {
3180 printk("%s: UNABLE TO GET MAJOR NUMBER %d\n", hwif->name, hwif->major);
3181 } else if (init_irq (hwif)) {
3182 printk("%s: UNABLE TO GET IRQ %d\n", hwif->name, hwif->irq);
3183 (void) unregister_blkdev (hwif->major, hwif->name);
3184 } else {
3185 init_gendisk(hwif);
3186 blk_dev[hwif->major].request_fn = rfn;
3187 read_ahead[hwif->major] = 8;
3188 hwif->present = 1;
3189 }
3190 return hwif->present;
3191 }
3192
3193
3194
3195
3196 int ide_init (void)
3197 {
3198 int index;
3199
3200 init_ide_data ();
3201
3202
3203
3204 probe_for_hwifs ();
3205
3206
3207
3208
3209 for (index = 0; index < MAX_HWIFS; ++index)
3210 hwif_init (index);
3211
3212 #ifdef CONFIG_BLK_DEV_IDETAPE
3213 idetape_register_chrdev();
3214 #endif
3215
3216 return 0;
3217 }
3218
3219 #ifdef CONFIG_BLK_DEV_IDE_PCMCIA
3220 int ide_register(int io_base, int ctl_port, int irq)
3221 {
3222 int index, i, rc = -1;
3223 ide_hwif_t *hwif;
3224 unsigned long flags;
3225
3226 save_flags(flags);
3227 cli();
3228 for (index = 0; index < MAX_HWIFS; ++index) {
3229 hwif = &ide_hwifs[index];
3230 if (hwif->present) {
3231 if (hwif->io_base == io_base || hwif->ctl_port == ctl_port)
3232 break;
3233 } else {
3234 hwif->io_base = io_base;
3235 hwif->ctl_port = ctl_port;
3236 hwif->irq = irq;
3237 hwif->noprobe = 0;
3238 if (!hwif_init(index))
3239 break;
3240 hwif->gd->real_devices = hwif->drives[0].name;
3241 for (i = 0; i < hwif->gd->nr_real; i++)
3242 revalidate_disk(MKDEV(hwif->major, i<<PARTN_BITS));
3243 rc = index;
3244 }
3245 }
3246 restore_flags(flags);
3247 return rc;
3248 }
3249
3250 void ide_unregister (unsigned int index)
3251 {
3252 struct gendisk *prev_gd, *gd;
3253 ide_hwif_t *hwif, *g;
3254 ide_hwgroup_t *hwgroup;
3255 int irq_count = 0;
3256 unsigned long flags;
3257
3258 if (index >= MAX_HWIFS)
3259 return;
3260 save_flags(flags);
3261 cli();
3262 hwif = &ide_hwifs[index];
3263 if (!hwif->present || hwif->drives[0].busy || hwif->drives[1].busy) {
3264 restore_flags(flags);
3265 return;
3266 }
3267 hwif->present = 0;
3268 hwgroup = hwif->hwgroup;
3269
3270
3271
3272
3273 g = hwgroup->hwif;
3274 do {
3275 if (g->irq == hwif->irq)
3276 ++irq_count;
3277 g = g->next;
3278 } while (g != hwgroup->hwif);
3279 if (irq_count == 1)
3280 free_irq(hwif->irq, hwgroup);
3281
3282
3283
3284
3285
3286 while (hwgroup->hwif->next != hwif)
3287 hwgroup->hwif = hwgroup->hwif->next;
3288 hwgroup->hwif->next = hwif->next;
3289 if (hwgroup->hwif == hwif)
3290 hwgroup->hwif = hwif->next;
3291 if (hwgroup->next_hwif == hwif)
3292 hwgroup->next_hwif = hwif->next;
3293 if (hwgroup->hwif == hwif)
3294 kfree(hwgroup);
3295
3296
3297
3298
3299 unregister_blkdev(hwif->major, hwif->name);
3300 kfree(blksize_size[hwif->major]);
3301 blk_dev[hwif->major].request_fn = NULL;
3302 blksize_size[hwif->major] = NULL;
3303 gd = gendisk_head; prev_gd = NULL;
3304 while (gd && (gd != hwif->gd)) {
3305 prev_gd = gd;
3306 gd = gd->next;
3307 }
3308 if (gd != hwif->gd)
3309 printk("gd not in disk chain!\n");
3310 else {
3311 if (prev_gd != NULL)
3312 prev_gd->next = gd->next;
3313 else
3314 gendisk_head = gd->next;
3315 kfree(gd->sizes);
3316 kfree(gd->part);
3317 kfree(gd);
3318 }
3319 init_hwif_data (index);
3320 restore_flags(flags);
3321 }
3322 #endif