1/* 2 * Copyright (C) 1991, 1992 Linus Torvalds 3 * 4 * This is the low-level hd interrupt support. It traverses the 5 * request-list, using interrupts to jump between functions. As 6 * all the functions are called within interrupts, we may not 7 * sleep. Special care is recommended. 8 * 9 * modified by Drew Eckhardt to check nr of hd's from the CMOS. 10 * 11 * Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug 12 * in the early extended-partition checks and added DM partitions 13 * 14 * IRQ-unmask, drive-id, multiple-mode, support for ">16 heads", 15 * and general streamlining by Mark Lord. 16 * 17 * Removed 99% of above. Use Mark's ide driver for those options. 18 * This is now a lightweight ST-506 driver. (Paul Gortmaker) 19 * 20 * Modified 1995 Russell King for ARM processor. 21 * 22 * Bugfix: max_sectors must be <= 255 or the wheels tend to come 23 * off in a hurry once you queue things up - Paul G. 02/2001 24 */ 25 26/* Uncomment the following if you want verbose error reports. */ 27/* #define VERBOSE_ERRORS */ 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/mc146818rtc.h> /* CMOS defines */ 41#include <linux/init.h> 42#include <linux/blkpg.h> 43#include <linux/hdreg.h> 44 45#define REALLY_SLOW_IO 46#include <asm/system.h> 47#include <asm/io.h> 48#include <asm/uaccess.h> 49 50#ifdef __arm__ 51#undef HD_IRQ 52#endif 53#include <asm/irq.h> 54#ifdef __arm__ 55#define HD_IRQ IRQ_HARDDISK 56#endif 57 58/* Hd controller regster ports */ 59 60#define HD_DATA 0x1f0 /* _CTL when writing */ 61#define HD_ERROR 0x1f1 /* see err-bits */ 62#define HD_NSECTOR 0x1f2 /* nr of sectors to read/write */ 63#define HD_SECTOR 0x1f3 /* starting sector */ 64#define HD_LCYL 0x1f4 /* starting cylinder */ 65#define HD_HCYL 0x1f5 /* high byte of starting cyl */ 66#define HD_CURRENT 0x1f6 /* 101dhhhh , d=drive, hhhh=head */ 67#define HD_STATUS 0x1f7 /* see status-bits */ 68#define HD_FEATURE HD_ERROR /* same io address, read=error, write=feature */ 69#define HD_PRECOMP HD_FEATURE /* obsolete use of this port - predates IDE */ 70#define HD_COMMAND HD_STATUS /* same io address, read=status, write=cmd */ 71 72#define HD_CMD 0x3f6 /* used for resets */ 73#define HD_ALTSTATUS 0x3f6 /* same as HD_STATUS but doesn't clear irq */ 74 75/* Bits of HD_STATUS */ 76#define ERR_STAT 0x01 77#define INDEX_STAT 0x02 78#define ECC_STAT 0x04 /* Corrected error */ 79#define DRQ_STAT 0x08 80#define SEEK_STAT 0x10 81#define SERVICE_STAT SEEK_STAT 82#define WRERR_STAT 0x20 83#define READY_STAT 0x40 84#define BUSY_STAT 0x80 85 86/* Bits for HD_ERROR */ 87#define MARK_ERR 0x01 /* Bad address mark */ 88#define TRK0_ERR 0x02 /* couldn't find track 0 */ 89#define ABRT_ERR 0x04 /* Command aborted */ 90#define MCR_ERR 0x08 /* media change request */ 91#define ID_ERR 0x10 /* ID field not found */ 92#define MC_ERR 0x20 /* media changed */ 93#define ECC_ERR 0x40 /* Uncorrectable ECC error */ 94#define BBD_ERR 0x80 /* pre-EIDE meaning: block marked bad */ 95#define ICRC_ERR 0x80 /* new meaning: CRC error during transfer */ 96 97static DEFINE_SPINLOCK(hd_lock); 98static struct request_queue *hd_queue; 99 100#define MAJOR_NR HD_MAJOR 101#define QUEUE (hd_queue) 102#define CURRENT elv_next_request(hd_queue) 103 104#define TIMEOUT_VALUE (6*HZ) 105#define HD_DELAY 0 106 107#define MAX_ERRORS 16 /* Max read/write errors/sector */ 108#define RESET_FREQ 8 /* Reset controller every 8th retry */ 109#define RECAL_FREQ 4 /* Recalibrate every 4th retry */ 110#define MAX_HD 2 111 112#define STAT_OK (READY_STAT|SEEK_STAT) 113#define OK_STATUS(s) (((s)&(STAT_OK|(BUSY_STAT|WRERR_STAT|ERR_STAT)))==STAT_OK) 114 115static void recal_intr(void); 116static void bad_rw_intr(void); 117 118static int reset; 119static int hd_error; 120 121/* 122 * This struct defines the HD's and their types. 123 */ 124struct hd_i_struct { 125 unsigned int head,sect,cyl,wpcom,lzone,ctl; 126 int unit; 127 int recalibrate; 128 int special_op; 129}; 130 131#ifdef HD_TYPE 132static struct hd_i_struct hd_info[] = { HD_TYPE }; 133static int NR_HD = ((sizeof (hd_info))/(sizeof (struct hd_i_struct))); 134#else 135static struct hd_i_struct hd_info[MAX_HD]; 136static int NR_HD; 137#endif 138 139static struct gendisk *hd_gendisk[MAX_HD]; 140 141static struct timer_list device_timer; 142 143#define TIMEOUT_VALUE (6*HZ) 144 145#define SET_TIMER \ 146 do { \ 147 mod_timer(&device_timer, jiffies + TIMEOUT_VALUE); \ 148 } while (0) 149 150static void (*do_hd)(void) = NULL; 151#define SET_HANDLER(x) \ 152if ((do_hd = (x)) != NULL) \ 153 SET_TIMER; \ 154else \ 155 del_timer(&device_timer); 156 157 158#if (HD_DELAY > 0) 159 160#include <asm/i8253.h> 161 162unsigned long last_req; 163 164unsigned long read_timer(void) 165{ 166 unsigned long t, flags; 167 int i; 168 169 spin_lock_irqsave(&i8253_lock, flags); 170 t = jiffies * 11932; 171 outb_p(0, 0x43); 172 i = inb_p(0x40); 173 i |= inb(0x40) << 8; 174 spin_unlock_irqrestore(&i8253_lock, flags); 175 return(t - i); 176} 177#endif 178 179static void __init hd_setup(char *str, int *ints) 180{ 181 int hdind = 0; 182 183 if (ints[0] != 3) 184 return; 185 if (hd_info[0].head != 0) 186 hdind=1; 187 hd_info[hdind].head = ints[2]; 188 hd_info[hdind].sect = ints[3]; 189 hd_info[hdind].cyl = ints[1]; 190 hd_info[hdind].wpcom = 0; 191 hd_info[hdind].lzone = ints[1]; 192 hd_info[hdind].ctl = (ints[2] > 8 ? 8 : 0); 193 NR_HD = hdind+1; 194} 195 196static void dump_status (const char *msg, unsigned int stat) 197{ 198 char *name = "hd?"; 199 if (CURRENT) 200 name = CURRENT->rq_disk->disk_name; 201 202#ifdef VERBOSE_ERRORS 203 printk("%s: %s: status=0x%02x { ", name, msg, stat & 0xff); 204 if (stat & BUSY_STAT) printk("Busy "); 205 if (stat & READY_STAT) printk("DriveReady "); 206 if (stat & WRERR_STAT) printk("WriteFault "); 207 if (stat & SEEK_STAT) printk("SeekComplete "); 208 if (stat & DRQ_STAT) printk("DataRequest "); 209 if (stat & ECC_STAT) printk("CorrectedError "); 210 if (stat & INDEX_STAT) printk("Index "); 211 if (stat & ERR_STAT) printk("Error "); 212 printk("}\n"); 213 if ((stat & ERR_STAT) == 0) { 214 hd_error = 0; 215 } else { 216 hd_error = inb(HD_ERROR); 217 printk("%s: %s: error=0x%02x { ", name, msg, hd_error & 0xff); 218 if (hd_error & BBD_ERR) printk("BadSector "); 219 if (hd_error & ECC_ERR) printk("UncorrectableError "); 220 if (hd_error & ID_ERR) printk("SectorIdNotFound "); 221 if (hd_error & ABRT_ERR) printk("DriveStatusError "); 222 if (hd_error & TRK0_ERR) printk("TrackZeroNotFound "); 223 if (hd_error & MARK_ERR) printk("AddrMarkNotFound "); 224 printk("}"); 225 if (hd_error & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) { 226 printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL), 227 inb(HD_CURRENT) & 0xf, inb(HD_SECTOR)); 228 if (CURRENT) 229 printk(", sector=%ld", CURRENT->sector); 230 } 231 printk("\n"); 232 } 233#else 234 printk("%s: %s: status=0x%02x.\n", name, msg, stat & 0xff); 235 if ((stat & ERR_STAT) == 0) { 236 hd_error = 0; 237 } else { 238 hd_error = inb(HD_ERROR); 239 printk("%s: %s: error=0x%02x.\n", name, msg, hd_error & 0xff); 240 } 241#endif 242} 243 244static void check_status(void) 245{ 246 int i = inb_p(HD_STATUS); 247 248 if (!OK_STATUS(i)) { 249 dump_status("check_status", i); 250 bad_rw_intr(); 251 } 252} 253 254static int controller_busy(void) 255{ 256 int retries = 100000; 257 unsigned char status; 258 259 do { 260 status = inb_p(HD_STATUS); 261 } while ((status & BUSY_STAT) && --retries); 262 return status; 263} 264 265static int status_ok(void) 266{ 267 unsigned char status = inb_p(HD_STATUS); 268 269 if (status & BUSY_STAT) 270 return 1; /* Ancient, but does it make sense??? */ 271 if (status & WRERR_STAT) 272 return 0; 273 if (!(status & READY_STAT)) 274 return 0; 275 if (!(status & SEEK_STAT)) 276 return 0; 277 return 1; 278} 279 280static int controller_ready(unsigned int drive, unsigned int head) 281{ 282 int retry = 100; 283 284 do { 285 if (controller_busy() & BUSY_STAT) 286 return 0; 287 outb_p(0xA0 | (drive<<4) | head, HD_CURRENT); 288 if (status_ok()) 289 return 1; 290 } while (--retry); 291 return 0; 292} 293 294 295static void hd_out(struct hd_i_struct *disk, 296 unsigned int nsect, 297 unsigned int sect, 298 unsigned int head, 299 unsigned int cyl, 300 unsigned int cmd, 301 void (*intr_addr)(void)) 302{ 303 unsigned short port; 304 305#if (HD_DELAY > 0) 306 while (read_timer() - last_req < HD_DELAY) 307 /* nothing */; 308#endif 309 if (reset) 310 return; 311 if (!controller_ready(disk->unit, head)) { 312 reset = 1; 313 return; 314 } 315 SET_HANDLER(intr_addr); 316 outb_p(disk->ctl,HD_CMD); 317 port=HD_DATA; 318 outb_p(disk->wpcom>>2,++port); 319 outb_p(nsect,++port); 320 outb_p(sect,++port); 321 outb_p(cyl,++port); 322 outb_p(cyl>>8,++port); 323 outb_p(0xA0|(disk->unit<<4)|head,++port); 324 outb_p(cmd,++port); 325} 326 327static void hd_request (void); 328 329static int drive_busy(void) 330{ 331 unsigned int i; 332 unsigned char c; 333 334 for (i = 0; i < 500000 ; i++) { 335 c = inb_p(HD_STATUS); 336 if ((c & (BUSY_STAT | READY_STAT | SEEK_STAT)) == STAT_OK) 337 return 0; 338 } 339 dump_status("reset timed out", c); 340 return 1; 341} 342 343static void reset_controller(void) 344{ 345 int i; 346 347 outb_p(4,HD_CMD); 348 for(i = 0; i < 1000; i++) barrier(); 349 outb_p(hd_info[0].ctl & 0x0f,HD_CMD); 350 for(i = 0; i < 1000; i++) barrier(); 351 if (drive_busy()) 352 printk("hd: controller still busy\n"); 353 else if ((hd_error = inb(HD_ERROR)) != 1) 354 printk("hd: controller reset failed: %02x\n",hd_error); 355} 356 357static void reset_hd(void) 358{ 359 static int i; 360 361repeat: 362 if (reset) { 363 reset = 0; 364 i = -1; 365 reset_controller(); 366 } else { 367 check_status(); 368 if (reset) 369 goto repeat; 370 } 371 if (++i < NR_HD) { 372 struct hd_i_struct *disk = &hd_info[i]; 373 disk->special_op = disk->recalibrate = 1; 374 hd_out(disk,disk->sect,disk->sect,disk->head-1, 375 disk->cyl,WIN_SPECIFY,&reset_hd); 376 if (reset) 377 goto repeat; 378 } else 379 hd_request(); 380} 381 382/* 383 * Ok, don't know what to do with the unexpected interrupts: on some machines 384 * doing a reset and a retry seems to result in an eternal loop. Right now I 385 * ignore it, and just set the timeout. 386 * 387 * On laptops (and "green" PCs), an unexpected interrupt occurs whenever the 388 * drive enters "idle", "standby", or "sleep" mode, so if the status looks 389 * "good", we just ignore the interrupt completely. 390 */ 391static void unexpected_hd_interrupt(void) 392{ 393 unsigned int stat = inb_p(HD_STATUS); 394 395 if (stat & (BUSY_STAT|DRQ_STAT|ECC_STAT|ERR_STAT)) { 396 dump_status ("unexpected interrupt", stat); 397 SET_TIMER; 398 } 399} 400 401/* 402 * bad_rw_intr() now tries to be a bit smarter and does things 403 * according to the error returned by the controller. 404 * -Mika Liljeberg (liljeber@cs.Helsinki.FI) 405 */ 406static void bad_rw_intr(void) 407{ 408 struct request *req = CURRENT; 409 if (req != NULL) { 410 struct hd_i_struct *disk = req->rq_disk->private_data; 411 if (++req->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) { 412 end_request(req, 0); 413 disk->special_op = disk->recalibrate = 1; 414 } else if (req->errors % RESET_FREQ == 0) 415 reset = 1; 416 else if ((hd_error & TRK0_ERR) || req->errors % RECAL_FREQ == 0) 417 disk->special_op = disk->recalibrate = 1; 418 /* Otherwise just retry */ 419 } 420} 421 422static inline int wait_DRQ(void) 423{ 424 int retries = 100000, stat; 425 426 while (--retries > 0) 427 if ((stat = inb_p(HD_STATUS)) & DRQ_STAT) 428 return 0; 429 dump_status("wait_DRQ", stat); 430 return -1; 431} 432 433static void read_intr(void) 434{ 435 struct request *req; 436 int i, retries = 100000; 437 438 do { 439 i = (unsigned) inb_p(HD_STATUS); 440 if (i & BUSY_STAT) 441 continue; 442 if (!OK_STATUS(i)) 443 break; 444 if (i & DRQ_STAT) 445 goto ok_to_read; 446 } while (--retries > 0); 447 dump_status("read_intr", i); 448 bad_rw_intr(); 449 hd_request(); 450 return; 451ok_to_read: 452 req = CURRENT; 453 insw(HD_DATA,req->buffer,256); 454 req->sector++; 455 req->buffer += 512; 456 req->errors = 0; 457 i = --req->nr_sectors; 458 --req->current_nr_sectors; 459#ifdef DEBUG 460 printk("%s: read: sector %ld, remaining = %ld, buffer=%p\n", 461 req->rq_disk->disk_name, req->sector, req->nr_sectors, 462 req->buffer+512); 463#endif 464 if (req->current_nr_sectors <= 0) 465 end_request(req, 1); 466 if (i > 0) { 467 SET_HANDLER(&read_intr); 468 return; 469 } 470 (void) inb_p(HD_STATUS); 471#if (HD_DELAY > 0) 472 last_req = read_timer(); 473#endif 474 if (elv_next_request(QUEUE)) 475 hd_request(); 476 return; 477} 478 479static void write_intr(void) 480{ 481 struct request *req = CURRENT; 482 int i; 483 int retries = 100000; 484 485 do { 486 i = (unsigned) inb_p(HD_STATUS); 487 if (i & BUSY_STAT) 488 continue; 489 if (!OK_STATUS(i)) 490 break; 491 if ((req->nr_sectors <= 1) || (i & DRQ_STAT)) 492 goto ok_to_write; 493 } while (--retries > 0); 494 dump_status("write_intr", i); 495 bad_rw_intr(); 496 hd_request(); 497 return; 498ok_to_write: 499 req->sector++; 500 i = --req->nr_sectors; 501 --req->current_nr_sectors; 502 req->buffer += 512; 503 if (!i || (req->bio && req->current_nr_sectors <= 0)) 504 end_request(req, 1); 505 if (i > 0) { 506 SET_HANDLER(&write_intr); 507 outsw(HD_DATA,req->buffer,256); 508 local_irq_enable(); 509 } else { 510#if (HD_DELAY > 0) 511 last_req = read_timer(); 512#endif 513 hd_request(); 514 } 515 return; 516} 517 518static void recal_intr(void) 519{ 520 check_status(); 521#if (HD_DELAY > 0) 522 last_req = read_timer(); 523#endif 524 hd_request(); 525} 526 527/* 528 * This is another of the error-routines I don't know what to do with. The 529 * best idea seems to just set reset, and start all over again. 530 */ 531static void hd_times_out(unsigned long dummy) 532{ 533 char *name; 534 535 do_hd = NULL; 536 537 if (!CURRENT) 538 return; 539 540 disable_irq(HD_IRQ); 541 local_irq_enable(); 542 reset = 1; 543 name = CURRENT->rq_disk->disk_name; 544 printk("%s: timeout\n", name); 545 if (++CURRENT->errors >= MAX_ERRORS) { 546#ifdef DEBUG 547 printk("%s: too many errors\n", name); 548#endif 549 end_request(CURRENT, 0); 550 } 551 local_irq_disable(); 552 hd_request(); 553 enable_irq(HD_IRQ); 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,WIN_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 end_request(req, 0); 566 } 567 disk->special_op = 0; 568 return 1; 569} 570 571/* 572 * The driver enables interrupts as much as possible. In order to do this, 573 * (a) the device-interrupt is disabled before entering hd_request(), 574 * and (b) the timeout-interrupt is disabled before the sti(). 575 * 576 * Interrupts are still masked (by default) whenever we are exchanging 577 * data/cmds with a drive, because some drives seem to have very poor 578 * tolerance for latency during I/O. The IDE driver has support to unmask 579 * interrupts for non-broken hardware, so use that driver if required. 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 local_irq_enable(); 592 593 req = CURRENT; 594 if (!req) { 595 do_hd = NULL; 596 return; 597 } 598 599 if (reset) { 600 local_irq_disable(); 601 reset_hd(); 602 return; 603 } 604 disk = req->rq_disk->private_data; 605 block = req->sector; 606 nsect = req->nr_sectors; 607 if (block >= get_capacity(req->rq_disk) || 608 ((block+nsect) > get_capacity(req->rq_disk))) { 609 printk("%s: bad access: block=%d, count=%d\n", 610 req->rq_disk->disk_name, block, nsect); 611 end_request(req, 0); 612 goto repeat; 613 } 614 615 if (disk->special_op) { 616 if (do_special_op(disk, req)) 617 goto repeat; 618 return; 619 } 620 sec = block % disk->sect + 1; 621 track = block / disk->sect; 622 head = track % disk->head; 623 cyl = track / disk->head; 624#ifdef DEBUG 625 printk("%s: %sing: CHS=%d/%d/%d, sectors=%d, buffer=%p\n", 626 req->rq_disk->disk_name, (req->cmd == READ)?"read":"writ", 627 cyl, head, sec, nsect, req->buffer); 628#endif 629 if (blk_fs_request(req)) { 630 switch (rq_data_dir(req)) { 631 case READ: 632 hd_out(disk,nsect,sec,head,cyl,WIN_READ,&read_intr); 633 if (reset) 634 goto repeat; 635 break; 636 case WRITE: 637 hd_out(disk,nsect,sec,head,cyl,WIN_WRITE,&write_intr); 638 if (reset) 639 goto repeat; 640 if (wait_DRQ()) { 641 bad_rw_intr(); 642 goto repeat; 643 } 644 outsw(HD_DATA,req->buffer,256); 645 break; 646 default: 647 printk("unknown hd-command\n"); 648 end_request(req, 0); 649 break; 650 } 651 } 652} 653 654static void do_hd_request (request_queue_t * q) 655{ 656 disable_irq(HD_IRQ); 657 hd_request(); 658 enable_irq(HD_IRQ); 659} 660 661static int hd_getgeo(struct block_device *bdev, struct hd_geometry *geo) 662{ 663 struct hd_i_struct *disk = bdev->bd_disk->private_data; 664 665 geo->heads = disk->head; 666 geo->sectors = disk->sect; 667 geo->cylinders = disk->cyl; 668 return 0; 669} 670 671/* 672 * Releasing a block device means we sync() it, so that it can safely 673 * be forgotten about... 674 */ 675 676static irqreturn_t hd_interrupt(int irq, void *dev_id) 677{ 678 void (*handler)(void) = do_hd; 679 680 do_hd = NULL; 681 del_timer(&device_timer); 682 if (!handler) 683 handler = unexpected_hd_interrupt; 684 handler(); 685 local_irq_enable(); 686 return IRQ_HANDLED; 687} 688 689static struct block_device_operations hd_fops = { 690 .getgeo = hd_getgeo, 691}; 692 693/* 694 * This is the hard disk IRQ description. The IRQF_DISABLED in sa_flags 695 * means we run the IRQ-handler with interrupts disabled: this is bad for 696 * interrupt latency, but anything else has led to problems on some 697 * machines. 698 * 699 * We enable interrupts in some of the routines after making sure it's 700 * safe. 701 */ 702 703static int __init hd_init(void) 704{ 705 int drive; 706 707 if (register_blkdev(MAJOR_NR,"hd")) 708 return -1; 709 710 hd_queue = blk_init_queue(do_hd_request, &hd_lock); 711 if (!hd_queue) { 712 unregister_blkdev(MAJOR_NR,"hd"); 713 return -ENOMEM; 714 } 715 716 blk_queue_max_sectors(hd_queue, 255); 717 init_timer(&device_timer); 718 device_timer.function = hd_times_out; 719 blk_queue_hardsect_size(hd_queue, 512); 720 721#ifdef __i386__ 722 if (!NR_HD) { 723 extern struct drive_info drive_info; 724 unsigned char *BIOS = (unsigned char *) &drive_info; 725 unsigned long flags; 726 int cmos_disks; 727 728 for (drive=0 ; drive<2 ; drive++) { 729 hd_info[drive].cyl = *(unsigned short *) BIOS; 730 hd_info[drive].head = *(2+BIOS); 731 hd_info[drive].wpcom = *(unsigned short *) (5+BIOS); 732 hd_info[drive].ctl = *(8+BIOS); 733 hd_info[drive].lzone = *(unsigned short *) (12+BIOS); 734 hd_info[drive].sect = *(14+BIOS); 735#ifdef does_not_work_for_everybody_with_scsi_but_helps_ibm_vp 736 if (hd_info[drive].cyl && NR_HD == drive) 737 NR_HD++; 738#endif 739 BIOS += 16; 740 } 741 742 /* 743 We query CMOS about hard disks : it could be that 744 we have a SCSI/ESDI/etc controller that is BIOS 745 compatible with ST-506, and thus showing up in our 746 BIOS table, but not register compatible, and therefore 747 not present in CMOS. 748 749 Furthermore, we will assume that our ST-506 drives 750 <if any> are the primary drives in the system, and 751 the ones reflected as drive 1 or 2. 752 753 The first drive is stored in the high nibble of CMOS 754 byte 0x12, the second in the low nibble. This will be 755 either a 4 bit drive type or 0xf indicating use byte 0x19 756 for an 8 bit type, drive 1, 0x1a for drive 2 in CMOS. 757 758 Needless to say, a non-zero value means we have 759 an AT controller hard disk for that drive. 760 761 Currently the rtc_lock is a bit academic since this 762 driver is non-modular, but someday... ? Paul G. 763 */ 764 765 spin_lock_irqsave(&rtc_lock, flags); 766 cmos_disks = CMOS_READ(0x12); 767 spin_unlock_irqrestore(&rtc_lock, flags); 768 769 if (cmos_disks & 0xf0) { 770 if (cmos_disks & 0x0f) 771 NR_HD = 2; 772 else 773 NR_HD = 1; 774 } 775 } 776#endif /* __i386__ */ 777#ifdef __arm__ 778 if (!NR_HD) { 779 /* We don't know anything about the drive. This means 780 * that you *MUST* specify the drive parameters to the 781 * kernel yourself. 782 */ 783 printk("hd: no drives specified - use hd=cyl,head,sectors" 784 " on kernel command line\n"); 785 } 786#endif 787 if (!NR_HD) 788 goto out; 789 790 for (drive=0 ; drive < NR_HD ; drive++) { 791 struct gendisk *disk = alloc_disk(64); 792 struct hd_i_struct *p = &hd_info[drive]; 793 if (!disk) 794 goto Enomem; 795 disk->major = MAJOR_NR; 796 disk->first_minor = drive << 6; 797 disk->fops = &hd_fops; 798 sprintf(disk->disk_name, "hd%c", 'a'+drive); 799 disk->private_data = p; 800 set_capacity(disk, p->head * p->sect * p->cyl); 801 disk->queue = hd_queue; 802 p->unit = drive; 803 hd_gendisk[drive] = disk; 804 printk ("%s: %luMB, CHS=%d/%d/%d\n", 805 disk->disk_name, (unsigned long)get_capacity(disk)/2048, 806 p->cyl, p->head, p->sect); 807 } 808 809 if (request_irq(HD_IRQ, hd_interrupt, IRQF_DISABLED, "hd", NULL)) { 810 printk("hd: unable to get IRQ%d for the hard disk driver\n", 811 HD_IRQ); 812 goto out1; 813 } 814 if (!request_region(HD_DATA, 8, "hd")) { 815 printk(KERN_WARNING "hd: port 0x%x busy\n", HD_DATA); 816 goto out2; 817 } 818 if (!request_region(HD_CMD, 1, "hd(cmd)")) { 819 printk(KERN_WARNING "hd: port 0x%x busy\n", HD_CMD); 820 goto out3; 821 } 822 823 /* Let them fly */ 824 for(drive=0; drive < NR_HD; drive++) 825 add_disk(hd_gendisk[drive]); 826 827 return 0; 828 829out3: 830 release_region(HD_DATA, 8); 831out2: 832 free_irq(HD_IRQ, NULL); 833out1: 834 for (drive = 0; drive < NR_HD; drive++) 835 put_disk(hd_gendisk[drive]); 836 NR_HD = 0; 837out: 838 del_timer(&device_timer); 839 unregister_blkdev(MAJOR_NR,"hd"); 840 blk_cleanup_queue(hd_queue); 841 return -1; 842Enomem: 843 while (drive--) 844 put_disk(hd_gendisk[drive]); 845 goto out; 846} 847 848static int __init parse_hd_setup (char *line) { 849 int ints[6]; 850 851 (void) get_options(line, ARRAY_SIZE(ints), ints); 852 hd_setup(NULL, ints); 853 854 return 1; 855} 856__setup("hd=", parse_hd_setup); 857 858module_init(hd_init); 859