2 * linux/drivers/ide/ide-disk.c Version 1.18 Mar 05, 2003
4 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below)
5 * Copyright (C) 1998-2002 Linux ATA Development
6 * Andre Hedrick <andre@linux-ide.org>
7 * Copyright (C) 2003 Red Hat <alan@redhat.com>
11 * Mostly written by Mark Lord <mlord@pobox.com>
12 * and Gadi Oxman <gadio@netvision.net.il>
13 * and Andre Hedrick <andre@linux-ide.org>
15 * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
17 * Version 1.00 move disk only code from ide.c to ide-disk.c
18 * support optional byte-swapping of all data
19 * Version 1.01 fix previous byte-swapping code
20 * Version 1.02 remove ", LBA" from drive identification msgs
21 * Version 1.03 fix display of id->buf_size for big-endian
22 * Version 1.04 add /proc configurable settings and S.M.A.R.T support
23 * Version 1.05 add capacity support for ATA3 >= 8GB
24 * Version 1.06 get boot-up messages to show full cyl count
25 * Version 1.07 disable door-locking if it fails
26 * Version 1.08 fixed CHS/LBA translations for ATA4 > 8GB,
27 * process of adding new ATA4 compliance.
28 * fixed problems in allowing fdisk to see
30 * Version 1.09 added increment of rq->sector in ide_multwrite
31 * added UDMA 3/4 reporting
32 * Version 1.10 request queue changes, Ultra DMA 100
33 * Version 1.11 added 48-bit lba
34 * Version 1.12 adding taskfile io access method
35 * Version 1.13 added standby and flush-cache for notifier
36 * Version 1.14 added acoustic-wcache
37 * Version 1.15 convert all calls to ide_raw_taskfile
38 * since args will return register content.
39 * Version 1.16 added suspend-resume-checkpower
40 * Version 1.17 do flush on standby, do flush on ATA < ATA6
44 #define IDEDISK_VERSION "1.18"
48 #include <linux/module.h>
49 #include <linux/types.h>
50 #include <linux/string.h>
51 #include <linux/kernel.h>
52 #include <linux/timer.h>
54 #include <linux/interrupt.h>
55 #include <linux/major.h>
56 #include <linux/errno.h>
57 #include <linux/genhd.h>
58 #include <linux/slab.h>
59 #include <linux/delay.h>
60 #include <linux/mutex.h>
61 #include <linux/leds.h>
65 #include <linux/ide.h>
67 #include <asm/byteorder.h>
69 #include <asm/uaccess.h>
71 #include <asm/div64.h>
78 unsigned int openers; /* protected by BKL for now */
81 static DEFINE_MUTEX(idedisk_ref_mutex);
83 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
85 #define ide_disk_g(disk) \
86 container_of((disk)->private_data, struct ide_disk_obj, driver)
88 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
90 struct ide_disk_obj *idkp = NULL;
92 mutex_lock(&idedisk_ref_mutex);
93 idkp = ide_disk_g(disk);
95 kref_get(&idkp->kref);
96 mutex_unlock(&idedisk_ref_mutex);
100 static void ide_disk_release(struct kref *);
102 static void ide_disk_put(struct ide_disk_obj *idkp)
104 mutex_lock(&idedisk_ref_mutex);
105 kref_put(&idkp->kref, ide_disk_release);
106 mutex_unlock(&idedisk_ref_mutex);
110 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
111 * value for this drive (from its reported identification information).
113 * Returns: 1 if lba_capacity looks sensible
116 * It is called only once for each drive.
118 static int lba_capacity_is_ok (struct hd_driveid *id)
120 unsigned long lba_sects, chs_sects, head, tail;
122 /* No non-LBA info .. so valid! */
127 * The ATA spec tells large drives to return
128 * C/H/S = 16383/16/63 independent of their size.
129 * Some drives can be jumpered to use 15 heads instead of 16.
130 * Some drives can be jumpered to use 4092 cyls instead of 16383.
132 if ((id->cyls == 16383
133 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
135 (id->heads == 15 || id->heads == 16) &&
136 (id->lba_capacity >= 16383*63*id->heads))
139 lba_sects = id->lba_capacity;
140 chs_sects = id->cyls * id->heads * id->sectors;
142 /* perform a rough sanity check on lba_sects: within 10% is OK */
143 if ((lba_sects - chs_sects) < chs_sects/10)
146 /* some drives have the word order reversed */
147 head = ((lba_sects >> 16) & 0xffff);
148 tail = (lba_sects & 0xffff);
149 lba_sects = (head | (tail << 16));
150 if ((lba_sects - chs_sects) < chs_sects/10) {
151 id->lba_capacity = lba_sects;
152 return 1; /* lba_capacity is (now) good */
155 return 0; /* lba_capacity value may be bad */
159 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
160 * using LBA if supported, or CHS otherwise, to address sectors.
162 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
164 ide_hwif_t *hwif = HWIF(drive);
165 unsigned int dma = drive->using_dma;
166 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
167 task_ioreg_t command = WIN_NOP;
168 ata_nsector_t nsectors;
170 nsectors.all = (u16) rq->nr_sectors;
172 if (hwif->no_lba48_dma && lba48 && dma) {
173 if (block + rq->nr_sectors > 1ULL << 28)
180 ide_init_sg_cmd(drive, rq);
181 ide_map_sg(drive, rq);
185 hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
187 /* FIXME: SELECT_MASK(drive, 0) ? */
189 if (drive->select.b.lba) {
191 task_ioreg_t tasklets[10];
193 pr_debug("%s: LBA=0x%012llx\n", drive->name,
194 (unsigned long long)block);
198 tasklets[2] = nsectors.b.low;
199 tasklets[3] = nsectors.b.high;
200 tasklets[4] = (task_ioreg_t) block;
201 tasklets[5] = (task_ioreg_t) (block>>8);
202 tasklets[6] = (task_ioreg_t) (block>>16);
203 tasklets[7] = (task_ioreg_t) (block>>24);
204 if (sizeof(block) == 4) {
205 tasklets[8] = (task_ioreg_t) 0;
206 tasklets[9] = (task_ioreg_t) 0;
208 tasklets[8] = (task_ioreg_t)((u64)block >> 32);
209 tasklets[9] = (task_ioreg_t)((u64)block >> 40);
212 printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
213 drive->name, tasklets[3], tasklets[2],
214 tasklets[9], tasklets[8], tasklets[7],
215 tasklets[6], tasklets[5], tasklets[4]);
217 hwif->OUTB(tasklets[1], IDE_FEATURE_REG);
218 hwif->OUTB(tasklets[3], IDE_NSECTOR_REG);
219 hwif->OUTB(tasklets[7], IDE_SECTOR_REG);
220 hwif->OUTB(tasklets[8], IDE_LCYL_REG);
221 hwif->OUTB(tasklets[9], IDE_HCYL_REG);
223 hwif->OUTB(tasklets[0], IDE_FEATURE_REG);
224 hwif->OUTB(tasklets[2], IDE_NSECTOR_REG);
225 hwif->OUTB(tasklets[4], IDE_SECTOR_REG);
226 hwif->OUTB(tasklets[5], IDE_LCYL_REG);
227 hwif->OUTB(tasklets[6], IDE_HCYL_REG);
228 hwif->OUTB(0x00|drive->select.all,IDE_SELECT_REG);
230 hwif->OUTB(0x00, IDE_FEATURE_REG);
231 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
232 hwif->OUTB(block, IDE_SECTOR_REG);
233 hwif->OUTB(block>>=8, IDE_LCYL_REG);
234 hwif->OUTB(block>>=8, IDE_HCYL_REG);
235 hwif->OUTB(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
238 unsigned int sect,head,cyl,track;
239 track = (int)block / drive->sect;
240 sect = (int)block % drive->sect + 1;
241 hwif->OUTB(sect, IDE_SECTOR_REG);
242 head = track % drive->head;
243 cyl = track / drive->head;
245 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
247 hwif->OUTB(0x00, IDE_FEATURE_REG);
248 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
249 hwif->OUTB(cyl, IDE_LCYL_REG);
250 hwif->OUTB(cyl>>8, IDE_HCYL_REG);
251 hwif->OUTB(head|drive->select.all,IDE_SELECT_REG);
255 if (!hwif->dma_setup(drive)) {
256 if (rq_data_dir(rq)) {
257 command = lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
259 command = lba48 ? WIN_WRITE_EXT: WIN_WRITE;
261 command = lba48 ? WIN_READDMA_EXT : WIN_READDMA;
263 command = lba48 ? WIN_READ_EXT: WIN_READ;
265 hwif->dma_exec_cmd(drive, command);
266 hwif->dma_start(drive);
269 /* fallback to PIO */
270 ide_init_sg_cmd(drive, rq);
273 if (rq_data_dir(rq) == READ) {
275 if (drive->mult_count) {
276 hwif->data_phase = TASKFILE_MULTI_IN;
277 command = lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
279 hwif->data_phase = TASKFILE_IN;
280 command = lba48 ? WIN_READ_EXT : WIN_READ;
283 ide_execute_command(drive, command, &task_in_intr, WAIT_CMD, NULL);
286 if (drive->mult_count) {
287 hwif->data_phase = TASKFILE_MULTI_OUT;
288 command = lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
290 hwif->data_phase = TASKFILE_OUT;
291 command = lba48 ? WIN_WRITE_EXT : WIN_WRITE;
294 /* FIXME: ->OUTBSYNC ? */
295 hwif->OUTB(command, IDE_COMMAND_REG);
297 return pre_task_out_intr(drive, rq);
302 * 268435455 == 137439 MB or 28bit limit
303 * 320173056 == 163929 MB or 48bit addressing
304 * 1073741822 == 549756 MB or 48bit addressing fake drive
307 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
309 ide_hwif_t *hwif = HWIF(drive);
311 BUG_ON(drive->blocked);
313 if (!blk_fs_request(rq)) {
314 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
315 ide_end_request(drive, 0, 0);
319 ledtrig_ide_activity();
321 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
322 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
323 (unsigned long long)block, rq->nr_sectors,
324 (unsigned long)rq->buffer);
327 hwif->rw_disk(drive, rq);
329 return __ide_do_rw_disk(drive, rq, block);
333 * Queries for true maximum capacity of the drive.
334 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
336 static unsigned long idedisk_read_native_max_address(ide_drive_t *drive)
339 unsigned long addr = 0;
341 /* Create IDE/ATA command request structure */
342 memset(&args, 0, sizeof(ide_task_t));
343 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
344 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX;
345 args.command_type = IDE_DRIVE_TASK_NO_DATA;
346 args.handler = &task_no_data_intr;
347 /* submit command request */
348 ide_raw_taskfile(drive, &args, NULL);
350 /* if OK, compute maximum address value */
351 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
352 addr = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
353 | ((args.tfRegister[ IDE_HCYL_OFFSET] ) << 16)
354 | ((args.tfRegister[ IDE_LCYL_OFFSET] ) << 8)
355 | ((args.tfRegister[IDE_SECTOR_OFFSET] ));
356 addr++; /* since the return value is (maxlba - 1), we add 1 */
361 static unsigned long long idedisk_read_native_max_address_ext(ide_drive_t *drive)
364 unsigned long long addr = 0;
366 /* Create IDE/ATA command request structure */
367 memset(&args, 0, sizeof(ide_task_t));
369 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
370 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX_EXT;
371 args.command_type = IDE_DRIVE_TASK_NO_DATA;
372 args.handler = &task_no_data_intr;
373 /* submit command request */
374 ide_raw_taskfile(drive, &args, NULL);
376 /* if OK, compute maximum address value */
377 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
378 u32 high = (args.hobRegister[IDE_HCYL_OFFSET] << 16) |
379 (args.hobRegister[IDE_LCYL_OFFSET] << 8) |
380 args.hobRegister[IDE_SECTOR_OFFSET];
381 u32 low = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
382 ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
383 (args.tfRegister[IDE_SECTOR_OFFSET]);
384 addr = ((__u64)high << 24) | low;
385 addr++; /* since the return value is (maxlba - 1), we add 1 */
391 * Sets maximum virtual LBA address of the drive.
392 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
394 static unsigned long idedisk_set_max_address(ide_drive_t *drive, unsigned long addr_req)
397 unsigned long addr_set = 0;
400 /* Create IDE/ATA command request structure */
401 memset(&args, 0, sizeof(ide_task_t));
402 args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >> 0) & 0xff);
403 args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >> 8) & 0xff);
404 args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >> 16) & 0xff);
405 args.tfRegister[IDE_SELECT_OFFSET] = ((addr_req >> 24) & 0x0f) | 0x40;
406 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX;
407 args.command_type = IDE_DRIVE_TASK_NO_DATA;
408 args.handler = &task_no_data_intr;
409 /* submit command request */
410 ide_raw_taskfile(drive, &args, NULL);
411 /* if OK, read new maximum address value */
412 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
413 addr_set = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
414 | ((args.tfRegister[ IDE_HCYL_OFFSET] ) << 16)
415 | ((args.tfRegister[ IDE_LCYL_OFFSET] ) << 8)
416 | ((args.tfRegister[IDE_SECTOR_OFFSET] ));
422 static unsigned long long idedisk_set_max_address_ext(ide_drive_t *drive, unsigned long long addr_req)
425 unsigned long long addr_set = 0;
428 /* Create IDE/ATA command request structure */
429 memset(&args, 0, sizeof(ide_task_t));
430 args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >> 0) & 0xff);
431 args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
432 args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
433 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
434 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX_EXT;
435 args.hobRegister[IDE_SECTOR_OFFSET] = (addr_req >>= 8) & 0xff;
436 args.hobRegister[IDE_LCYL_OFFSET] = (addr_req >>= 8) & 0xff;
437 args.hobRegister[IDE_HCYL_OFFSET] = (addr_req >>= 8) & 0xff;
438 args.hobRegister[IDE_SELECT_OFFSET] = 0x40;
439 args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
440 args.command_type = IDE_DRIVE_TASK_NO_DATA;
441 args.handler = &task_no_data_intr;
442 /* submit command request */
443 ide_raw_taskfile(drive, &args, NULL);
444 /* if OK, compute maximum address value */
445 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
446 u32 high = (args.hobRegister[IDE_HCYL_OFFSET] << 16) |
447 (args.hobRegister[IDE_LCYL_OFFSET] << 8) |
448 args.hobRegister[IDE_SECTOR_OFFSET];
449 u32 low = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
450 ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
451 (args.tfRegister[IDE_SECTOR_OFFSET]);
452 addr_set = ((__u64)high << 24) | low;
458 static unsigned long long sectors_to_MB(unsigned long long n)
460 n <<= 9; /* make it bytes */
461 do_div(n, 1000000); /* make it MB */
466 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
467 * so on non-buggy drives we need test only one.
468 * However, we should also check whether these fields are valid.
470 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
472 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
478 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
480 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
481 && id->lba_capacity_2;
484 static void idedisk_check_hpa(ide_drive_t *drive)
486 unsigned long long capacity, set_max;
487 int lba48 = idedisk_supports_lba48(drive->id);
489 capacity = drive->capacity64;
491 set_max = idedisk_read_native_max_address_ext(drive);
493 set_max = idedisk_read_native_max_address(drive);
495 if (set_max <= capacity)
498 printk(KERN_INFO "%s: Host Protected Area detected.\n"
499 "\tcurrent capacity is %llu sectors (%llu MB)\n"
500 "\tnative capacity is %llu sectors (%llu MB)\n",
502 capacity, sectors_to_MB(capacity),
503 set_max, sectors_to_MB(set_max));
506 set_max = idedisk_set_max_address_ext(drive, set_max);
508 set_max = idedisk_set_max_address(drive, set_max);
510 drive->capacity64 = set_max;
511 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
517 * Compute drive->capacity, the full capacity of the drive
518 * Called with drive->id != NULL.
520 * To compute capacity, this uses either of
522 * 1. CHS value set by user (whatever user sets will be trusted)
523 * 2. LBA value from target drive (require new ATA feature)
524 * 3. LBA value from system BIOS (new one is OK, old one may break)
525 * 4. CHS value from system BIOS (traditional style)
527 * in above order (i.e., if value of higher priority is available,
528 * reset will be ignored).
530 static void init_idedisk_capacity (ide_drive_t *drive)
532 struct hd_driveid *id = drive->id;
534 * If this drive supports the Host Protected Area feature set,
535 * then we may need to change our opinion about the drive's capacity.
537 int hpa = idedisk_supports_hpa(id);
539 if (idedisk_supports_lba48(id)) {
540 /* drive speaks 48-bit LBA */
541 drive->select.b.lba = 1;
542 drive->capacity64 = id->lba_capacity_2;
544 idedisk_check_hpa(drive);
545 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
546 /* drive speaks 28-bit LBA */
547 drive->select.b.lba = 1;
548 drive->capacity64 = id->lba_capacity;
550 idedisk_check_hpa(drive);
552 /* drive speaks boring old 28-bit CHS */
553 drive->capacity64 = drive->cyl * drive->head * drive->sect;
557 static sector_t idedisk_capacity (ide_drive_t *drive)
559 return drive->capacity64 - drive->sect0;
562 #ifdef CONFIG_IDE_PROC_FS
564 static int smart_enable(ide_drive_t *drive)
568 memset(&args, 0, sizeof(ide_task_t));
569 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_ENABLE;
570 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
571 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
572 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
573 args.command_type = IDE_DRIVE_TASK_NO_DATA;
574 args.handler = &task_no_data_intr;
575 return ide_raw_taskfile(drive, &args, NULL);
578 static int get_smart_values(ide_drive_t *drive, u8 *buf)
582 memset(&args, 0, sizeof(ide_task_t));
583 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_VALUES;
584 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
585 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
586 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
587 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
588 args.command_type = IDE_DRIVE_TASK_IN;
589 args.data_phase = TASKFILE_IN;
590 args.handler = &task_in_intr;
591 (void) smart_enable(drive);
592 return ide_raw_taskfile(drive, &args, buf);
595 static int get_smart_thresholds(ide_drive_t *drive, u8 *buf)
598 memset(&args, 0, sizeof(ide_task_t));
599 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_THRESHOLDS;
600 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
601 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
602 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
603 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
604 args.command_type = IDE_DRIVE_TASK_IN;
605 args.data_phase = TASKFILE_IN;
606 args.handler = &task_in_intr;
607 (void) smart_enable(drive);
608 return ide_raw_taskfile(drive, &args, buf);
611 static int proc_idedisk_read_cache
612 (char *page, char **start, off_t off, int count, int *eof, void *data)
614 ide_drive_t *drive = (ide_drive_t *) data;
619 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
621 len = sprintf(out,"(none)\n");
622 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
625 static int proc_idedisk_read_capacity
626 (char *page, char **start, off_t off, int count, int *eof, void *data)
628 ide_drive_t*drive = (ide_drive_t *)data;
631 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
632 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
635 static int proc_idedisk_read_smart_thresholds
636 (char *page, char **start, off_t off, int count, int *eof, void *data)
638 ide_drive_t *drive = (ide_drive_t *)data;
641 if (!get_smart_thresholds(drive, page)) {
642 unsigned short *val = (unsigned short *) page;
643 char *out = ((char *)val) + (SECTOR_WORDS * 4);
646 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
648 } while (i < (SECTOR_WORDS * 2));
651 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
654 static int proc_idedisk_read_smart_values
655 (char *page, char **start, off_t off, int count, int *eof, void *data)
657 ide_drive_t *drive = (ide_drive_t *)data;
660 if (!get_smart_values(drive, page)) {
661 unsigned short *val = (unsigned short *) page;
662 char *out = ((char *)val) + (SECTOR_WORDS * 4);
665 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
667 } while (i < (SECTOR_WORDS * 2));
670 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
673 static ide_proc_entry_t idedisk_proc[] = {
674 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
675 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
676 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
677 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
678 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
679 { NULL, 0, NULL, NULL }
684 #define idedisk_proc NULL
686 #endif /* CONFIG_IDE_PROC_FS */
688 static void idedisk_prepare_flush(request_queue_t *q, struct request *rq)
690 ide_drive_t *drive = q->queuedata;
692 memset(rq->cmd, 0, sizeof(rq->cmd));
694 if (ide_id_has_flush_cache_ext(drive->id) &&
695 (drive->capacity64 >= (1UL << 28)))
696 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
698 rq->cmd[0] = WIN_FLUSH_CACHE;
701 rq->cmd_type = REQ_TYPE_ATA_TASK;
702 rq->cmd_flags |= REQ_SOFTBARRIER;
703 rq->buffer = rq->cmd;
706 static int idedisk_issue_flush(request_queue_t *q, struct gendisk *disk,
707 sector_t *error_sector)
709 ide_drive_t *drive = q->queuedata;
716 rq = blk_get_request(q, WRITE, __GFP_WAIT);
718 idedisk_prepare_flush(q, rq);
720 ret = blk_execute_rq(q, disk, rq, 0);
723 * if we failed and caller wants error offset, get it
725 if (ret && error_sector)
726 *error_sector = ide_get_error_location(drive, rq->cmd);
733 * This is tightly woven into the driver->do_special can not touch.
734 * DON'T do it again until a total personality rewrite is committed.
736 static int set_multcount(ide_drive_t *drive, int arg)
740 if (arg < 0 || arg > drive->id->max_multsect)
743 if (drive->special.b.set_multmode)
745 ide_init_drive_cmd (&rq);
746 rq.cmd_type = REQ_TYPE_ATA_CMD;
747 drive->mult_req = arg;
748 drive->special.b.set_multmode = 1;
749 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
750 return (drive->mult_count == arg) ? 0 : -EIO;
753 static int set_nowerr(ide_drive_t *drive, int arg)
755 if (arg < 0 || arg > 1)
758 if (ide_spin_wait_hwgroup(drive))
761 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
762 spin_unlock_irq(&ide_lock);
766 static void update_ordered(ide_drive_t *drive)
768 struct hd_driveid *id = drive->id;
769 unsigned ordered = QUEUE_ORDERED_NONE;
770 prepare_flush_fn *prep_fn = NULL;
771 issue_flush_fn *issue_fn = NULL;
774 unsigned long long capacity;
777 * We must avoid issuing commands a drive does not
778 * understand or we may crash it. We check flush cache
779 * is supported. We also check we have the LBA48 flush
780 * cache if the drive capacity is too large. By this
781 * time we have trimmed the drive capacity if LBA48 is
782 * not available so we don't need to recheck that.
784 capacity = idedisk_capacity(drive);
785 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
786 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
787 ide_id_has_flush_cache_ext(id));
789 printk(KERN_INFO "%s: cache flushes %ssupported\n",
790 drive->name, barrier ? "" : "not ");
793 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
794 prep_fn = idedisk_prepare_flush;
795 issue_fn = idedisk_issue_flush;
798 ordered = QUEUE_ORDERED_DRAIN;
800 blk_queue_ordered(drive->queue, ordered, prep_fn);
801 blk_queue_issue_flush_fn(drive->queue, issue_fn);
804 static int write_cache(ide_drive_t *drive, int arg)
809 if (arg < 0 || arg > 1)
812 if (ide_id_has_flush_cache(drive->id)) {
813 memset(&args, 0, sizeof(ide_task_t));
814 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ?
815 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
816 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
817 args.command_type = IDE_DRIVE_TASK_NO_DATA;
818 args.handler = &task_no_data_intr;
819 err = ide_raw_taskfile(drive, &args, NULL);
824 update_ordered(drive);
829 static int do_idedisk_flushcache (ide_drive_t *drive)
833 memset(&args, 0, sizeof(ide_task_t));
834 if (ide_id_has_flush_cache_ext(drive->id))
835 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE_EXT;
837 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE;
838 args.command_type = IDE_DRIVE_TASK_NO_DATA;
839 args.handler = &task_no_data_intr;
840 return ide_raw_taskfile(drive, &args, NULL);
843 static int set_acoustic (ide_drive_t *drive, int arg)
847 if (arg < 0 || arg > 254)
850 memset(&args, 0, sizeof(ide_task_t));
851 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ? SETFEATURES_EN_AAM :
853 args.tfRegister[IDE_NSECTOR_OFFSET] = arg;
854 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
855 args.command_type = IDE_DRIVE_TASK_NO_DATA;
856 args.handler = &task_no_data_intr;
857 ide_raw_taskfile(drive, &args, NULL);
858 drive->acoustic = arg;
866 * 2: 48-bit capable doing 28-bit
868 static int set_lba_addressing(ide_drive_t *drive, int arg)
870 if (arg < 0 || arg > 2)
873 drive->addressing = 0;
875 if (HWIF(drive)->no_lba48)
878 if (!idedisk_supports_lba48(drive->id))
880 drive->addressing = arg;
884 static void idedisk_add_settings(ide_drive_t *drive)
886 struct hd_driveid *id = drive->id;
888 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
889 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
890 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
891 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
892 ide_add_setting(drive, "bswap", SETTING_READ, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
893 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount);
894 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
895 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
896 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
897 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
898 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
899 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
902 static void idedisk_setup (ide_drive_t *drive)
904 struct hd_driveid *id = drive->id;
905 unsigned long long capacity;
907 idedisk_add_settings(drive);
909 if (drive->id_read == 0)
912 if (drive->removable) {
914 * Removable disks (eg. SYQUEST); ignore 'WD' drives
916 if (id->model[0] != 'W' || id->model[1] != 'D') {
917 drive->doorlocking = 1;
921 (void)set_lba_addressing(drive, 1);
923 if (drive->addressing == 1) {
924 ide_hwif_t *hwif = HWIF(drive);
927 if (max_s > hwif->rqsize)
928 max_s = hwif->rqsize;
930 blk_queue_max_sectors(drive->queue, max_s);
933 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
935 /* calculate drive capacity, and select LBA if possible */
936 init_idedisk_capacity (drive);
938 /* limit drive capacity to 137GB if LBA48 cannot be used */
939 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
940 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
941 "%llu sectors (%llu MB)\n",
942 drive->name, (unsigned long long)drive->capacity64,
943 sectors_to_MB(drive->capacity64));
944 drive->capacity64 = 1ULL << 28;
947 if (drive->hwif->no_lba48_dma && drive->addressing) {
948 if (drive->capacity64 > 1ULL << 28) {
949 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
950 " be used for accessing sectors > %u\n",
951 drive->name, 1 << 28);
953 drive->addressing = 0;
957 * if possible, give fdisk access to more of the drive,
958 * by correcting bios_cyls:
960 capacity = idedisk_capacity (drive);
961 if (!drive->forced_geom) {
963 if (idedisk_supports_lba48(drive->id)) {
965 drive->bios_sect = 63;
966 drive->bios_head = 255;
969 if (drive->bios_sect && drive->bios_head) {
970 unsigned int cap0 = capacity; /* truncate to 32 bits */
971 unsigned int cylsz, cyl;
973 if (cap0 != capacity)
974 drive->bios_cyl = 65535;
976 cylsz = drive->bios_sect * drive->bios_head;
980 if (cyl > drive->bios_cyl)
981 drive->bios_cyl = cyl;
985 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
986 drive->name, capacity, sectors_to_MB(capacity));
988 /* Only print cache size when it was specified */
990 printk (" w/%dKiB Cache", id->buf_size/2);
992 printk(", CHS=%d/%d/%d",
993 drive->bios_cyl, drive->bios_head, drive->bios_sect);
994 if (drive->using_dma)
995 ide_dma_verbose(drive);
998 /* write cache enabled? */
999 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
1002 write_cache(drive, 1);
1005 static void ide_cacheflush_p(ide_drive_t *drive)
1007 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
1010 if (do_idedisk_flushcache(drive))
1011 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
1014 static void ide_disk_remove(ide_drive_t *drive)
1016 struct ide_disk_obj *idkp = drive->driver_data;
1017 struct gendisk *g = idkp->disk;
1019 ide_unregister_subdriver(drive, idkp->driver);
1023 ide_cacheflush_p(drive);
1028 static void ide_disk_release(struct kref *kref)
1030 struct ide_disk_obj *idkp = to_ide_disk(kref);
1031 ide_drive_t *drive = idkp->drive;
1032 struct gendisk *g = idkp->disk;
1034 drive->driver_data = NULL;
1035 g->private_data = NULL;
1040 static int ide_disk_probe(ide_drive_t *drive);
1042 static void ide_device_shutdown(ide_drive_t *drive)
1045 /* On Alpha, halt(8) doesn't actually turn the machine off,
1046 it puts you into the sort of firmware monitor. Typically,
1047 it's used to boot another kernel image, so it's not much
1048 different from reboot(8). Therefore, we don't need to
1049 spin down the disk in this case, especially since Alpha
1050 firmware doesn't handle disks in standby mode properly.
1051 On the other hand, it's reasonably safe to turn the power
1052 off when the shutdown process reaches the firmware prompt,
1053 as the firmware initialization takes rather long time -
1054 at least 10 seconds, which should be sufficient for
1055 the disk to expire its write cache. */
1056 if (system_state != SYSTEM_POWER_OFF) {
1058 if (system_state == SYSTEM_RESTART) {
1060 ide_cacheflush_p(drive);
1064 printk("Shutdown: %s\n", drive->name);
1065 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
1068 static ide_driver_t idedisk_driver = {
1070 .owner = THIS_MODULE,
1072 .bus = &ide_bus_type,
1074 .probe = ide_disk_probe,
1075 .remove = ide_disk_remove,
1076 .shutdown = ide_device_shutdown,
1077 .version = IDEDISK_VERSION,
1079 .supports_dsc_overlap = 0,
1080 .do_request = ide_do_rw_disk,
1081 .end_request = ide_end_request,
1082 .error = __ide_error,
1083 .abort = __ide_abort,
1084 .proc = idedisk_proc,
1087 static int idedisk_open(struct inode *inode, struct file *filp)
1089 struct gendisk *disk = inode->i_bdev->bd_disk;
1090 struct ide_disk_obj *idkp;
1093 if (!(idkp = ide_disk_get(disk)))
1096 drive = idkp->drive;
1100 if (drive->removable && idkp->openers == 1) {
1102 memset(&args, 0, sizeof(ide_task_t));
1103 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORLOCK;
1104 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1105 args.handler = &task_no_data_intr;
1106 check_disk_change(inode->i_bdev);
1108 * Ignore the return code from door_lock,
1109 * since the open() has already succeeded,
1110 * and the door_lock is irrelevant at this point.
1112 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1113 drive->doorlocking = 0;
1118 static int idedisk_release(struct inode *inode, struct file *filp)
1120 struct gendisk *disk = inode->i_bdev->bd_disk;
1121 struct ide_disk_obj *idkp = ide_disk_g(disk);
1122 ide_drive_t *drive = idkp->drive;
1124 if (idkp->openers == 1)
1125 ide_cacheflush_p(drive);
1127 if (drive->removable && idkp->openers == 1) {
1129 memset(&args, 0, sizeof(ide_task_t));
1130 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORUNLOCK;
1131 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1132 args.handler = &task_no_data_intr;
1133 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1134 drive->doorlocking = 0;
1144 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1146 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1147 ide_drive_t *drive = idkp->drive;
1149 geo->heads = drive->bios_head;
1150 geo->sectors = drive->bios_sect;
1151 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1155 static int idedisk_ioctl(struct inode *inode, struct file *file,
1156 unsigned int cmd, unsigned long arg)
1158 unsigned long flags;
1159 struct block_device *bdev = inode->i_bdev;
1160 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1161 ide_drive_t *drive = idkp->drive;
1162 int err, (*setfunc)(ide_drive_t *, int);
1166 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1167 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1168 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1169 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1170 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1171 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1172 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1173 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1174 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1175 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1178 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1181 down(&ide_setting_sem);
1182 spin_lock_irqsave(&ide_lock, flags);
1184 spin_unlock_irqrestore(&ide_lock, flags);
1185 up(&ide_setting_sem);
1186 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1189 if (bdev != bdev->bd_contains)
1192 if (!capable(CAP_SYS_ADMIN))
1195 down(&ide_setting_sem);
1196 err = setfunc(drive, arg);
1197 up(&ide_setting_sem);
1203 static int idedisk_media_changed(struct gendisk *disk)
1205 struct ide_disk_obj *idkp = ide_disk_g(disk);
1206 ide_drive_t *drive = idkp->drive;
1208 /* do not scan partitions twice if this is a removable device */
1209 if (drive->attach) {
1213 /* if removable, always assume it was changed */
1214 return drive->removable;
1217 static int idedisk_revalidate_disk(struct gendisk *disk)
1219 struct ide_disk_obj *idkp = ide_disk_g(disk);
1220 set_capacity(disk, idedisk_capacity(idkp->drive));
1224 static struct block_device_operations idedisk_ops = {
1225 .owner = THIS_MODULE,
1226 .open = idedisk_open,
1227 .release = idedisk_release,
1228 .ioctl = idedisk_ioctl,
1229 .getgeo = idedisk_getgeo,
1230 .media_changed = idedisk_media_changed,
1231 .revalidate_disk= idedisk_revalidate_disk
1234 MODULE_DESCRIPTION("ATA DISK Driver");
1236 static int ide_disk_probe(ide_drive_t *drive)
1238 struct ide_disk_obj *idkp;
1241 /* strstr("foo", "") is non-NULL */
1242 if (!strstr("ide-disk", drive->driver_req))
1244 if (!drive->present)
1246 if (drive->media != ide_disk)
1249 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1253 g = alloc_disk_node(1 << PARTN_BITS,
1254 hwif_to_node(drive->hwif));
1258 ide_init_disk(g, drive);
1260 ide_register_subdriver(drive, &idedisk_driver);
1262 kref_init(&idkp->kref);
1264 idkp->drive = drive;
1265 idkp->driver = &idedisk_driver;
1268 g->private_data = &idkp->driver;
1270 drive->driver_data = idkp;
1272 idedisk_setup(drive);
1273 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1274 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1275 drive->name, drive->head);
1280 g->minors = 1 << PARTN_BITS;
1281 g->driverfs_dev = &drive->gendev;
1282 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1283 set_capacity(g, idedisk_capacity(drive));
1284 g->fops = &idedisk_ops;
1294 static void __exit idedisk_exit (void)
1296 driver_unregister(&idedisk_driver.gen_driver);
1299 static int __init idedisk_init(void)
1301 return driver_register(&idedisk_driver.gen_driver);
1304 MODULE_ALIAS("ide:*m-disk*");
1305 module_init(idedisk_init);
1306 module_exit(idedisk_exit);
1307 MODULE_LICENSE("GPL");