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#include <linux/blkdev.h>
30#include <linux/errno.h>
31#include <linux/signal.h>
32#include <linux/interrupt.h>
33#include <linux/timer.h>
34#include <linux/fs.h>
35#include <linux/kernel.h>
36#include <linux/genhd.h>
37#include <linux/slab.h>
38#include <linux/string.h>
39#include <linux/ioport.h>
40#include <linux/init.h>
41#include <linux/blkpg.h>
42#include <linux/ata.h>
43#include <linux/hdreg.h>
44
45#define HD_IRQ 14
46
47#define REALLY_SLOW_IO
48#include <asm/system.h>
49#include <asm/io.h>
50#include <asm/uaccess.h>
51
52#ifdef __arm__
53#undef HD_IRQ
54#endif
55#include <asm/irq.h>
56#ifdef __arm__
57#define HD_IRQ IRQ_HARDDISK
58#endif
59
60
61
62#define HD_DATA 0x1f0
63#define HD_ERROR 0x1f1
64#define HD_NSECTOR 0x1f2
65#define HD_SECTOR 0x1f3
66#define HD_LCYL 0x1f4
67#define HD_HCYL 0x1f5
68#define HD_CURRENT 0x1f6
69#define HD_STATUS 0x1f7
70#define HD_FEATURE HD_ERROR
71#define HD_PRECOMP HD_FEATURE
72#define HD_COMMAND HD_STATUS
73
74#define HD_CMD 0x3f6
75#define HD_ALTSTATUS 0x3f6
76
77
78#define ERR_STAT 0x01
79#define INDEX_STAT 0x02
80#define ECC_STAT 0x04
81#define DRQ_STAT 0x08
82#define SEEK_STAT 0x10
83#define SERVICE_STAT SEEK_STAT
84#define WRERR_STAT 0x20
85#define READY_STAT 0x40
86#define BUSY_STAT 0x80
87
88
89#define MARK_ERR 0x01
90#define TRK0_ERR 0x02
91#define ABRT_ERR 0x04
92#define MCR_ERR 0x08
93#define ID_ERR 0x10
94#define MC_ERR 0x20
95#define ECC_ERR 0x40
96#define BBD_ERR 0x80
97#define ICRC_ERR 0x80
98
99static DEFINE_SPINLOCK(hd_lock);
100static struct request_queue *hd_queue;
101static struct request *hd_req;
102
103#define TIMEOUT_VALUE (6*HZ)
104#define HD_DELAY 0
105
106#define MAX_ERRORS 16
107#define RESET_FREQ 8
108#define RECAL_FREQ 4
109#define MAX_HD 2
110
111#define STAT_OK (READY_STAT|SEEK_STAT)
112#define OK_STATUS(s) (((s)&(STAT_OK|(BUSY_STAT|WRERR_STAT|ERR_STAT)))==STAT_OK)
113
114static void recal_intr(void);
115static void bad_rw_intr(void);
116
117static int reset;
118static int hd_error;
119
120
121
122
123struct hd_i_struct {
124 unsigned int head, sect, cyl, wpcom, lzone, ctl;
125 int unit;
126 int recalibrate;
127 int special_op;
128};
129
130#ifdef HD_TYPE
131static struct hd_i_struct hd_info[] = { HD_TYPE };
132static int NR_HD = ARRAY_SIZE(hd_info);
133#else
134static struct hd_i_struct hd_info[MAX_HD];
135static int NR_HD;
136#endif
137
138static struct gendisk *hd_gendisk[MAX_HD];
139
140static struct timer_list device_timer;
141
142#define TIMEOUT_VALUE (6*HZ)
143
144#define SET_TIMER \
145 do { \
146 mod_timer(&device_timer, jiffies + TIMEOUT_VALUE); \
147 } while (0)
148
149static void (*do_hd)(void) = NULL;
150#define SET_HANDLER(x) \
151if ((do_hd = (x)) != NULL) \
152 SET_TIMER; \
153else \
154 del_timer(&device_timer);
155
156
157#if (HD_DELAY > 0)
158
159#include <asm/i8253.h>
160
161unsigned long last_req;
162
163unsigned long read_timer(void)
164{
165 unsigned long t, flags;
166 int i;
167
168 spin_lock_irqsave(&i8253_lock, flags);
169 t = jiffies * 11932;
170 outb_p(0, 0x43);
171 i = inb_p(0x40);
172 i |= inb(0x40) << 8;
173 spin_unlock_irqrestore(&i8253_lock, flags);
174 return(t - i);
175}
176#endif
177
178static void __init hd_setup(char *str, int *ints)
179{
180 int hdind = 0;
181
182 if (ints[0] != 3)
183 return;
184 if (hd_info[0].head != 0)
185 hdind = 1;
186 hd_info[hdind].head = ints[2];
187 hd_info[hdind].sect = ints[3];
188 hd_info[hdind].cyl = ints[1];
189 hd_info[hdind].wpcom = 0;
190 hd_info[hdind].lzone = ints[1];
191 hd_info[hdind].ctl = (ints[2] > 8 ? 8 : 0);
192 NR_HD = hdind+1;
193}
194
195static bool hd_end_request(int err, unsigned int bytes)
196{
197 if (__blk_end_request(hd_req, err, bytes))
198 return true;
199 hd_req = NULL;
200 return false;
201}
202
203static bool hd_end_request_cur(int err)
204{
205 return hd_end_request(err, blk_rq_cur_bytes(hd_req));
206}
207
208static void dump_status(const char *msg, unsigned int stat)
209{
210 char *name = "hd?";
211 if (hd_req)
212 name = hd_req->rq_disk->disk_name;
213
214#ifdef VERBOSE_ERRORS
215 printk("%s: %s: status=0x%02x { ", name, msg, stat & 0xff);
216 if (stat & BUSY_STAT) printk("Busy ");
217 if (stat & READY_STAT) printk("DriveReady ");
218 if (stat & WRERR_STAT) printk("WriteFault ");
219 if (stat & SEEK_STAT) printk("SeekComplete ");
220 if (stat & DRQ_STAT) printk("DataRequest ");
221 if (stat & ECC_STAT) printk("CorrectedError ");
222 if (stat & INDEX_STAT) printk("Index ");
223 if (stat & ERR_STAT) printk("Error ");
224 printk("}\n");
225 if ((stat & ERR_STAT) == 0) {
226 hd_error = 0;
227 } else {
228 hd_error = inb(HD_ERROR);
229 printk("%s: %s: error=0x%02x { ", name, msg, hd_error & 0xff);
230 if (hd_error & BBD_ERR) printk("BadSector ");
231 if (hd_error & ECC_ERR) printk("UncorrectableError ");
232 if (hd_error & ID_ERR) printk("SectorIdNotFound ");
233 if (hd_error & ABRT_ERR) printk("DriveStatusError ");
234 if (hd_error & TRK0_ERR) printk("TrackZeroNotFound ");
235 if (hd_error & MARK_ERR) printk("AddrMarkNotFound ");
236 printk("}");
237 if (hd_error & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
238 printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL),
239 inb(HD_CURRENT) & 0xf, inb(HD_SECTOR));
240 if (hd_req)
241 printk(", sector=%ld", blk_rq_pos(hd_req));
242 }
243 printk("\n");
244 }
245#else
246 printk("%s: %s: status=0x%02x.\n", name, msg, stat & 0xff);
247 if ((stat & ERR_STAT) == 0) {
248 hd_error = 0;
249 } else {
250 hd_error = inb(HD_ERROR);
251 printk("%s: %s: error=0x%02x.\n", name, msg, hd_error & 0xff);
252 }
253#endif
254}
255
256static void check_status(void)
257{
258 int i = inb_p(HD_STATUS);
259
260 if (!OK_STATUS(i)) {
261 dump_status("check_status", i);
262 bad_rw_intr();
263 }
264}
265
266static int controller_busy(void)
267{
268 int retries = 100000;
269 unsigned char status;
270
271 do {
272 status = inb_p(HD_STATUS);
273 } while ((status & BUSY_STAT) && --retries);
274 return status;
275}
276
277static int status_ok(void)
278{
279 unsigned char status = inb_p(HD_STATUS);
280
281 if (status & BUSY_STAT)
282 return 1;
283 if (status & WRERR_STAT)
284 return 0;
285 if (!(status & READY_STAT))
286 return 0;
287 if (!(status & SEEK_STAT))
288 return 0;
289 return 1;
290}
291
292static int controller_ready(unsigned int drive, unsigned int head)
293{
294 int retry = 100;
295
296 do {
297 if (controller_busy() & BUSY_STAT)
298 return 0;
299 outb_p(0xA0 | (drive<<4) | head, HD_CURRENT);
300 if (status_ok())
301 return 1;
302 } while (--retry);
303 return 0;
304}
305
306static void hd_out(struct hd_i_struct *disk,
307 unsigned int nsect,
308 unsigned int sect,
309 unsigned int head,
310 unsigned int cyl,
311 unsigned int cmd,
312 void (*intr_addr)(void))
313{
314 unsigned short port;
315
316#if (HD_DELAY > 0)
317 while (read_timer() - last_req < HD_DELAY)
318 ;
319#endif
320 if (reset)
321 return;
322 if (!controller_ready(disk->unit, head)) {
323 reset = 1;
324 return;
325 }
326 SET_HANDLER(intr_addr);
327 outb_p(disk->ctl, HD_CMD);
328 port = HD_DATA;
329 outb_p(disk->wpcom >> 2, ++port);
330 outb_p(nsect, ++port);
331 outb_p(sect, ++port);
332 outb_p(cyl, ++port);
333 outb_p(cyl >> 8, ++port);
334 outb_p(0xA0 | (disk->unit << 4) | head, ++port);
335 outb_p(cmd, ++port);
336}
337
338static void hd_request (void);
339
340static int drive_busy(void)
341{
342 unsigned int i;
343 unsigned char c;
344
345 for (i = 0; i < 500000 ; i++) {
346 c = inb_p(HD_STATUS);
347 if ((c & (BUSY_STAT | READY_STAT | SEEK_STAT)) == STAT_OK)
348 return 0;
349 }
350 dump_status("reset timed out", c);
351 return 1;
352}
353
354static void reset_controller(void)
355{
356 int i;
357
358 outb_p(4, HD_CMD);
359 for (i = 0; i < 1000; i++) barrier();
360 outb_p(hd_info[0].ctl & 0x0f, HD_CMD);
361 for (i = 0; i < 1000; i++) barrier();
362 if (drive_busy())
363 printk("hd: controller still busy\n");
364 else if ((hd_error = inb(HD_ERROR)) != 1)
365 printk("hd: controller reset failed: %02x\n", hd_error);
366}
367
368static void reset_hd(void)
369{
370 static int i;
371
372repeat:
373 if (reset) {
374 reset = 0;
375 i = -1;
376 reset_controller();
377 } else {
378 check_status();
379 if (reset)
380 goto repeat;
381 }
382 if (++i < NR_HD) {
383 struct hd_i_struct *disk = &hd_info[i];
384 disk->special_op = disk->recalibrate = 1;
385 hd_out(disk, disk->sect, disk->sect, disk->head-1,
386 disk->cyl, ATA_CMD_INIT_DEV_PARAMS, &reset_hd);
387 if (reset)
388 goto repeat;
389 } else
390 hd_request();
391}
392
393
394
395
396
397
398
399
400
401
402static void unexpected_hd_interrupt(void)
403{
404 unsigned int stat = inb_p(HD_STATUS);
405
406 if (stat & (BUSY_STAT|DRQ_STAT|ECC_STAT|ERR_STAT)) {
407 dump_status("unexpected interrupt", stat);
408 SET_TIMER;
409 }
410}
411
412
413
414
415
416
417static void bad_rw_intr(void)
418{
419 struct request *req = hd_req;
420
421 if (req != NULL) {
422 struct hd_i_struct *disk = req->rq_disk->private_data;
423 if (++req->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {
424 hd_end_request_cur(-EIO);
425 disk->special_op = disk->recalibrate = 1;
426 } else if (req->errors % RESET_FREQ == 0)
427 reset = 1;
428 else if ((hd_error & TRK0_ERR) || req->errors % RECAL_FREQ == 0)
429 disk->special_op = disk->recalibrate = 1;
430
431 }
432}
433
434static inline int wait_DRQ(void)
435{
436 int retries;
437 int stat;
438
439 for (retries = 0; retries < 100000; retries++) {
440 stat = inb_p(HD_STATUS);
441 if (stat & DRQ_STAT)
442 return 0;
443 }
444 dump_status("wait_DRQ", stat);
445 return -1;
446}
447
448static void read_intr(void)
449{
450 struct request *req;
451 int i, retries = 100000;
452
453 do {
454 i = (unsigned) inb_p(HD_STATUS);
455 if (i & BUSY_STAT)
456 continue;
457 if (!OK_STATUS(i))
458 break;
459 if (i & DRQ_STAT)
460 goto ok_to_read;
461 } while (--retries > 0);
462 dump_status("read_intr", i);
463 bad_rw_intr();
464 hd_request();
465 return;
466
467ok_to_read:
468 req = hd_req;
469 insw(HD_DATA, req->buffer, 256);
470#ifdef DEBUG
471 printk("%s: read: sector %ld, remaining = %u, buffer=%p\n",
472 req->rq_disk->disk_name, blk_rq_pos(req) + 1,
473 blk_rq_sectors(req) - 1, req->buffer+512);
474#endif
475 if (hd_end_request(0, 512)) {
476 SET_HANDLER(&read_intr);
477 return;
478 }
479
480 (void) inb_p(HD_STATUS);
481#if (HD_DELAY > 0)
482 last_req = read_timer();
483#endif
484 hd_request();
485}
486
487static void write_intr(void)
488{
489 struct request *req = hd_req;
490 int i;
491 int retries = 100000;
492
493 do {
494 i = (unsigned) inb_p(HD_STATUS);
495 if (i & BUSY_STAT)
496 continue;
497 if (!OK_STATUS(i))
498 break;
499 if ((blk_rq_sectors(req) <= 1) || (i & DRQ_STAT))
500 goto ok_to_write;
501 } while (--retries > 0);
502 dump_status("write_intr", i);
503 bad_rw_intr();
504 hd_request();
505 return;
506
507ok_to_write:
508 if (hd_end_request(0, 512)) {
509 SET_HANDLER(&write_intr);
510 outsw(HD_DATA, req->buffer, 256);
511 return;
512 }
513
514#if (HD_DELAY > 0)
515 last_req = read_timer();
516#endif
517 hd_request();
518}
519
520static void recal_intr(void)
521{
522 check_status();
523#if (HD_DELAY > 0)
524 last_req = read_timer();
525#endif
526 hd_request();
527}
528
529
530
531
532
533static void hd_times_out(unsigned long dummy)
534{
535 char *name;
536
537 do_hd = NULL;
538
539 if (!hd_req)
540 return;
541
542 spin_lock_irq(hd_queue->queue_lock);
543 reset = 1;
544 name = hd_req->rq_disk->disk_name;
545 printk("%s: timeout\n", name);
546 if (++hd_req->errors >= MAX_ERRORS) {
547#ifdef DEBUG
548 printk("%s: too many errors\n", name);
549#endif
550 hd_end_request_cur(-EIO);
551 }
552 hd_request();
553 spin_unlock_irq(hd_queue->queue_lock);
554}
555
556static int do_special_op(struct hd_i_struct *disk, struct request *req)
557{
558 if (disk->recalibrate) {
559 disk->recalibrate = 0;
560 hd_out(disk, disk->sect, 0, 0, 0, ATA_CMD_RESTORE, &recal_intr);
561 return reset;
562 }
563 if (disk->head > 16) {
564 printk("%s: cannot handle device with more than 16 heads - giving up\n", req->rq_disk->disk_name);
565 hd_end_request_cur(-EIO);
566 }
567 disk->special_op = 0;
568 return 1;
569}
570
571
572
573
574
575
576
577
578
579
580
581static void hd_request(void)
582{
583 unsigned int block, nsect, sec, track, head, cyl;
584 struct hd_i_struct *disk;
585 struct request *req;
586
587 if (do_hd)
588 return;
589repeat:
590 del_timer(&device_timer);
591
592 if (!hd_req) {
593 hd_req = blk_fetch_request(hd_queue);
594 if (!hd_req) {
595 do_hd = NULL;
596 return;
597 }
598 }
599 req = hd_req;
600
601 if (reset) {
602 reset_hd();
603 return;
604 }
605 disk = req->rq_disk->private_data;
606 block = blk_rq_pos(req);
607 nsect = blk_rq_sectors(req);
608 if (block >= get_capacity(req->rq_disk) ||
609 ((block+nsect) > get_capacity(req->rq_disk))) {
610 printk("%s: bad access: block=%d, count=%d\n",
611 req->rq_disk->disk_name, block, nsect);
612 hd_end_request_cur(-EIO);
613 goto repeat;
614 }
615
616 if (disk->special_op) {
617 if (do_special_op(disk, req))
618 goto repeat;
619 return;
620 }
621 sec = block % disk->sect + 1;
622 track = block / disk->sect;
623 head = track % disk->head;
624 cyl = track / disk->head;
625#ifdef DEBUG
626 printk("%s: %sing: CHS=%d/%d/%d, sectors=%d, buffer=%p\n",
627 req->rq_disk->disk_name,
628 req_data_dir(req) == READ ? "read" : "writ",
629 cyl, head, sec, nsect, req->buffer);
630#endif
631 if (blk_fs_request(req)) {
632 switch (rq_data_dir(req)) {
633 case READ:
634 hd_out(disk, nsect, sec, head, cyl, ATA_CMD_PIO_READ,
635 &read_intr);
636 if (reset)
637 goto repeat;
638 break;
639 case WRITE:
640 hd_out(disk, nsect, sec, head, cyl, ATA_CMD_PIO_WRITE,
641 &write_intr);
642 if (reset)
643 goto repeat;
644 if (wait_DRQ()) {
645 bad_rw_intr();
646 goto repeat;
647 }
648 outsw(HD_DATA, req->buffer, 256);
649 break;
650 default:
651 printk("unknown hd-command\n");
652 hd_end_request_cur(-EIO);
653 break;
654 }
655 }
656}
657
658static void do_hd_request(struct request_queue *q)
659{
660 hd_request();
661}
662
663static int hd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
664{
665 struct hd_i_struct *disk = bdev->bd_disk->private_data;
666
667 geo->heads = disk->head;
668 geo->sectors = disk->sect;
669 geo->cylinders = disk->cyl;
670 return 0;
671}
672
673
674
675
676
677
678static irqreturn_t hd_interrupt(int irq, void *dev_id)
679{
680 void (*handler)(void) = do_hd;
681
682 spin_lock(hd_queue->queue_lock);
683
684 do_hd = NULL;
685 del_timer(&device_timer);
686 if (!handler)
687 handler = unexpected_hd_interrupt;
688 handler();
689
690 spin_unlock(hd_queue->queue_lock);
691
692 return IRQ_HANDLED;
693}
694
695static const struct block_device_operations hd_fops = {
696 .getgeo = hd_getgeo,
697};
698
699
700
701
702
703
704
705
706
707
708
709static int __init hd_init(void)
710{
711 int drive;
712
713 if (register_blkdev(HD_MAJOR, "hd"))
714 return -1;
715
716 hd_queue = blk_init_queue(do_hd_request, &hd_lock);
717 if (!hd_queue) {
718 unregister_blkdev(HD_MAJOR, "hd");
719 return -ENOMEM;
720 }
721
722 blk_queue_max_sectors(hd_queue, 255);
723 init_timer(&device_timer);
724 device_timer.function = hd_times_out;
725 blk_queue_logical_block_size(hd_queue, 512);
726
727 if (!NR_HD) {
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742 printk("hd: no drives specified - use hd=cyl,head,sectors"
743 " on kernel command line\n");
744 goto out;
745 }
746
747 for (drive = 0 ; drive < NR_HD ; drive++) {
748 struct gendisk *disk = alloc_disk(64);
749 struct hd_i_struct *p = &hd_info[drive];
750 if (!disk)
751 goto Enomem;
752 disk->major = HD_MAJOR;
753 disk->first_minor = drive << 6;
754 disk->fops = &hd_fops;
755 sprintf(disk->disk_name, "hd%c", 'a'+drive);
756 disk->private_data = p;
757 set_capacity(disk, p->head * p->sect * p->cyl);
758 disk->queue = hd_queue;
759 p->unit = drive;
760 hd_gendisk[drive] = disk;
761 printk("%s: %luMB, CHS=%d/%d/%d\n",
762 disk->disk_name, (unsigned long)get_capacity(disk)/2048,
763 p->cyl, p->head, p->sect);
764 }
765
766 if (request_irq(HD_IRQ, hd_interrupt, IRQF_DISABLED, "hd", NULL)) {
767 printk("hd: unable to get IRQ%d for the hard disk driver\n",
768 HD_IRQ);
769 goto out1;
770 }
771 if (!request_region(HD_DATA, 8, "hd")) {
772 printk(KERN_WARNING "hd: port 0x%x busy\n", HD_DATA);
773 goto out2;
774 }
775 if (!request_region(HD_CMD, 1, "hd(cmd)")) {
776 printk(KERN_WARNING "hd: port 0x%x busy\n", HD_CMD);
777 goto out3;
778 }
779
780
781 for (drive = 0; drive < NR_HD; drive++)
782 add_disk(hd_gendisk[drive]);
783
784 return 0;
785
786out3:
787 release_region(HD_DATA, 8);
788out2:
789 free_irq(HD_IRQ, NULL);
790out1:
791 for (drive = 0; drive < NR_HD; drive++)
792 put_disk(hd_gendisk[drive]);
793 NR_HD = 0;
794out:
795 del_timer(&device_timer);
796 unregister_blkdev(HD_MAJOR, "hd");
797 blk_cleanup_queue(hd_queue);
798 return -1;
799Enomem:
800 while (drive--)
801 put_disk(hd_gendisk[drive]);
802 goto out;
803}
804
805static int __init parse_hd_setup(char *line)
806{
807 int ints[6];
808
809 (void) get_options(line, ARRAY_SIZE(ints), ints);
810 hd_setup(NULL, ints);
811
812 return 1;
813}
814__setup("hd=", parse_hd_setup);
815
816late_initcall(hd_init);
817