blob: 5116c65c07cb71e9384372faaf7a7d9fa8c29d89 [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;
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900101static struct request *hd_req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103#define TIMEOUT_VALUE (6*HZ)
104#define HD_DELAY 0
105
106#define MAX_ERRORS 16 /* Max read/write errors/sector */
107#define RESET_FREQ 8 /* Reset controller every 8th retry */
108#define RECAL_FREQ 4 /* Recalibrate every 4th retry */
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 * This struct defines the HD's and their types.
122 */
123struct hd_i_struct {
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200124 unsigned int head, sect, cyl, wpcom, lzone, ctl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 int unit;
126 int recalibrate;
127 int special_op;
128};
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200129
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130#ifdef HD_TYPE
131static struct hd_i_struct hd_info[] = { HD_TYPE };
Andi Drebesecea5732007-07-09 23:17:57 +0200132static int NR_HD = ARRAY_SIZE(hd_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133#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)
Ingo Molnar306e4402005-06-30 02:58:55 -0700158
159#include <asm/i8253.h>
160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161unsigned long last_req;
162
163unsigned long read_timer(void)
164{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 unsigned long t, flags;
166 int i;
167
168 spin_lock_irqsave(&i8253_lock, flags);
169 t = jiffies * 11932;
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200170 outb_p(0, 0x43);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 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)
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200185 hdind = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 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
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900195static 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
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200208static void dump_status(const char *msg, unsigned int stat)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209{
210 char *name = "hd?";
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900211 if (hd_req)
212 name = hd_req->rq_disk->disk_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
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));
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900240 if (hd_req)
241 printk(", sector=%ld", blk_rq_pos(hd_req));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 }
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; /* Ancient, but does it make sense??? */
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306static 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 /* nothing */;
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);
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200327 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336}
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
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200358 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();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 if (drive_busy())
363 printk("hd: controller still busy\n");
364 else if ((hd_error = inb(HD_ERROR)) != 1)
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200365 printk("hd: controller reset failed: %02x\n", hd_error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366}
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;
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200385 hd_out(disk, disk->sect, disk->sect, disk->head-1,
Bartlomiej Zolnierkiewiczf26b3d72008-10-10 22:39:21 +0200386 disk->cyl, ATA_CMD_INIT_DEV_PARAMS, &reset_hd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 if (reset)
388 goto repeat;
389 } else
390 hd_request();
391}
392
393/*
394 * Ok, don't know what to do with the unexpected interrupts: on some machines
395 * doing a reset and a retry seems to result in an eternal loop. Right now I
396 * ignore it, and just set the timeout.
397 *
398 * On laptops (and "green" PCs), an unexpected interrupt occurs whenever the
399 * drive enters "idle", "standby", or "sleep" mode, so if the status looks
400 * "good", we just ignore the interrupt completely.
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)) {
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200407 dump_status("unexpected interrupt", stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 SET_TIMER;
409 }
410}
411
412/*
413 * bad_rw_intr() now tries to be a bit smarter and does things
414 * according to the error returned by the controller.
415 * -Mika Liljeberg (liljeber@cs.Helsinki.FI)
416 */
417static void bad_rw_intr(void)
418{
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900419 struct request *req = hd_req;
420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 if (req != NULL) {
422 struct hd_i_struct *disk = req->rq_disk->private_data;
423 if (++req->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900424 hd_end_request_cur(-EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 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 /* Otherwise just retry */
431 }
432}
433
434static inline int wait_DRQ(void)
435{
Andrew Mortonb0042232008-02-06 02:57:49 +0100436 int retries;
437 int stat;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Andrew Mortonb0042232008-02-06 02:57:49 +0100439 for (retries = 0; retries < 100000; retries++) {
440 stat = inb_p(HD_STATUS);
441 if (stat & DRQ_STAT)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 return 0;
Andrew Mortonb0042232008-02-06 02:57:49 +0100443 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 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;
Tejun Heoe091eb62009-04-28 13:06:11 +0900466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467ok_to_read:
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900468 req = hd_req;
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200469 insw(HD_DATA, req->buffer, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470#ifdef DEBUG
Tejun Heo83096eb2009-05-07 22:24:39 +0900471 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474#endif
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900475 if (hd_end_request(0, 512)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 SET_HANDLER(&read_intr);
477 return;
478 }
Tejun Heoe091eb62009-04-28 13:06:11 +0900479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 (void) inb_p(HD_STATUS);
481#if (HD_DELAY > 0)
482 last_req = read_timer();
483#endif
Tejun Heoe091eb62009-04-28 13:06:11 +0900484 hd_request();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485}
486
487static void write_intr(void)
488{
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900489 struct request *req = hd_req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 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;
Tejun Heo83096eb2009-05-07 22:24:39 +0900499 if ((blk_rq_sectors(req) <= 1) || (i & DRQ_STAT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 goto ok_to_write;
501 } while (--retries > 0);
502 dump_status("write_intr", i);
503 bad_rw_intr();
504 hd_request();
505 return;
Tejun Heoe091eb62009-04-28 13:06:11 +0900506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507ok_to_write:
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900508 if (hd_end_request(0, 512)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 SET_HANDLER(&write_intr);
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200510 outsw(HD_DATA, req->buffer, 256);
Tejun Heoe091eb62009-04-28 13:06:11 +0900511 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 }
Tejun Heoe091eb62009-04-28 13:06:11 +0900513
514#if (HD_DELAY > 0)
515 last_req = read_timer();
516#endif
517 hd_request();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518}
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 * This is another of the error-routines I don't know what to do with. The
531 * best idea seems to just set reset, and start all over again.
532 */
533static void hd_times_out(unsigned long dummy)
534{
535 char *name;
536
537 do_hd = NULL;
538
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900539 if (!hd_req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 return;
541
Tejun Heoe93b9fb2009-04-28 12:38:33 +0900542 spin_lock_irq(hd_queue->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 reset = 1;
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900544 name = hd_req->rq_disk->disk_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 printk("%s: timeout\n", name);
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900546 if (++hd_req->errors >= MAX_ERRORS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547#ifdef DEBUG
548 printk("%s: too many errors\n", name);
549#endif
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900550 hd_end_request_cur(-EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 hd_request();
Tejun Heoe93b9fb2009-04-28 12:38:33 +0900553 spin_unlock_irq(hd_queue->queue_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554}
555
556static int do_special_op(struct hd_i_struct *disk, struct request *req)
557{
558 if (disk->recalibrate) {
559 disk->recalibrate = 0;
Bartlomiej Zolnierkiewiczf26b3d72008-10-10 22:39:21 +0200560 hd_out(disk, disk->sect, 0, 0, 0, ATA_CMD_RESTORE, &recal_intr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 return reset;
562 }
563 if (disk->head > 16) {
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200564 printk("%s: cannot handle device with more than 16 heads - giving up\n", req->rq_disk->disk_name);
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900565 hd_end_request_cur(-EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 }
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900592 if (!hd_req) {
Tejun Heo9934c8c2009-05-08 11:54:16 +0900593 hd_req = blk_fetch_request(hd_queue);
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900594 if (!hd_req) {
595 do_hd = NULL;
596 return;
597 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 }
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900599 req = hd_req;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
601 if (reset) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 reset_hd();
603 return;
604 }
605 disk = req->rq_disk->private_data;
Tejun Heo83096eb2009-05-07 22:24:39 +0900606 block = blk_rq_pos(req);
607 nsect = blk_rq_sectors(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 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);
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900612 hd_end_request_cur(-EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 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",
Boaz Harroshe654bc42007-06-20 13:53:23 +0200627 req->rq_disk->disk_name,
628 req_data_dir(req) == READ ? "read" : "writ",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 cyl, head, sec, nsect, req->buffer);
630#endif
Jens Axboe4aff5e22006-08-10 08:44:47 +0200631 if (blk_fs_request(req)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 switch (rq_data_dir(req)) {
633 case READ:
Bartlomiej Zolnierkiewiczf26b3d72008-10-10 22:39:21 +0200634 hd_out(disk, nsect, sec, head, cyl, ATA_CMD_PIO_READ,
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200635 &read_intr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 if (reset)
637 goto repeat;
638 break;
639 case WRITE:
Bartlomiej Zolnierkiewiczf26b3d72008-10-10 22:39:21 +0200640 hd_out(disk, nsect, sec, head, cyl, ATA_CMD_PIO_WRITE,
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200641 &write_intr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 if (reset)
643 goto repeat;
644 if (wait_DRQ()) {
645 bad_rw_intr();
646 goto repeat;
647 }
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200648 outsw(HD_DATA, req->buffer, 256);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 break;
650 default:
651 printk("unknown hd-command\n");
Tejun Heo8a12c4a2009-05-08 11:54:02 +0900652 hd_end_request_cur(-EIO);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 break;
654 }
655 }
656}
657
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200658static void do_hd_request(struct request_queue *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 hd_request();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661}
662
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800663static int hd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664{
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800665 struct hd_i_struct *disk = bdev->bd_disk->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800667 geo->heads = disk->head;
668 geo->sectors = disk->sect;
669 geo->cylinders = disk->cyl;
670 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671}
672
673/*
674 * Releasing a block device means we sync() it, so that it can safely
675 * be forgotten about...
676 */
677
David Howells7d12e782006-10-05 14:55:46 +0100678static irqreturn_t hd_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679{
680 void (*handler)(void) = do_hd;
681
Tejun Heoe93b9fb2009-04-28 12:38:33 +0900682 spin_lock(hd_queue->queue_lock);
683
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 do_hd = NULL;
685 del_timer(&device_timer);
686 if (!handler)
687 handler = unexpected_hd_interrupt;
688 handler();
Tejun Heoe93b9fb2009-04-28 12:38:33 +0900689
690 spin_unlock(hd_queue->queue_lock);
691
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 return IRQ_HANDLED;
693}
694
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -0700695static const struct block_device_operations hd_fops = {
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800696 .getgeo = hd_getgeo,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697};
698
699/*
Thomas Gleixner362537b2006-07-01 19:29:34 -0700700 * This is the hard disk IRQ description. The IRQF_DISABLED in sa_flags
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 * means we run the IRQ-handler with interrupts disabled: this is bad for
702 * interrupt latency, but anything else has led to problems on some
703 * machines.
704 *
705 * We enable interrupts in some of the routines after making sure it's
706 * safe.
707 */
708
709static int __init hd_init(void)
710{
711 int drive;
712
Christoph Hellwigddeb9c32009-06-16 22:07:32 +0200713 if (register_blkdev(HD_MAJOR, "hd"))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 return -1;
715
716 hd_queue = blk_init_queue(do_hd_request, &hd_lock);
717 if (!hd_queue) {
Christoph Hellwigddeb9c32009-06-16 22:07:32 +0200718 unregister_blkdev(HD_MAJOR, "hd");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 return -ENOMEM;
720 }
721
Martin K. Petersen086fa5f2010-02-26 00:20:38 -0500722 blk_queue_max_hw_sectors(hd_queue, 255);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 init_timer(&device_timer);
724 device_timer.function = hd_times_out;
Martin K. Petersene1defc42009-05-22 17:17:49 -0400725 blk_queue_logical_block_size(hd_queue, 512);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 if (!NR_HD) {
H. Peter Anvin48dd6432007-07-11 12:18:27 -0700728 /*
729 * We don't know anything about the drive. This means
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 * that you *MUST* specify the drive parameters to the
731 * kernel yourself.
H. Peter Anvin48dd6432007-07-11 12:18:27 -0700732 *
733 * If we were on an i386, we used to read this info from
734 * the BIOS or CMOS. This doesn't work all that well,
735 * since this assumes that this is a primary or secondary
736 * drive, and if we're using this legacy driver, it's
737 * probably an auxilliary controller added to recover
738 * legacy data off an ST-506 drive. Either way, it's
739 * definitely safest to have the user explicitly specify
740 * the information.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 */
742 printk("hd: no drives specified - use hd=cyl,head,sectors"
743 " on kernel command line\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 goto out;
H. Peter Anvin48dd6432007-07-11 12:18:27 -0700745 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200747 for (drive = 0 ; drive < NR_HD ; drive++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 struct gendisk *disk = alloc_disk(64);
749 struct hd_i_struct *p = &hd_info[drive];
750 if (!disk)
751 goto Enomem;
Christoph Hellwigddeb9c32009-06-16 22:07:32 +0200752 disk->major = HD_MAJOR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 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;
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200761 printk("%s: %luMB, CHS=%d/%d/%d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 disk->disk_name, (unsigned long)get_capacity(disk)/2048,
763 p->cyl, p->head, p->sect);
764 }
765
Thomas Gleixner362537b2006-07-01 19:29:34 -0700766 if (request_irq(HD_IRQ, hd_interrupt, IRQF_DISABLED, "hd", NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 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 /* Let them fly */
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200781 for (drive = 0; drive < NR_HD; drive++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 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);
Christoph Hellwigddeb9c32009-06-16 22:07:32 +0200796 unregister_blkdev(HD_MAJOR, "hd");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 blk_cleanup_queue(hd_queue);
798 return -1;
799Enomem:
800 while (drive--)
801 put_disk(hd_gendisk[drive]);
802 goto out;
803}
804
Paolo Ciarrocchiec297822008-04-26 17:36:41 +0200805static int __init parse_hd_setup(char *line)
806{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 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
Adrian Bunk01c22bf2008-07-16 20:33:47 +0200816late_initcall(hd_init);