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 */
133 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
134 * using LBA if supported, or CHS otherwise, to address sectors.
136 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
138 ide_hwif_t *hwif = HWIF(drive);
139 unsigned int dma = drive->using_dma;
140 u16 nsectors = (u16)rq->nr_sectors;
141 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
142 u8 command = WIN_NOP;
144 struct ide_taskfile *tf = &task.tf;
146 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
147 if (block + rq->nr_sectors > 1ULL << 28)
154 ide_init_sg_cmd(drive, rq);
155 ide_map_sg(drive, rq);
158 memset(&task, 0, sizeof(task));
159 task.tf_flags = IDE_TFLAG_NO_SELECT_MASK; /* FIXME? */
160 task.tf_flags |= (IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE);
162 if (drive->select.b.lba) {
164 pr_debug("%s: LBA=0x%012llx\n", drive->name,
165 (unsigned long long)block);
167 tf->hob_nsect = (nsectors >> 8) & 0xff;
168 tf->hob_lbal = (u8)(block >> 24);
169 if (sizeof(block) != 4) {
170 tf->hob_lbam = (u8)((u64)block >> 32);
171 tf->hob_lbah = (u8)((u64)block >> 40);
174 tf->nsect = nsectors & 0xff;
175 tf->lbal = (u8) block;
176 tf->lbam = (u8)(block >> 8);
177 tf->lbah = (u8)(block >> 16);
179 printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
180 drive->name, tf->hob_nsect, tf->nsect,
181 tf->hob_lbah, tf->hob_lbam, tf->hob_lbal,
182 tf->lbah, tf->lbam, tf->lbal);
184 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
186 tf->nsect = nsectors & 0xff;
188 tf->lbam = block >>= 8;
189 tf->lbah = block >>= 8;
190 tf->device = (block >> 8) & 0xf;
193 unsigned int sect,head,cyl,track;
194 track = (int)block / drive->sect;
195 sect = (int)block % drive->sect + 1;
196 head = track % drive->head;
197 cyl = track / drive->head;
199 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
201 tf->nsect = nsectors & 0xff;
208 ide_tf_load(drive, &task);
211 if (!hwif->dma_setup(drive)) {
212 if (rq_data_dir(rq)) {
213 command = lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
215 command = lba48 ? WIN_WRITE_EXT: WIN_WRITE;
217 command = lba48 ? WIN_READDMA_EXT : WIN_READDMA;
219 command = lba48 ? WIN_READ_EXT: WIN_READ;
221 hwif->dma_exec_cmd(drive, command);
222 hwif->dma_start(drive);
225 /* fallback to PIO */
226 ide_init_sg_cmd(drive, rq);
229 if (rq_data_dir(rq) == READ) {
231 if (drive->mult_count) {
232 hwif->data_phase = TASKFILE_MULTI_IN;
233 command = lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
235 hwif->data_phase = TASKFILE_IN;
236 command = lba48 ? WIN_READ_EXT : WIN_READ;
239 ide_execute_command(drive, command, &task_in_intr,
240 WAIT_WORSTCASE, NULL);
243 if (drive->mult_count) {
244 hwif->data_phase = TASKFILE_MULTI_OUT;
245 command = lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
247 hwif->data_phase = TASKFILE_OUT;
248 command = lba48 ? WIN_WRITE_EXT : WIN_WRITE;
251 hwif->OUTBSYNC(drive, command, IDE_COMMAND_REG);
252 ndelay(400); /* FIXME */
254 return pre_task_out_intr(drive, rq);
259 * 268435455 == 137439 MB or 28bit limit
260 * 320173056 == 163929 MB or 48bit addressing
261 * 1073741822 == 549756 MB or 48bit addressing fake drive
264 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
266 ide_hwif_t *hwif = HWIF(drive);
268 BUG_ON(drive->blocked);
270 if (!blk_fs_request(rq)) {
271 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
272 ide_end_request(drive, 0, 0);
276 ledtrig_ide_activity();
278 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
279 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
280 (unsigned long long)block, rq->nr_sectors,
281 (unsigned long)rq->buffer);
284 hwif->rw_disk(drive, rq);
286 return __ide_do_rw_disk(drive, rq, block);
290 * Queries for true maximum capacity of the drive.
291 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
293 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
296 struct ide_taskfile *tf = &args.tf;
299 /* Create IDE/ATA command request structure */
300 memset(&args, 0, sizeof(ide_task_t));
302 tf->command = WIN_READ_NATIVE_MAX_EXT;
304 tf->command = WIN_READ_NATIVE_MAX;
305 tf->device = ATA_LBA;
306 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
308 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
309 /* submit command request */
310 ide_no_data_taskfile(drive, &args);
312 /* if OK, compute maximum address value */
313 if ((tf->status & 0x01) == 0) {
317 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
320 high = tf->device & 0xf;
321 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
322 addr = ((__u64)high << 24) | low;
323 addr++; /* since the return value is (maxlba - 1), we add 1 */
329 * Sets maximum virtual LBA address of the drive.
330 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
332 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
335 struct ide_taskfile *tf = &args.tf;
339 /* Create IDE/ATA command request structure */
340 memset(&args, 0, sizeof(ide_task_t));
341 tf->lbal = (addr_req >> 0) & 0xff;
342 tf->lbam = (addr_req >>= 8) & 0xff;
343 tf->lbah = (addr_req >>= 8) & 0xff;
345 tf->hob_lbal = (addr_req >>= 8) & 0xff;
346 tf->hob_lbam = (addr_req >>= 8) & 0xff;
347 tf->hob_lbah = (addr_req >>= 8) & 0xff;
348 tf->command = WIN_SET_MAX_EXT;
350 tf->device = (addr_req >>= 8) & 0x0f;
351 tf->command = WIN_SET_MAX;
353 tf->device |= ATA_LBA;
354 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
356 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
357 /* submit command request */
358 ide_no_data_taskfile(drive, &args);
359 /* if OK, compute maximum address value */
360 if ((tf->status & 0x01) == 0) {
364 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
367 high = tf->device & 0xf;
368 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
369 addr_set = ((__u64)high << 24) | low;
375 static unsigned long long sectors_to_MB(unsigned long long n)
377 n <<= 9; /* make it bytes */
378 do_div(n, 1000000); /* make it MB */
383 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
384 * so on non-buggy drives we need test only one.
385 * However, we should also check whether these fields are valid.
387 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
389 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
395 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
397 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
398 && id->lba_capacity_2;
402 * Some disks report total number of sectors instead of
403 * maximum sector address. We list them here.
405 static const struct drive_list_entry hpa_list[] = {
406 { "ST340823A", NULL },
407 { "ST320413A", NULL },
411 static void idedisk_check_hpa(ide_drive_t *drive)
413 unsigned long long capacity, set_max;
414 int lba48 = idedisk_supports_lba48(drive->id);
416 capacity = drive->capacity64;
418 set_max = idedisk_read_native_max_address(drive, lba48);
420 if (ide_in_drive_list(drive->id, hpa_list)) {
422 * Since we are inclusive wrt to firmware revisions do this
423 * extra check and apply the workaround only when needed.
425 if (set_max == capacity + 1)
429 if (set_max <= capacity)
432 printk(KERN_INFO "%s: Host Protected Area detected.\n"
433 "\tcurrent capacity is %llu sectors (%llu MB)\n"
434 "\tnative capacity is %llu sectors (%llu MB)\n",
436 capacity, sectors_to_MB(capacity),
437 set_max, sectors_to_MB(set_max));
439 set_max = idedisk_set_max_address(drive, set_max, lba48);
442 drive->capacity64 = set_max;
443 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
449 * Compute drive->capacity, the full capacity of the drive
450 * Called with drive->id != NULL.
452 * To compute capacity, this uses either of
454 * 1. CHS value set by user (whatever user sets will be trusted)
455 * 2. LBA value from target drive (require new ATA feature)
456 * 3. LBA value from system BIOS (new one is OK, old one may break)
457 * 4. CHS value from system BIOS (traditional style)
459 * in above order (i.e., if value of higher priority is available,
460 * reset will be ignored).
462 static void init_idedisk_capacity (ide_drive_t *drive)
464 struct hd_driveid *id = drive->id;
466 * If this drive supports the Host Protected Area feature set,
467 * then we may need to change our opinion about the drive's capacity.
469 int hpa = idedisk_supports_hpa(id);
471 if (idedisk_supports_lba48(id)) {
472 /* drive speaks 48-bit LBA */
473 drive->select.b.lba = 1;
474 drive->capacity64 = id->lba_capacity_2;
476 idedisk_check_hpa(drive);
477 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
478 /* drive speaks 28-bit LBA */
479 drive->select.b.lba = 1;
480 drive->capacity64 = id->lba_capacity;
482 idedisk_check_hpa(drive);
484 /* drive speaks boring old 28-bit CHS */
485 drive->capacity64 = drive->cyl * drive->head * drive->sect;
489 static sector_t idedisk_capacity (ide_drive_t *drive)
491 return drive->capacity64 - drive->sect0;
494 #ifdef CONFIG_IDE_PROC_FS
495 static int smart_enable(ide_drive_t *drive)
498 struct ide_taskfile *tf = &args.tf;
500 memset(&args, 0, sizeof(ide_task_t));
501 tf->feature = SMART_ENABLE;
502 tf->lbam = SMART_LCYL_PASS;
503 tf->lbah = SMART_HCYL_PASS;
504 tf->command = WIN_SMART;
505 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
506 return ide_no_data_taskfile(drive, &args);
509 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
512 struct ide_taskfile *tf = &args.tf;
514 memset(&args, 0, sizeof(ide_task_t));
515 tf->feature = sub_cmd;
517 tf->lbam = SMART_LCYL_PASS;
518 tf->lbah = SMART_HCYL_PASS;
519 tf->command = WIN_SMART;
520 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
521 args.data_phase = TASKFILE_IN;
522 (void) smart_enable(drive);
523 return ide_raw_taskfile(drive, &args, buf, 1);
526 static int proc_idedisk_read_cache
527 (char *page, char **start, off_t off, int count, int *eof, void *data)
529 ide_drive_t *drive = (ide_drive_t *) data;
534 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
536 len = sprintf(out,"(none)\n");
537 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
540 static int proc_idedisk_read_capacity
541 (char *page, char **start, off_t off, int count, int *eof, void *data)
543 ide_drive_t*drive = (ide_drive_t *)data;
546 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
547 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
550 static int proc_idedisk_read_smart_thresholds
551 (char *page, char **start, off_t off, int count, int *eof, void *data)
553 ide_drive_t *drive = (ide_drive_t *)data;
556 if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
557 unsigned short *val = (unsigned short *) page;
558 char *out = ((char *)val) + (SECTOR_WORDS * 4);
561 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
563 } while (i < (SECTOR_WORDS * 2));
566 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
569 static int proc_idedisk_read_smart_values
570 (char *page, char **start, off_t off, int count, int *eof, void *data)
572 ide_drive_t *drive = (ide_drive_t *)data;
575 if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
576 unsigned short *val = (unsigned short *) page;
577 char *out = ((char *)val) + (SECTOR_WORDS * 4);
580 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
582 } while (i < (SECTOR_WORDS * 2));
585 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
588 static ide_proc_entry_t idedisk_proc[] = {
589 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
590 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
591 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
592 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
593 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
594 { NULL, 0, NULL, NULL }
596 #endif /* CONFIG_IDE_PROC_FS */
598 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
600 ide_drive_t *drive = q->queuedata;
603 memset(&task, 0, sizeof(task));
604 if (ide_id_has_flush_cache_ext(drive->id) &&
605 (drive->capacity64 >= (1UL << 28)))
606 task.tf.command = WIN_FLUSH_CACHE_EXT;
608 task.tf.command = WIN_FLUSH_CACHE;
609 task.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
610 task.data_phase = TASKFILE_NO_DATA;
612 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
613 rq->cmd_flags |= REQ_SOFTBARRIER;
618 * This is tightly woven into the driver->do_special can not touch.
619 * DON'T do it again until a total personality rewrite is committed.
621 static int set_multcount(ide_drive_t *drive, int arg)
625 if (arg < 0 || arg > drive->id->max_multsect)
628 if (drive->special.b.set_multmode)
630 ide_init_drive_cmd (&rq);
631 rq.cmd_type = REQ_TYPE_ATA_CMD;
632 drive->mult_req = arg;
633 drive->special.b.set_multmode = 1;
634 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
635 return (drive->mult_count == arg) ? 0 : -EIO;
638 static int set_nowerr(ide_drive_t *drive, int arg)
640 if (arg < 0 || arg > 1)
643 if (ide_spin_wait_hwgroup(drive))
646 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
647 spin_unlock_irq(&ide_lock);
651 static void update_ordered(ide_drive_t *drive)
653 struct hd_driveid *id = drive->id;
654 unsigned ordered = QUEUE_ORDERED_NONE;
655 prepare_flush_fn *prep_fn = NULL;
658 unsigned long long capacity;
661 * We must avoid issuing commands a drive does not
662 * understand or we may crash it. We check flush cache
663 * is supported. We also check we have the LBA48 flush
664 * cache if the drive capacity is too large. By this
665 * time we have trimmed the drive capacity if LBA48 is
666 * not available so we don't need to recheck that.
668 capacity = idedisk_capacity(drive);
669 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
670 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
671 ide_id_has_flush_cache_ext(id));
673 printk(KERN_INFO "%s: cache flushes %ssupported\n",
674 drive->name, barrier ? "" : "not ");
677 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
678 prep_fn = idedisk_prepare_flush;
681 ordered = QUEUE_ORDERED_DRAIN;
683 blk_queue_ordered(drive->queue, ordered, prep_fn);
686 static int write_cache(ide_drive_t *drive, int arg)
691 if (arg < 0 || arg > 1)
694 if (ide_id_has_flush_cache(drive->id)) {
695 memset(&args, 0, sizeof(ide_task_t));
696 args.tf.feature = arg ?
697 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
698 args.tf.command = WIN_SETFEATURES;
699 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
700 err = ide_no_data_taskfile(drive, &args);
705 update_ordered(drive);
710 static int do_idedisk_flushcache (ide_drive_t *drive)
714 memset(&args, 0, sizeof(ide_task_t));
715 if (ide_id_has_flush_cache_ext(drive->id))
716 args.tf.command = WIN_FLUSH_CACHE_EXT;
718 args.tf.command = WIN_FLUSH_CACHE;
719 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
720 return ide_no_data_taskfile(drive, &args);
723 static int set_acoustic (ide_drive_t *drive, int arg)
727 if (arg < 0 || arg > 254)
730 memset(&args, 0, sizeof(ide_task_t));
731 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
733 args.tf.command = WIN_SETFEATURES;
734 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
735 ide_no_data_taskfile(drive, &args);
736 drive->acoustic = arg;
744 * 2: 48-bit capable doing 28-bit
746 static int set_lba_addressing(ide_drive_t *drive, int arg)
748 if (arg < 0 || arg > 2)
751 drive->addressing = 0;
753 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
756 if (!idedisk_supports_lba48(drive->id))
758 drive->addressing = arg;
762 #ifdef CONFIG_IDE_PROC_FS
763 static void idedisk_add_settings(ide_drive_t *drive)
765 struct hd_driveid *id = drive->id;
767 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
768 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
769 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
770 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
771 ide_add_setting(drive, "bswap", SETTING_READ, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
772 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount);
773 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
774 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
775 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
776 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
777 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
778 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
781 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
784 static void idedisk_setup (ide_drive_t *drive)
786 ide_hwif_t *hwif = drive->hwif;
787 struct hd_driveid *id = drive->id;
788 unsigned long long capacity;
790 idedisk_add_settings(drive);
792 if (drive->id_read == 0)
795 if (drive->removable) {
797 * Removable disks (eg. SYQUEST); ignore 'WD' drives
799 if (id->model[0] != 'W' || id->model[1] != 'D') {
800 drive->doorlocking = 1;
804 (void)set_lba_addressing(drive, 1);
806 if (drive->addressing == 1) {
809 if (max_s > hwif->rqsize)
810 max_s = hwif->rqsize;
812 blk_queue_max_sectors(drive->queue, max_s);
815 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
817 /* calculate drive capacity, and select LBA if possible */
818 init_idedisk_capacity (drive);
820 /* limit drive capacity to 137GB if LBA48 cannot be used */
821 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
822 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
823 "%llu sectors (%llu MB)\n",
824 drive->name, (unsigned long long)drive->capacity64,
825 sectors_to_MB(drive->capacity64));
826 drive->capacity64 = 1ULL << 28;
829 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
830 if (drive->capacity64 > 1ULL << 28) {
831 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
832 " be used for accessing sectors > %u\n",
833 drive->name, 1 << 28);
835 drive->addressing = 0;
839 * if possible, give fdisk access to more of the drive,
840 * by correcting bios_cyls:
842 capacity = idedisk_capacity (drive);
843 if (!drive->forced_geom) {
845 if (idedisk_supports_lba48(drive->id)) {
847 drive->bios_sect = 63;
848 drive->bios_head = 255;
851 if (drive->bios_sect && drive->bios_head) {
852 unsigned int cap0 = capacity; /* truncate to 32 bits */
853 unsigned int cylsz, cyl;
855 if (cap0 != capacity)
856 drive->bios_cyl = 65535;
858 cylsz = drive->bios_sect * drive->bios_head;
862 if (cyl > drive->bios_cyl)
863 drive->bios_cyl = cyl;
867 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
868 drive->name, capacity, sectors_to_MB(capacity));
870 /* Only print cache size when it was specified */
872 printk (" w/%dKiB Cache", id->buf_size/2);
874 printk(KERN_CONT ", CHS=%d/%d/%d\n",
875 drive->bios_cyl, drive->bios_head, drive->bios_sect);
877 /* write cache enabled? */
878 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
881 write_cache(drive, 1);
884 static void ide_cacheflush_p(ide_drive_t *drive)
886 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
889 if (do_idedisk_flushcache(drive))
890 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
893 static void ide_disk_remove(ide_drive_t *drive)
895 struct ide_disk_obj *idkp = drive->driver_data;
896 struct gendisk *g = idkp->disk;
898 ide_proc_unregister_driver(drive, idkp->driver);
902 ide_cacheflush_p(drive);
907 static void ide_disk_release(struct kref *kref)
909 struct ide_disk_obj *idkp = to_ide_disk(kref);
910 ide_drive_t *drive = idkp->drive;
911 struct gendisk *g = idkp->disk;
913 drive->driver_data = NULL;
914 g->private_data = NULL;
919 static int ide_disk_probe(ide_drive_t *drive);
922 * On HPA drives the capacity needs to be
923 * reinitilized on resume otherwise the disk
924 * can not be used and a hard reset is required
926 static void ide_disk_resume(ide_drive_t *drive)
928 if (idedisk_supports_hpa(drive->id))
929 init_idedisk_capacity(drive);
932 static void ide_device_shutdown(ide_drive_t *drive)
935 /* On Alpha, halt(8) doesn't actually turn the machine off,
936 it puts you into the sort of firmware monitor. Typically,
937 it's used to boot another kernel image, so it's not much
938 different from reboot(8). Therefore, we don't need to
939 spin down the disk in this case, especially since Alpha
940 firmware doesn't handle disks in standby mode properly.
941 On the other hand, it's reasonably safe to turn the power
942 off when the shutdown process reaches the firmware prompt,
943 as the firmware initialization takes rather long time -
944 at least 10 seconds, which should be sufficient for
945 the disk to expire its write cache. */
946 if (system_state != SYSTEM_POWER_OFF) {
948 if (system_state == SYSTEM_RESTART) {
950 ide_cacheflush_p(drive);
954 printk("Shutdown: %s\n", drive->name);
955 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
958 static ide_driver_t idedisk_driver = {
960 .owner = THIS_MODULE,
962 .bus = &ide_bus_type,
964 .probe = ide_disk_probe,
965 .remove = ide_disk_remove,
966 .resume = ide_disk_resume,
967 .shutdown = ide_device_shutdown,
968 .version = IDEDISK_VERSION,
970 .supports_dsc_overlap = 0,
971 .do_request = ide_do_rw_disk,
972 .end_request = ide_end_request,
973 .error = __ide_error,
974 .abort = __ide_abort,
975 #ifdef CONFIG_IDE_PROC_FS
976 .proc = idedisk_proc,
980 static int idedisk_open(struct inode *inode, struct file *filp)
982 struct gendisk *disk = inode->i_bdev->bd_disk;
983 struct ide_disk_obj *idkp;
986 if (!(idkp = ide_disk_get(disk)))
993 if (drive->removable && idkp->openers == 1) {
995 memset(&args, 0, sizeof(ide_task_t));
996 args.tf.command = WIN_DOORLOCK;
997 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
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 && ide_no_data_taskfile(drive, &args))
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) {
1021 memset(&args, 0, sizeof(ide_task_t));
1022 args.tf.command = WIN_DOORUNLOCK;
1023 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
1024 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
1025 drive->doorlocking = 0;
1035 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1037 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1038 ide_drive_t *drive = idkp->drive;
1040 geo->heads = drive->bios_head;
1041 geo->sectors = drive->bios_sect;
1042 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1046 static int idedisk_ioctl(struct inode *inode, struct file *file,
1047 unsigned int cmd, unsigned long arg)
1049 unsigned long flags;
1050 struct block_device *bdev = inode->i_bdev;
1051 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1052 ide_drive_t *drive = idkp->drive;
1053 int err, (*setfunc)(ide_drive_t *, int);
1057 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1058 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1059 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1060 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1061 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1062 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1063 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1064 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1065 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1066 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1069 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1072 mutex_lock(&ide_setting_mtx);
1073 spin_lock_irqsave(&ide_lock, flags);
1075 spin_unlock_irqrestore(&ide_lock, flags);
1076 mutex_unlock(&ide_setting_mtx);
1077 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1080 if (bdev != bdev->bd_contains)
1083 if (!capable(CAP_SYS_ADMIN))
1086 mutex_lock(&ide_setting_mtx);
1087 err = setfunc(drive, arg);
1088 mutex_unlock(&ide_setting_mtx);
1094 static int idedisk_media_changed(struct gendisk *disk)
1096 struct ide_disk_obj *idkp = ide_disk_g(disk);
1097 ide_drive_t *drive = idkp->drive;
1099 /* do not scan partitions twice if this is a removable device */
1100 if (drive->attach) {
1104 /* if removable, always assume it was changed */
1105 return drive->removable;
1108 static int idedisk_revalidate_disk(struct gendisk *disk)
1110 struct ide_disk_obj *idkp = ide_disk_g(disk);
1111 set_capacity(disk, idedisk_capacity(idkp->drive));
1115 static struct block_device_operations idedisk_ops = {
1116 .owner = THIS_MODULE,
1117 .open = idedisk_open,
1118 .release = idedisk_release,
1119 .ioctl = idedisk_ioctl,
1120 .getgeo = idedisk_getgeo,
1121 .media_changed = idedisk_media_changed,
1122 .revalidate_disk= idedisk_revalidate_disk
1125 MODULE_DESCRIPTION("ATA DISK Driver");
1127 static int ide_disk_probe(ide_drive_t *drive)
1129 struct ide_disk_obj *idkp;
1132 /* strstr("foo", "") is non-NULL */
1133 if (!strstr("ide-disk", drive->driver_req))
1135 if (!drive->present)
1137 if (drive->media != ide_disk)
1140 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1144 g = alloc_disk_node(1 << PARTN_BITS,
1145 hwif_to_node(drive->hwif));
1149 ide_init_disk(g, drive);
1151 ide_proc_register_driver(drive, &idedisk_driver);
1153 kref_init(&idkp->kref);
1155 idkp->drive = drive;
1156 idkp->driver = &idedisk_driver;
1159 g->private_data = &idkp->driver;
1161 drive->driver_data = idkp;
1163 idedisk_setup(drive);
1164 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1165 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1166 drive->name, drive->head);
1171 g->minors = 1 << PARTN_BITS;
1172 g->driverfs_dev = &drive->gendev;
1173 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1174 set_capacity(g, idedisk_capacity(drive));
1175 g->fops = &idedisk_ops;
1185 static void __exit idedisk_exit (void)
1187 driver_unregister(&idedisk_driver.gen_driver);
1190 static int __init idedisk_init(void)
1192 return driver_register(&idedisk_driver.gen_driver);
1195 MODULE_ALIAS("ide:*m-disk*");
1196 module_init(idedisk_init);
1197 module_exit(idedisk_exit);
1198 MODULE_LICENSE("GPL");