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.
18 #define IDEDISK_VERSION "1.18"
22 #include <linux/module.h>
23 #include <linux/types.h>
24 #include <linux/string.h>
25 #include <linux/kernel.h>
26 #include <linux/timer.h>
28 #include <linux/interrupt.h>
29 #include <linux/major.h>
30 #include <linux/errno.h>
31 #include <linux/genhd.h>
32 #include <linux/slab.h>
33 #include <linux/delay.h>
34 #include <linux/mutex.h>
35 #include <linux/leds.h>
39 #include <linux/ide.h>
41 #include <asm/byteorder.h>
43 #include <asm/uaccess.h>
45 #include <asm/div64.h>
52 unsigned int openers; /* protected by BKL for now */
55 static DEFINE_MUTEX(idedisk_ref_mutex);
57 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
59 #define ide_disk_g(disk) \
60 container_of((disk)->private_data, struct ide_disk_obj, driver)
62 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
64 struct ide_disk_obj *idkp = NULL;
66 mutex_lock(&idedisk_ref_mutex);
67 idkp = ide_disk_g(disk);
69 kref_get(&idkp->kref);
70 mutex_unlock(&idedisk_ref_mutex);
74 static void ide_disk_release(struct kref *);
76 static void ide_disk_put(struct ide_disk_obj *idkp)
78 mutex_lock(&idedisk_ref_mutex);
79 kref_put(&idkp->kref, ide_disk_release);
80 mutex_unlock(&idedisk_ref_mutex);
84 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
85 * value for this drive (from its reported identification information).
87 * Returns: 1 if lba_capacity looks sensible
90 * It is called only once for each drive.
92 static int lba_capacity_is_ok (struct hd_driveid *id)
94 unsigned long lba_sects, chs_sects, head, tail;
96 /* No non-LBA info .. so valid! */
101 * The ATA spec tells large drives to return
102 * C/H/S = 16383/16/63 independent of their size.
103 * Some drives can be jumpered to use 15 heads instead of 16.
104 * Some drives can be jumpered to use 4092 cyls instead of 16383.
106 if ((id->cyls == 16383
107 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
109 (id->heads == 15 || id->heads == 16) &&
110 (id->lba_capacity >= 16383*63*id->heads))
113 lba_sects = id->lba_capacity;
114 chs_sects = id->cyls * id->heads * id->sectors;
116 /* perform a rough sanity check on lba_sects: within 10% is OK */
117 if ((lba_sects - chs_sects) < chs_sects/10)
120 /* some drives have the word order reversed */
121 head = ((lba_sects >> 16) & 0xffff);
122 tail = (lba_sects & 0xffff);
123 lba_sects = (head | (tail << 16));
124 if ((lba_sects - chs_sects) < chs_sects/10) {
125 id->lba_capacity = lba_sects;
126 return 1; /* lba_capacity is (now) good */
129 return 0; /* lba_capacity value may be bad */
132 static const u8 ide_rw_cmds[] = {
147 static const u8 ide_data_phases[] = {
156 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
158 u8 index, lba48, write;
160 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
161 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
164 index = drive->vdma ? 4 : 8;
166 index = drive->mult_count ? 0 : 4;
168 task->tf.command = ide_rw_cmds[index + lba48 + write];
171 index = 8; /* fixup index */
173 task->data_phase = ide_data_phases[index / 2 + write];
177 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
178 * using LBA if supported, or CHS otherwise, to address sectors.
180 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
182 ide_hwif_t *hwif = HWIF(drive);
183 unsigned int dma = drive->using_dma;
184 u16 nsectors = (u16)rq->nr_sectors;
185 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
187 struct ide_taskfile *tf = &task.tf;
190 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
191 if (block + rq->nr_sectors > 1ULL << 28)
198 ide_init_sg_cmd(drive, rq);
199 ide_map_sg(drive, rq);
202 memset(&task, 0, sizeof(task));
203 task.tf_flags = IDE_TFLAG_NO_SELECT_MASK; /* FIXME? */
204 task.tf_flags |= (IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE);
206 if (drive->select.b.lba) {
208 pr_debug("%s: LBA=0x%012llx\n", drive->name,
209 (unsigned long long)block);
211 tf->hob_nsect = (nsectors >> 8) & 0xff;
212 tf->hob_lbal = (u8)(block >> 24);
213 if (sizeof(block) != 4) {
214 tf->hob_lbam = (u8)((u64)block >> 32);
215 tf->hob_lbah = (u8)((u64)block >> 40);
218 tf->nsect = nsectors & 0xff;
219 tf->lbal = (u8) block;
220 tf->lbam = (u8)(block >> 8);
221 tf->lbah = (u8)(block >> 16);
223 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
225 tf->nsect = nsectors & 0xff;
227 tf->lbam = block >>= 8;
228 tf->lbah = block >>= 8;
229 tf->device = (block >> 8) & 0xf;
232 unsigned int sect,head,cyl,track;
233 track = (int)block / drive->sect;
234 sect = (int)block % drive->sect + 1;
235 head = track % drive->head;
236 cyl = track / drive->head;
238 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
240 tf->nsect = nsectors & 0xff;
248 task.tf_flags |= IDE_TFLAG_WRITE;
250 ide_tf_set_cmd(drive, &task, dma);
252 hwif->data_phase = task.data_phase;
255 rc = do_rw_taskfile(drive, &task);
257 if (rc == ide_stopped && dma) {
258 /* fallback to PIO */
259 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
260 ide_tf_set_cmd(drive, &task, 0);
261 hwif->data_phase = task.data_phase;
262 ide_init_sg_cmd(drive, rq);
263 rc = do_rw_taskfile(drive, &task);
270 * 268435455 == 137439 MB or 28bit limit
271 * 320173056 == 163929 MB or 48bit addressing
272 * 1073741822 == 549756 MB or 48bit addressing fake drive
275 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
277 ide_hwif_t *hwif = HWIF(drive);
279 BUG_ON(drive->blocked);
281 if (!blk_fs_request(rq)) {
282 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
283 ide_end_request(drive, 0, 0);
287 ledtrig_ide_activity();
289 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
290 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
291 (unsigned long long)block, rq->nr_sectors,
292 (unsigned long)rq->buffer);
295 hwif->rw_disk(drive, rq);
297 return __ide_do_rw_disk(drive, rq, block);
301 * Queries for true maximum capacity of the drive.
302 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
304 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
307 struct ide_taskfile *tf = &args.tf;
310 /* Create IDE/ATA command request structure */
311 memset(&args, 0, sizeof(ide_task_t));
313 tf->command = WIN_READ_NATIVE_MAX_EXT;
315 tf->command = WIN_READ_NATIVE_MAX;
316 tf->device = ATA_LBA;
317 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
319 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
320 /* submit command request */
321 ide_no_data_taskfile(drive, &args);
323 /* if OK, compute maximum address value */
324 if ((tf->status & 0x01) == 0)
325 addr = ide_get_lba_addr(tf, lba48) + 1;
331 * Sets maximum virtual LBA address of the drive.
332 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
334 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
337 struct ide_taskfile *tf = &args.tf;
341 /* Create IDE/ATA command request structure */
342 memset(&args, 0, sizeof(ide_task_t));
343 tf->lbal = (addr_req >> 0) & 0xff;
344 tf->lbam = (addr_req >>= 8) & 0xff;
345 tf->lbah = (addr_req >>= 8) & 0xff;
347 tf->hob_lbal = (addr_req >>= 8) & 0xff;
348 tf->hob_lbam = (addr_req >>= 8) & 0xff;
349 tf->hob_lbah = (addr_req >>= 8) & 0xff;
350 tf->command = WIN_SET_MAX_EXT;
352 tf->device = (addr_req >>= 8) & 0x0f;
353 tf->command = WIN_SET_MAX;
355 tf->device |= ATA_LBA;
356 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
358 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
359 /* submit command request */
360 ide_no_data_taskfile(drive, &args);
361 /* if OK, compute maximum address value */
362 if ((tf->status & 0x01) == 0)
363 addr_set = ide_get_lba_addr(tf, lba48) + 1;
368 static unsigned long long sectors_to_MB(unsigned long long n)
370 n <<= 9; /* make it bytes */
371 do_div(n, 1000000); /* make it MB */
376 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
377 * so on non-buggy drives we need test only one.
378 * However, we should also check whether these fields are valid.
380 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
382 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
388 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
390 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
391 && id->lba_capacity_2;
395 * Some disks report total number of sectors instead of
396 * maximum sector address. We list them here.
398 static const struct drive_list_entry hpa_list[] = {
399 { "ST340823A", NULL },
400 { "ST320413A", NULL },
404 static void idedisk_check_hpa(ide_drive_t *drive)
406 unsigned long long capacity, set_max;
407 int lba48 = idedisk_supports_lba48(drive->id);
409 capacity = drive->capacity64;
411 set_max = idedisk_read_native_max_address(drive, lba48);
413 if (ide_in_drive_list(drive->id, hpa_list)) {
415 * Since we are inclusive wrt to firmware revisions do this
416 * extra check and apply the workaround only when needed.
418 if (set_max == capacity + 1)
422 if (set_max <= capacity)
425 printk(KERN_INFO "%s: Host Protected Area detected.\n"
426 "\tcurrent capacity is %llu sectors (%llu MB)\n"
427 "\tnative capacity is %llu sectors (%llu MB)\n",
429 capacity, sectors_to_MB(capacity),
430 set_max, sectors_to_MB(set_max));
432 set_max = idedisk_set_max_address(drive, set_max, lba48);
435 drive->capacity64 = set_max;
436 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
442 * Compute drive->capacity, the full capacity of the drive
443 * Called with drive->id != NULL.
445 * To compute capacity, this uses either of
447 * 1. CHS value set by user (whatever user sets will be trusted)
448 * 2. LBA value from target drive (require new ATA feature)
449 * 3. LBA value from system BIOS (new one is OK, old one may break)
450 * 4. CHS value from system BIOS (traditional style)
452 * in above order (i.e., if value of higher priority is available,
453 * reset will be ignored).
455 static void init_idedisk_capacity (ide_drive_t *drive)
457 struct hd_driveid *id = drive->id;
459 * If this drive supports the Host Protected Area feature set,
460 * then we may need to change our opinion about the drive's capacity.
462 int hpa = idedisk_supports_hpa(id);
464 if (idedisk_supports_lba48(id)) {
465 /* drive speaks 48-bit LBA */
466 drive->select.b.lba = 1;
467 drive->capacity64 = id->lba_capacity_2;
469 idedisk_check_hpa(drive);
470 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
471 /* drive speaks 28-bit LBA */
472 drive->select.b.lba = 1;
473 drive->capacity64 = id->lba_capacity;
475 idedisk_check_hpa(drive);
477 /* drive speaks boring old 28-bit CHS */
478 drive->capacity64 = drive->cyl * drive->head * drive->sect;
482 static sector_t idedisk_capacity (ide_drive_t *drive)
484 return drive->capacity64 - drive->sect0;
487 #ifdef CONFIG_IDE_PROC_FS
488 static int smart_enable(ide_drive_t *drive)
491 struct ide_taskfile *tf = &args.tf;
493 memset(&args, 0, sizeof(ide_task_t));
494 tf->feature = SMART_ENABLE;
495 tf->lbam = SMART_LCYL_PASS;
496 tf->lbah = SMART_HCYL_PASS;
497 tf->command = WIN_SMART;
498 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
499 return ide_no_data_taskfile(drive, &args);
502 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
505 struct ide_taskfile *tf = &args.tf;
507 memset(&args, 0, sizeof(ide_task_t));
508 tf->feature = sub_cmd;
510 tf->lbam = SMART_LCYL_PASS;
511 tf->lbah = SMART_HCYL_PASS;
512 tf->command = WIN_SMART;
513 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
514 args.data_phase = TASKFILE_IN;
515 (void) smart_enable(drive);
516 return ide_raw_taskfile(drive, &args, buf, 1);
519 static int proc_idedisk_read_cache
520 (char *page, char **start, off_t off, int count, int *eof, void *data)
522 ide_drive_t *drive = (ide_drive_t *) data;
527 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
529 len = sprintf(out,"(none)\n");
530 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
533 static int proc_idedisk_read_capacity
534 (char *page, char **start, off_t off, int count, int *eof, void *data)
536 ide_drive_t*drive = (ide_drive_t *)data;
539 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
540 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
543 static int proc_idedisk_read_smart_thresholds
544 (char *page, char **start, off_t off, int count, int *eof, void *data)
546 ide_drive_t *drive = (ide_drive_t *)data;
549 if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
550 unsigned short *val = (unsigned short *) page;
551 char *out = ((char *)val) + (SECTOR_WORDS * 4);
554 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
556 } while (i < (SECTOR_WORDS * 2));
559 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
562 static int proc_idedisk_read_smart_values
563 (char *page, char **start, off_t off, int count, int *eof, void *data)
565 ide_drive_t *drive = (ide_drive_t *)data;
568 if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
569 unsigned short *val = (unsigned short *) page;
570 char *out = ((char *)val) + (SECTOR_WORDS * 4);
573 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
575 } while (i < (SECTOR_WORDS * 2));
578 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
581 static ide_proc_entry_t idedisk_proc[] = {
582 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
583 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
584 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
585 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
586 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
587 { NULL, 0, NULL, NULL }
589 #endif /* CONFIG_IDE_PROC_FS */
591 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
593 ide_drive_t *drive = q->queuedata;
596 memset(&task, 0, sizeof(task));
597 if (ide_id_has_flush_cache_ext(drive->id) &&
598 (drive->capacity64 >= (1UL << 28)))
599 task.tf.command = WIN_FLUSH_CACHE_EXT;
601 task.tf.command = WIN_FLUSH_CACHE;
602 task.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
603 task.data_phase = TASKFILE_NO_DATA;
605 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
606 rq->cmd_flags |= REQ_SOFTBARRIER;
611 * This is tightly woven into the driver->do_special can not touch.
612 * DON'T do it again until a total personality rewrite is committed.
614 static int set_multcount(ide_drive_t *drive, int arg)
618 if (arg < 0 || arg > drive->id->max_multsect)
621 if (drive->special.b.set_multmode)
623 ide_init_drive_cmd (&rq);
624 rq.cmd_type = REQ_TYPE_ATA_CMD;
625 drive->mult_req = arg;
626 drive->special.b.set_multmode = 1;
627 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
628 return (drive->mult_count == arg) ? 0 : -EIO;
631 static int set_nowerr(ide_drive_t *drive, int arg)
633 if (arg < 0 || arg > 1)
636 if (ide_spin_wait_hwgroup(drive))
639 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
640 spin_unlock_irq(&ide_lock);
644 static void update_ordered(ide_drive_t *drive)
646 struct hd_driveid *id = drive->id;
647 unsigned ordered = QUEUE_ORDERED_NONE;
648 prepare_flush_fn *prep_fn = NULL;
651 unsigned long long capacity;
654 * We must avoid issuing commands a drive does not
655 * understand or we may crash it. We check flush cache
656 * is supported. We also check we have the LBA48 flush
657 * cache if the drive capacity is too large. By this
658 * time we have trimmed the drive capacity if LBA48 is
659 * not available so we don't need to recheck that.
661 capacity = idedisk_capacity(drive);
662 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
663 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
664 ide_id_has_flush_cache_ext(id));
666 printk(KERN_INFO "%s: cache flushes %ssupported\n",
667 drive->name, barrier ? "" : "not ");
670 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
671 prep_fn = idedisk_prepare_flush;
674 ordered = QUEUE_ORDERED_DRAIN;
676 blk_queue_ordered(drive->queue, ordered, prep_fn);
679 static int write_cache(ide_drive_t *drive, int arg)
684 if (arg < 0 || arg > 1)
687 if (ide_id_has_flush_cache(drive->id)) {
688 memset(&args, 0, sizeof(ide_task_t));
689 args.tf.feature = arg ?
690 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
691 args.tf.command = WIN_SETFEATURES;
692 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
693 err = ide_no_data_taskfile(drive, &args);
698 update_ordered(drive);
703 static int do_idedisk_flushcache (ide_drive_t *drive)
707 memset(&args, 0, sizeof(ide_task_t));
708 if (ide_id_has_flush_cache_ext(drive->id))
709 args.tf.command = WIN_FLUSH_CACHE_EXT;
711 args.tf.command = WIN_FLUSH_CACHE;
712 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
713 return ide_no_data_taskfile(drive, &args);
716 static int set_acoustic (ide_drive_t *drive, int arg)
720 if (arg < 0 || arg > 254)
723 memset(&args, 0, sizeof(ide_task_t));
724 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
726 args.tf.command = WIN_SETFEATURES;
727 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
728 ide_no_data_taskfile(drive, &args);
729 drive->acoustic = arg;
737 * 2: 48-bit capable doing 28-bit
739 static int set_lba_addressing(ide_drive_t *drive, int arg)
741 if (arg < 0 || arg > 2)
744 drive->addressing = 0;
746 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
749 if (!idedisk_supports_lba48(drive->id))
751 drive->addressing = arg;
755 #ifdef CONFIG_IDE_PROC_FS
756 static void idedisk_add_settings(ide_drive_t *drive)
758 struct hd_driveid *id = drive->id;
760 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
761 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
762 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
763 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
764 ide_add_setting(drive, "bswap", SETTING_READ, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
765 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount);
766 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
767 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
768 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
769 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
770 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
771 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
774 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
777 static void idedisk_setup (ide_drive_t *drive)
779 ide_hwif_t *hwif = drive->hwif;
780 struct hd_driveid *id = drive->id;
781 unsigned long long capacity;
783 idedisk_add_settings(drive);
785 if (drive->id_read == 0)
788 if (drive->removable) {
790 * Removable disks (eg. SYQUEST); ignore 'WD' drives
792 if (id->model[0] != 'W' || id->model[1] != 'D') {
793 drive->doorlocking = 1;
797 (void)set_lba_addressing(drive, 1);
799 if (drive->addressing == 1) {
802 if (max_s > hwif->rqsize)
803 max_s = hwif->rqsize;
805 blk_queue_max_sectors(drive->queue, max_s);
808 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
810 /* calculate drive capacity, and select LBA if possible */
811 init_idedisk_capacity (drive);
813 /* limit drive capacity to 137GB if LBA48 cannot be used */
814 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
815 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
816 "%llu sectors (%llu MB)\n",
817 drive->name, (unsigned long long)drive->capacity64,
818 sectors_to_MB(drive->capacity64));
819 drive->capacity64 = 1ULL << 28;
822 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
823 if (drive->capacity64 > 1ULL << 28) {
824 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
825 " be used for accessing sectors > %u\n",
826 drive->name, 1 << 28);
828 drive->addressing = 0;
832 * if possible, give fdisk access to more of the drive,
833 * by correcting bios_cyls:
835 capacity = idedisk_capacity (drive);
836 if (!drive->forced_geom) {
838 if (idedisk_supports_lba48(drive->id)) {
840 drive->bios_sect = 63;
841 drive->bios_head = 255;
844 if (drive->bios_sect && drive->bios_head) {
845 unsigned int cap0 = capacity; /* truncate to 32 bits */
846 unsigned int cylsz, cyl;
848 if (cap0 != capacity)
849 drive->bios_cyl = 65535;
851 cylsz = drive->bios_sect * drive->bios_head;
855 if (cyl > drive->bios_cyl)
856 drive->bios_cyl = cyl;
860 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
861 drive->name, capacity, sectors_to_MB(capacity));
863 /* Only print cache size when it was specified */
865 printk (" w/%dKiB Cache", id->buf_size/2);
867 printk(KERN_CONT ", CHS=%d/%d/%d\n",
868 drive->bios_cyl, drive->bios_head, drive->bios_sect);
870 /* write cache enabled? */
871 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
874 write_cache(drive, 1);
877 static void ide_cacheflush_p(ide_drive_t *drive)
879 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
882 if (do_idedisk_flushcache(drive))
883 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
886 static void ide_disk_remove(ide_drive_t *drive)
888 struct ide_disk_obj *idkp = drive->driver_data;
889 struct gendisk *g = idkp->disk;
891 ide_proc_unregister_driver(drive, idkp->driver);
895 ide_cacheflush_p(drive);
900 static void ide_disk_release(struct kref *kref)
902 struct ide_disk_obj *idkp = to_ide_disk(kref);
903 ide_drive_t *drive = idkp->drive;
904 struct gendisk *g = idkp->disk;
906 drive->driver_data = NULL;
907 g->private_data = NULL;
912 static int ide_disk_probe(ide_drive_t *drive);
915 * On HPA drives the capacity needs to be
916 * reinitilized on resume otherwise the disk
917 * can not be used and a hard reset is required
919 static void ide_disk_resume(ide_drive_t *drive)
921 if (idedisk_supports_hpa(drive->id))
922 init_idedisk_capacity(drive);
925 static void ide_device_shutdown(ide_drive_t *drive)
928 /* On Alpha, halt(8) doesn't actually turn the machine off,
929 it puts you into the sort of firmware monitor. Typically,
930 it's used to boot another kernel image, so it's not much
931 different from reboot(8). Therefore, we don't need to
932 spin down the disk in this case, especially since Alpha
933 firmware doesn't handle disks in standby mode properly.
934 On the other hand, it's reasonably safe to turn the power
935 off when the shutdown process reaches the firmware prompt,
936 as the firmware initialization takes rather long time -
937 at least 10 seconds, which should be sufficient for
938 the disk to expire its write cache. */
939 if (system_state != SYSTEM_POWER_OFF) {
941 if (system_state == SYSTEM_RESTART) {
943 ide_cacheflush_p(drive);
947 printk("Shutdown: %s\n", drive->name);
948 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
951 static ide_driver_t idedisk_driver = {
953 .owner = THIS_MODULE,
955 .bus = &ide_bus_type,
957 .probe = ide_disk_probe,
958 .remove = ide_disk_remove,
959 .resume = ide_disk_resume,
960 .shutdown = ide_device_shutdown,
961 .version = IDEDISK_VERSION,
963 .supports_dsc_overlap = 0,
964 .do_request = ide_do_rw_disk,
965 .end_request = ide_end_request,
966 .error = __ide_error,
967 .abort = __ide_abort,
968 #ifdef CONFIG_IDE_PROC_FS
969 .proc = idedisk_proc,
973 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
977 memset(&task, 0, sizeof(task));
978 task.tf.command = on ? WIN_DOORLOCK : WIN_DOORUNLOCK;
979 task.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
981 return ide_no_data_taskfile(drive, &task);
984 static int idedisk_open(struct inode *inode, struct file *filp)
986 struct gendisk *disk = inode->i_bdev->bd_disk;
987 struct ide_disk_obj *idkp;
990 if (!(idkp = ide_disk_get(disk)))
997 if (drive->removable && idkp->openers == 1) {
998 check_disk_change(inode->i_bdev);
1000 * Ignore the return code from door_lock,
1001 * since the open() has already succeeded,
1002 * and the door_lock is irrelevant at this point.
1004 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1005 drive->doorlocking = 0;
1010 static int idedisk_release(struct inode *inode, struct file *filp)
1012 struct gendisk *disk = inode->i_bdev->bd_disk;
1013 struct ide_disk_obj *idkp = ide_disk_g(disk);
1014 ide_drive_t *drive = idkp->drive;
1016 if (idkp->openers == 1)
1017 ide_cacheflush_p(drive);
1019 if (drive->removable && idkp->openers == 1) {
1020 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1021 drive->doorlocking = 0;
1031 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1033 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1034 ide_drive_t *drive = idkp->drive;
1036 geo->heads = drive->bios_head;
1037 geo->sectors = drive->bios_sect;
1038 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1042 static int idedisk_ioctl(struct inode *inode, struct file *file,
1043 unsigned int cmd, unsigned long arg)
1045 unsigned long flags;
1046 struct block_device *bdev = inode->i_bdev;
1047 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1048 ide_drive_t *drive = idkp->drive;
1049 int err, (*setfunc)(ide_drive_t *, int);
1053 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1054 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1055 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1056 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1057 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1058 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1059 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1060 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1061 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1062 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1065 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1068 mutex_lock(&ide_setting_mtx);
1069 spin_lock_irqsave(&ide_lock, flags);
1071 spin_unlock_irqrestore(&ide_lock, flags);
1072 mutex_unlock(&ide_setting_mtx);
1073 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1076 if (bdev != bdev->bd_contains)
1079 if (!capable(CAP_SYS_ADMIN))
1082 mutex_lock(&ide_setting_mtx);
1083 err = setfunc(drive, arg);
1084 mutex_unlock(&ide_setting_mtx);
1090 static int idedisk_media_changed(struct gendisk *disk)
1092 struct ide_disk_obj *idkp = ide_disk_g(disk);
1093 ide_drive_t *drive = idkp->drive;
1095 /* do not scan partitions twice if this is a removable device */
1096 if (drive->attach) {
1100 /* if removable, always assume it was changed */
1101 return drive->removable;
1104 static int idedisk_revalidate_disk(struct gendisk *disk)
1106 struct ide_disk_obj *idkp = ide_disk_g(disk);
1107 set_capacity(disk, idedisk_capacity(idkp->drive));
1111 static struct block_device_operations idedisk_ops = {
1112 .owner = THIS_MODULE,
1113 .open = idedisk_open,
1114 .release = idedisk_release,
1115 .ioctl = idedisk_ioctl,
1116 .getgeo = idedisk_getgeo,
1117 .media_changed = idedisk_media_changed,
1118 .revalidate_disk= idedisk_revalidate_disk
1121 MODULE_DESCRIPTION("ATA DISK Driver");
1123 static int ide_disk_probe(ide_drive_t *drive)
1125 struct ide_disk_obj *idkp;
1128 /* strstr("foo", "") is non-NULL */
1129 if (!strstr("ide-disk", drive->driver_req))
1131 if (!drive->present)
1133 if (drive->media != ide_disk)
1136 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1140 g = alloc_disk_node(1 << PARTN_BITS,
1141 hwif_to_node(drive->hwif));
1145 ide_init_disk(g, drive);
1147 ide_proc_register_driver(drive, &idedisk_driver);
1149 kref_init(&idkp->kref);
1151 idkp->drive = drive;
1152 idkp->driver = &idedisk_driver;
1155 g->private_data = &idkp->driver;
1157 drive->driver_data = idkp;
1159 idedisk_setup(drive);
1160 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1161 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1162 drive->name, drive->head);
1167 g->minors = 1 << PARTN_BITS;
1168 g->driverfs_dev = &drive->gendev;
1169 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1170 set_capacity(g, idedisk_capacity(drive));
1171 g->fops = &idedisk_ops;
1181 static void __exit idedisk_exit (void)
1183 driver_unregister(&idedisk_driver.gen_driver);
1186 static int __init idedisk_init(void)
1188 return driver_register(&idedisk_driver.gen_driver);
1191 MODULE_ALIAS("ide:*m-disk*");
1192 module_init(idedisk_init);
1193 module_exit(idedisk_exit);
1194 MODULE_LICENSE("GPL");