blob: baaa9e486e508d354b1818f2ec427c32691c1db9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/init.h>
41#include <linux/blkpg.h>
Bartlomiej Zolnierkiewiczf26b3d72008-10-10 22:39:21 +020042#include <linux/ata.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/hdreg.h>
44
Bartlomiej Zolnierkiewicz4fe6e302009-04-01 21:42:25 +020045#define HD_IRQ 14
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#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/* Hd controller regster ports */
61
62#define HD_DATA 0x1f0 /* _CTL when writing */
63#define HD_ERROR 0x1f1 /* see err-bits */
64#define HD_NSECTOR 0x1f2 /* nr of sectors to read/write */
65#define HD_SECTOR 0x1f3 /* starting sector */
66#define HD_LCYL 0x1f4 /* starting cylinder */
67#define HD_HCYL 0x1f5 /* high byte of starting cyl */
68#define HD_CURRENT 0x1f6 /* 101dhhhh , d=drive, hhhh=head */
69#define HD_STATUS 0x1f7 /* see status-bits */
70#define HD_FEATURE HD_ERROR /* same io address, read=error, write=feature */
71#define HD_PRECOMP HD_FEATURE /* obsolete use of this port - predates IDE */
72#define HD_COMMAND HD_STATUS /* same io address, read=status, write=cmd */
73
74#define HD_CMD 0x3f6 /* used for resets */
75#define HD_ALTSTATUS 0x3f6 /* same as HD_STATUS but doesn't clear irq */
76
77/* Bits of HD_STATUS */
78#define ERR_STAT 0x01
79#define INDEX_STAT 0x02
80#define ECC_STAT 0x04 /* Corrected error */
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/* Bits for HD_ERROR */
89#define MARK_ERR 0x01 /* Bad address mark */
90#define TRK0_ERR 0x02 /* couldn't find track 0 */
91#define ABRT_ERR 0x04 /* Command aborted */
92#define MCR_ERR 0x08 /* media change request */
93#define ID_ERR 0x10 /* ID field not found */
94#define MC_ERR 0x20 /* media changed */
95#define ECC_ERR 0x40 /* Uncorrectable ECC error */
96#define BBD_ERR 0x80 /* pre-EIDE meaning: block marked bad */
97#define ICRC_ERR 0x80 /* new meaning: CRC error during transfer */
98
99static DEFINE_SPINLOCK(hd_lock);
100static struct request_queue *hd_queue;
101
102#define MAJOR_NR HD_MAJOR
103#define QUEUE (hd_queue)
104#define CURRENT elv_next_request(hd_queue)
105
106#define TIMEOUT_VALUE (6*HZ)
107#define HD_DELAY 0
108
109#define MAX_ERRORS 16 /* Max read/write errors/sector */
110#define RESET_FREQ 8 /* Reset controller every 8th retry */
111#define RECAL_FREQ 4 /* Recalibrate every 4th retry */
112#define MAX_HD 2
113
114#define STAT_OK (READY_STAT|SEEK_STAT)
115#define OK_STATUS(s) (((s)&(STAT_OK|(BUSY_STAT|WRERR_STAT|ERR_STAT)))==STAT_OK)
116
117static void recal_intr(void);
118static void bad_rw_intr(void);
119
120static int reset;
121static int hd_error;
122
123/*
124 * This struct defines the HD's and their types.
125 */
126struct hd_i_struct {
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200127 unsigned int head, sect, cyl, wpcom, lzone, ctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 int unit;
129 int recalibrate;
130 int special_op;
131};
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200132
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133#ifdef HD_TYPE
134static struct hd_i_struct hd_info[] = { HD_TYPE };
Andi Drebesecea5732007-07-09 23:17:57 +0200135static int NR_HD = ARRAY_SIZE(hd_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136#else
137static struct hd_i_struct hd_info[MAX_HD];
138static int NR_HD;
139#endif
140
141static struct gendisk *hd_gendisk[MAX_HD];
142
143static struct timer_list device_timer;
144
145#define TIMEOUT_VALUE (6*HZ)
146
147#define SET_TIMER \
148 do { \
149 mod_timer(&device_timer, jiffies + TIMEOUT_VALUE); \
150 } while (0)
151
152static void (*do_hd)(void) = NULL;
153#define SET_HANDLER(x) \
154if ((do_hd = (x)) != NULL) \
155 SET_TIMER; \
156else \
157 del_timer(&device_timer);
158
159
160#if (HD_DELAY > 0)
Ingo Molnar306e4402005-06-30 02:58:55 -0700161
162#include <asm/i8253.h>
163
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164unsigned long last_req;
165
166unsigned long read_timer(void)
167{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 unsigned long t, flags;
169 int i;
170
171 spin_lock_irqsave(&i8253_lock, flags);
172 t = jiffies * 11932;
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200173 outb_p(0, 0x43);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 i = inb_p(0x40);
175 i |= inb(0x40) << 8;
176 spin_unlock_irqrestore(&i8253_lock, flags);
177 return(t - i);
178}
179#endif
180
181static void __init hd_setup(char *str, int *ints)
182{
183 int hdind = 0;
184
185 if (ints[0] != 3)
186 return;
187 if (hd_info[0].head != 0)
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200188 hdind = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 hd_info[hdind].head = ints[2];
190 hd_info[hdind].sect = ints[3];
191 hd_info[hdind].cyl = ints[1];
192 hd_info[hdind].wpcom = 0;
193 hd_info[hdind].lzone = ints[1];
194 hd_info[hdind].ctl = (ints[2] > 8 ? 8 : 0);
195 NR_HD = hdind+1;
196}
197
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200198static void dump_status(const char *msg, unsigned int stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199{
200 char *name = "hd?";
201 if (CURRENT)
202 name = CURRENT->rq_disk->disk_name;
203
204#ifdef VERBOSE_ERRORS
205 printk("%s: %s: status=0x%02x { ", name, msg, stat & 0xff);
206 if (stat & BUSY_STAT) printk("Busy ");
207 if (stat & READY_STAT) printk("DriveReady ");
208 if (stat & WRERR_STAT) printk("WriteFault ");
209 if (stat & SEEK_STAT) printk("SeekComplete ");
210 if (stat & DRQ_STAT) printk("DataRequest ");
211 if (stat & ECC_STAT) printk("CorrectedError ");
212 if (stat & INDEX_STAT) printk("Index ");
213 if (stat & ERR_STAT) printk("Error ");
214 printk("}\n");
215 if ((stat & ERR_STAT) == 0) {
216 hd_error = 0;
217 } else {
218 hd_error = inb(HD_ERROR);
219 printk("%s: %s: error=0x%02x { ", name, msg, hd_error & 0xff);
220 if (hd_error & BBD_ERR) printk("BadSector ");
221 if (hd_error & ECC_ERR) printk("UncorrectableError ");
222 if (hd_error & ID_ERR) printk("SectorIdNotFound ");
223 if (hd_error & ABRT_ERR) printk("DriveStatusError ");
224 if (hd_error & TRK0_ERR) printk("TrackZeroNotFound ");
225 if (hd_error & MARK_ERR) printk("AddrMarkNotFound ");
226 printk("}");
227 if (hd_error & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
228 printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL),
229 inb(HD_CURRENT) & 0xf, inb(HD_SECTOR));
230 if (CURRENT)
231 printk(", sector=%ld", CURRENT->sector);
232 }
233 printk("\n");
234 }
235#else
236 printk("%s: %s: status=0x%02x.\n", name, msg, stat & 0xff);
237 if ((stat & ERR_STAT) == 0) {
238 hd_error = 0;
239 } else {
240 hd_error = inb(HD_ERROR);
241 printk("%s: %s: error=0x%02x.\n", name, msg, hd_error & 0xff);
242 }
243#endif
244}
245
246static void check_status(void)
247{
248 int i = inb_p(HD_STATUS);
249
250 if (!OK_STATUS(i)) {
251 dump_status("check_status", i);
252 bad_rw_intr();
253 }
254}
255
256static int controller_busy(void)
257{
258 int retries = 100000;
259 unsigned char status;
260
261 do {
262 status = inb_p(HD_STATUS);
263 } while ((status & BUSY_STAT) && --retries);
264 return status;
265}
266
267static int status_ok(void)
268{
269 unsigned char status = inb_p(HD_STATUS);
270
271 if (status & BUSY_STAT)
272 return 1; /* Ancient, but does it make sense??? */
273 if (status & WRERR_STAT)
274 return 0;
275 if (!(status & READY_STAT))
276 return 0;
277 if (!(status & SEEK_STAT))
278 return 0;
279 return 1;
280}
281
282static int controller_ready(unsigned int drive, unsigned int head)
283{
284 int retry = 100;
285
286 do {
287 if (controller_busy() & BUSY_STAT)
288 return 0;
289 outb_p(0xA0 | (drive<<4) | head, HD_CURRENT);
290 if (status_ok())
291 return 1;
292 } while (--retry);
293 return 0;
294}
295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296static void hd_out(struct hd_i_struct *disk,
297 unsigned int nsect,
298 unsigned int sect,
299 unsigned int head,
300 unsigned int cyl,
301 unsigned int cmd,
302 void (*intr_addr)(void))
303{
304 unsigned short port;
305
306#if (HD_DELAY > 0)
307 while (read_timer() - last_req < HD_DELAY)
308 /* nothing */;
309#endif
310 if (reset)
311 return;
312 if (!controller_ready(disk->unit, head)) {
313 reset = 1;
314 return;
315 }
316 SET_HANDLER(intr_addr);
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200317 outb_p(disk->ctl, HD_CMD);
318 port = HD_DATA;
319 outb_p(disk->wpcom >> 2, ++port);
320 outb_p(nsect, ++port);
321 outb_p(sect, ++port);
322 outb_p(cyl, ++port);
323 outb_p(cyl >> 8, ++port);
324 outb_p(0xA0 | (disk->unit << 4) | head, ++port);
325 outb_p(cmd, ++port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
328static void hd_request (void);
329
330static int drive_busy(void)
331{
332 unsigned int i;
333 unsigned char c;
334
335 for (i = 0; i < 500000 ; i++) {
336 c = inb_p(HD_STATUS);
337 if ((c & (BUSY_STAT | READY_STAT | SEEK_STAT)) == STAT_OK)
338 return 0;
339 }
340 dump_status("reset timed out", c);
341 return 1;
342}
343
344static void reset_controller(void)
345{
346 int i;
347
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200348 outb_p(4, HD_CMD);
349 for (i = 0; i < 1000; i++) barrier();
350 outb_p(hd_info[0].ctl & 0x0f, HD_CMD);
351 for (i = 0; i < 1000; i++) barrier();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 if (drive_busy())
353 printk("hd: controller still busy\n");
354 else if ((hd_error = inb(HD_ERROR)) != 1)
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200355 printk("hd: controller reset failed: %02x\n", hd_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356}
357
358static void reset_hd(void)
359{
360 static int i;
361
362repeat:
363 if (reset) {
364 reset = 0;
365 i = -1;
366 reset_controller();
367 } else {
368 check_status();
369 if (reset)
370 goto repeat;
371 }
372 if (++i < NR_HD) {
373 struct hd_i_struct *disk = &hd_info[i];
374 disk->special_op = disk->recalibrate = 1;
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200375 hd_out(disk, disk->sect, disk->sect, disk->head-1,
Bartlomiej Zolnierkiewiczf26b3d72008-10-10 22:39:21 +0200376 disk->cyl, ATA_CMD_INIT_DEV_PARAMS, &reset_hd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 if (reset)
378 goto repeat;
379 } else
380 hd_request();
381}
382
383/*
384 * Ok, don't know what to do with the unexpected interrupts: on some machines
385 * doing a reset and a retry seems to result in an eternal loop. Right now I
386 * ignore it, and just set the timeout.
387 *
388 * On laptops (and "green" PCs), an unexpected interrupt occurs whenever the
389 * drive enters "idle", "standby", or "sleep" mode, so if the status looks
390 * "good", we just ignore the interrupt completely.
391 */
392static void unexpected_hd_interrupt(void)
393{
394 unsigned int stat = inb_p(HD_STATUS);
395
396 if (stat & (BUSY_STAT|DRQ_STAT|ECC_STAT|ERR_STAT)) {
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200397 dump_status("unexpected interrupt", stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 SET_TIMER;
399 }
400}
401
402/*
403 * bad_rw_intr() now tries to be a bit smarter and does things
404 * according to the error returned by the controller.
405 * -Mika Liljeberg (liljeber@cs.Helsinki.FI)
406 */
407static void bad_rw_intr(void)
408{
409 struct request *req = CURRENT;
410 if (req != NULL) {
411 struct hd_i_struct *disk = req->rq_disk->private_data;
412 if (++req->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {
413 end_request(req, 0);
414 disk->special_op = disk->recalibrate = 1;
415 } else if (req->errors % RESET_FREQ == 0)
416 reset = 1;
417 else if ((hd_error & TRK0_ERR) || req->errors % RECAL_FREQ == 0)
418 disk->special_op = disk->recalibrate = 1;
419 /* Otherwise just retry */
420 }
421}
422
423static inline int wait_DRQ(void)
424{
Andrew Mortonb0042232008-02-06 02:57:49 +0100425 int retries;
426 int stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
Andrew Mortonb0042232008-02-06 02:57:49 +0100428 for (retries = 0; retries < 100000; retries++) {
429 stat = inb_p(HD_STATUS);
430 if (stat & DRQ_STAT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 return 0;
Andrew Mortonb0042232008-02-06 02:57:49 +0100432 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 dump_status("wait_DRQ", stat);
434 return -1;
435}
436
437static void read_intr(void)
438{
439 struct request *req;
440 int i, retries = 100000;
441
442 do {
443 i = (unsigned) inb_p(HD_STATUS);
444 if (i & BUSY_STAT)
445 continue;
446 if (!OK_STATUS(i))
447 break;
448 if (i & DRQ_STAT)
449 goto ok_to_read;
450 } while (--retries > 0);
451 dump_status("read_intr", i);
452 bad_rw_intr();
453 hd_request();
454 return;
455ok_to_read:
456 req = CURRENT;
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200457 insw(HD_DATA, req->buffer, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 req->sector++;
459 req->buffer += 512;
460 req->errors = 0;
461 i = --req->nr_sectors;
462 --req->current_nr_sectors;
463#ifdef DEBUG
464 printk("%s: read: sector %ld, remaining = %ld, buffer=%p\n",
465 req->rq_disk->disk_name, req->sector, req->nr_sectors,
Nicolas Kaiser6a34b572006-11-14 02:03:28 -0800466 req->buffer+512);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467#endif
468 if (req->current_nr_sectors <= 0)
469 end_request(req, 1);
470 if (i > 0) {
471 SET_HANDLER(&read_intr);
472 return;
473 }
474 (void) inb_p(HD_STATUS);
475#if (HD_DELAY > 0)
476 last_req = read_timer();
477#endif
478 if (elv_next_request(QUEUE))
479 hd_request();
480 return;
481}
482
483static void write_intr(void)
484{
485 struct request *req = CURRENT;
486 int i;
487 int retries = 100000;
488
489 do {
490 i = (unsigned) inb_p(HD_STATUS);
491 if (i & BUSY_STAT)
492 continue;
493 if (!OK_STATUS(i))
494 break;
495 if ((req->nr_sectors <= 1) || (i & DRQ_STAT))
496 goto ok_to_write;
497 } while (--retries > 0);
498 dump_status("write_intr", i);
499 bad_rw_intr();
500 hd_request();
501 return;
502ok_to_write:
503 req->sector++;
504 i = --req->nr_sectors;
505 --req->current_nr_sectors;
506 req->buffer += 512;
507 if (!i || (req->bio && req->current_nr_sectors <= 0))
508 end_request(req, 1);
509 if (i > 0) {
510 SET_HANDLER(&write_intr);
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200511 outsw(HD_DATA, req->buffer, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 } else {
513#if (HD_DELAY > 0)
514 last_req = read_timer();
515#endif
516 hd_request();
517 }
518 return;
519}
520
521static void recal_intr(void)
522{
523 check_status();
524#if (HD_DELAY > 0)
525 last_req = read_timer();
526#endif
527 hd_request();
528}
529
530/*
531 * This is another of the error-routines I don't know what to do with. The
532 * best idea seems to just set reset, and start all over again.
533 */
534static void hd_times_out(unsigned long dummy)
535{
536 char *name;
537
538 do_hd = NULL;
539
540 if (!CURRENT)
541 return;
542
Tejun Heo01919442009-04-28 12:38:33 +0900543 spin_lock_irq(hd_queue->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 reset = 1;
545 name = CURRENT->rq_disk->disk_name;
546 printk("%s: timeout\n", name);
547 if (++CURRENT->errors >= MAX_ERRORS) {
548#ifdef DEBUG
549 printk("%s: too many errors\n", name);
550#endif
551 end_request(CURRENT, 0);
552 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 hd_request();
Tejun Heo01919442009-04-28 12:38:33 +0900554 spin_unlock_irq(hd_queue->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555}
556
557static int do_special_op(struct hd_i_struct *disk, struct request *req)
558{
559 if (disk->recalibrate) {
560 disk->recalibrate = 0;
Bartlomiej Zolnierkiewiczf26b3d72008-10-10 22:39:21 +0200561 hd_out(disk, disk->sect, 0, 0, 0, ATA_CMD_RESTORE, &recal_intr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 return reset;
563 }
564 if (disk->head > 16) {
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200565 printk("%s: cannot handle device with more than 16 heads - giving up\n", req->rq_disk->disk_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 end_request(req, 0);
567 }
568 disk->special_op = 0;
569 return 1;
570}
571
572/*
573 * The driver enables interrupts as much as possible. In order to do this,
574 * (a) the device-interrupt is disabled before entering hd_request(),
575 * and (b) the timeout-interrupt is disabled before the sti().
576 *
577 * Interrupts are still masked (by default) whenever we are exchanging
578 * data/cmds with a drive, because some drives seem to have very poor
579 * tolerance for latency during I/O. The IDE driver has support to unmask
580 * interrupts for non-broken hardware, so use that driver if required.
581 */
582static void hd_request(void)
583{
584 unsigned int block, nsect, sec, track, head, cyl;
585 struct hd_i_struct *disk;
586 struct request *req;
587
588 if (do_hd)
589 return;
590repeat:
591 del_timer(&device_timer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
593 req = CURRENT;
594 if (!req) {
595 do_hd = NULL;
596 return;
597 }
598
599 if (reset) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 reset_hd();
601 return;
602 }
603 disk = req->rq_disk->private_data;
604 block = req->sector;
605 nsect = req->nr_sectors;
606 if (block >= get_capacity(req->rq_disk) ||
607 ((block+nsect) > get_capacity(req->rq_disk))) {
608 printk("%s: bad access: block=%d, count=%d\n",
609 req->rq_disk->disk_name, block, nsect);
610 end_request(req, 0);
611 goto repeat;
612 }
613
614 if (disk->special_op) {
615 if (do_special_op(disk, req))
616 goto repeat;
617 return;
618 }
619 sec = block % disk->sect + 1;
620 track = block / disk->sect;
621 head = track % disk->head;
622 cyl = track / disk->head;
623#ifdef DEBUG
624 printk("%s: %sing: CHS=%d/%d/%d, sectors=%d, buffer=%p\n",
Boaz Harroshe654bc42007-06-20 13:53:23 +0200625 req->rq_disk->disk_name,
626 req_data_dir(req) == READ ? "read" : "writ",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 cyl, head, sec, nsect, req->buffer);
628#endif
Jens Axboe4aff5e22006-08-10 08:44:47 +0200629 if (blk_fs_request(req)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 switch (rq_data_dir(req)) {
631 case READ:
Bartlomiej Zolnierkiewiczf26b3d72008-10-10 22:39:21 +0200632 hd_out(disk, nsect, sec, head, cyl, ATA_CMD_PIO_READ,
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200633 &read_intr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 if (reset)
635 goto repeat;
636 break;
637 case WRITE:
Bartlomiej Zolnierkiewiczf26b3d72008-10-10 22:39:21 +0200638 hd_out(disk, nsect, sec, head, cyl, ATA_CMD_PIO_WRITE,
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200639 &write_intr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 if (reset)
641 goto repeat;
642 if (wait_DRQ()) {
643 bad_rw_intr();
644 goto repeat;
645 }
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200646 outsw(HD_DATA, req->buffer, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 break;
648 default:
649 printk("unknown hd-command\n");
650 end_request(req, 0);
651 break;
652 }
653 }
654}
655
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200656static void do_hd_request(struct request_queue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 hd_request();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659}
660
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800661static int hd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662{
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800663 struct hd_i_struct *disk = bdev->bd_disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800665 geo->heads = disk->head;
666 geo->sectors = disk->sect;
667 geo->cylinders = disk->cyl;
668 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669}
670
671/*
672 * Releasing a block device means we sync() it, so that it can safely
673 * be forgotten about...
674 */
675
David Howells7d12e782006-10-05 14:55:46 +0100676static irqreturn_t hd_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677{
678 void (*handler)(void) = do_hd;
679
Tejun Heo01919442009-04-28 12:38:33 +0900680 spin_lock(hd_queue->queue_lock);
681
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 do_hd = NULL;
683 del_timer(&device_timer);
684 if (!handler)
685 handler = unexpected_hd_interrupt;
686 handler();
Tejun Heo01919442009-04-28 12:38:33 +0900687
688 spin_unlock(hd_queue->queue_lock);
689
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 return IRQ_HANDLED;
691}
692
693static struct block_device_operations hd_fops = {
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800694 .getgeo = hd_getgeo,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695};
696
697/*
Thomas Gleixner362537b2006-07-01 19:29:34 -0700698 * This is the hard disk IRQ description. The IRQF_DISABLED in sa_flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 * means we run the IRQ-handler with interrupts disabled: this is bad for
700 * interrupt latency, but anything else has led to problems on some
701 * machines.
702 *
703 * We enable interrupts in some of the routines after making sure it's
704 * safe.
705 */
706
707static int __init hd_init(void)
708{
709 int drive;
710
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200711 if (register_blkdev(MAJOR_NR, "hd"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 return -1;
713
714 hd_queue = blk_init_queue(do_hd_request, &hd_lock);
715 if (!hd_queue) {
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200716 unregister_blkdev(MAJOR_NR, "hd");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 return -ENOMEM;
718 }
719
720 blk_queue_max_sectors(hd_queue, 255);
721 init_timer(&device_timer);
722 device_timer.function = hd_times_out;
723 blk_queue_hardsect_size(hd_queue, 512);
724
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 if (!NR_HD) {
H. Peter Anvin48dd6432007-07-11 12:18:27 -0700726 /*
727 * We don't know anything about the drive. This means
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 * that you *MUST* specify the drive parameters to the
729 * kernel yourself.
H. Peter Anvin48dd6432007-07-11 12:18:27 -0700730 *
731 * If we were on an i386, we used to read this info from
732 * the BIOS or CMOS. This doesn't work all that well,
733 * since this assumes that this is a primary or secondary
734 * drive, and if we're using this legacy driver, it's
735 * probably an auxilliary controller added to recover
736 * legacy data off an ST-506 drive. Either way, it's
737 * definitely safest to have the user explicitly specify
738 * the information.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 */
740 printk("hd: no drives specified - use hd=cyl,head,sectors"
741 " on kernel command line\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 goto out;
H. Peter Anvin48dd6432007-07-11 12:18:27 -0700743 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200745 for (drive = 0 ; drive < NR_HD ; drive++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 struct gendisk *disk = alloc_disk(64);
747 struct hd_i_struct *p = &hd_info[drive];
748 if (!disk)
749 goto Enomem;
750 disk->major = MAJOR_NR;
751 disk->first_minor = drive << 6;
752 disk->fops = &hd_fops;
753 sprintf(disk->disk_name, "hd%c", 'a'+drive);
754 disk->private_data = p;
755 set_capacity(disk, p->head * p->sect * p->cyl);
756 disk->queue = hd_queue;
757 p->unit = drive;
758 hd_gendisk[drive] = disk;
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200759 printk("%s: %luMB, CHS=%d/%d/%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 disk->disk_name, (unsigned long)get_capacity(disk)/2048,
761 p->cyl, p->head, p->sect);
762 }
763
Thomas Gleixner362537b2006-07-01 19:29:34 -0700764 if (request_irq(HD_IRQ, hd_interrupt, IRQF_DISABLED, "hd", NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 printk("hd: unable to get IRQ%d for the hard disk driver\n",
766 HD_IRQ);
767 goto out1;
768 }
769 if (!request_region(HD_DATA, 8, "hd")) {
770 printk(KERN_WARNING "hd: port 0x%x busy\n", HD_DATA);
771 goto out2;
772 }
773 if (!request_region(HD_CMD, 1, "hd(cmd)")) {
774 printk(KERN_WARNING "hd: port 0x%x busy\n", HD_CMD);
775 goto out3;
776 }
777
778 /* Let them fly */
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200779 for (drive = 0; drive < NR_HD; drive++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 add_disk(hd_gendisk[drive]);
781
782 return 0;
783
784out3:
785 release_region(HD_DATA, 8);
786out2:
787 free_irq(HD_IRQ, NULL);
788out1:
789 for (drive = 0; drive < NR_HD; drive++)
790 put_disk(hd_gendisk[drive]);
791 NR_HD = 0;
792out:
793 del_timer(&device_timer);
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200794 unregister_blkdev(MAJOR_NR, "hd");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 blk_cleanup_queue(hd_queue);
796 return -1;
797Enomem:
798 while (drive--)
799 put_disk(hd_gendisk[drive]);
800 goto out;
801}
802
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200803static int __init parse_hd_setup(char *line)
804{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 int ints[6];
806
807 (void) get_options(line, ARRAY_SIZE(ints), ints);
808 hd_setup(NULL, ints);
809
810 return 1;
811}
812__setup("hd=", parse_hd_setup);
813
Adrian Bunk01c22bf2008-07-16 20:33:47 +0200814late_initcall(hd_init);