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 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
141 u8 command = WIN_NOP;
142 ata_nsector_t nsectors;
144 struct ide_taskfile *tf = &task.tf;
146 nsectors.all = (u16) rq->nr_sectors;
148 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
149 if (block + rq->nr_sectors > 1ULL << 28)
156 ide_init_sg_cmd(drive, rq);
157 ide_map_sg(drive, rq);
160 memset(&task, 0, sizeof(task));
161 task.tf_flags = IDE_TFLAG_NO_SELECT_MASK; /* FIXME? */
162 task.tf_flags |= (IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE);
164 if (drive->select.b.lba) {
166 pr_debug("%s: LBA=0x%012llx\n", drive->name,
167 (unsigned long long)block);
169 tf->hob_nsect = nsectors.b.high;
170 tf->hob_lbal = (u8)(block >> 24);
171 if (sizeof(block) != 4) {
172 tf->hob_lbam = (u8)((u64)block >> 32);
173 tf->hob_lbah = (u8)((u64)block >> 40);
176 tf->nsect = nsectors.b.low;
177 tf->lbal = (u8) block;
178 tf->lbam = (u8)(block >> 8);
179 tf->lbah = (u8)(block >> 16);
181 printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
182 drive->name, tf->hob_nsect, tf->nsect,
183 tf->hob_lbah, tf->hob_lbam, tf->hob_lbal,
184 tf->lbah, tf->lbam, tf->lbal);
186 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
188 tf->nsect = nsectors.b.low;
190 tf->lbam = block >>= 8;
191 tf->lbah = block >>= 8;
192 tf->device = (block >> 8) & 0xf;
195 unsigned int sect,head,cyl,track;
196 track = (int)block / drive->sect;
197 sect = (int)block % drive->sect + 1;
198 head = track % drive->head;
199 cyl = track / drive->head;
201 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
203 tf->nsect = nsectors.b.low;
210 ide_tf_load(drive, &task);
213 if (!hwif->dma_setup(drive)) {
214 if (rq_data_dir(rq)) {
215 command = lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
217 command = lba48 ? WIN_WRITE_EXT: WIN_WRITE;
219 command = lba48 ? WIN_READDMA_EXT : WIN_READDMA;
221 command = lba48 ? WIN_READ_EXT: WIN_READ;
223 hwif->dma_exec_cmd(drive, command);
224 hwif->dma_start(drive);
227 /* fallback to PIO */
228 ide_init_sg_cmd(drive, rq);
231 if (rq_data_dir(rq) == READ) {
233 if (drive->mult_count) {
234 hwif->data_phase = TASKFILE_MULTI_IN;
235 command = lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
237 hwif->data_phase = TASKFILE_IN;
238 command = lba48 ? WIN_READ_EXT : WIN_READ;
241 ide_execute_command(drive, command, &task_in_intr, WAIT_CMD, NULL);
244 if (drive->mult_count) {
245 hwif->data_phase = TASKFILE_MULTI_OUT;
246 command = lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
248 hwif->data_phase = TASKFILE_OUT;
249 command = lba48 ? WIN_WRITE_EXT : WIN_WRITE;
252 /* FIXME: ->OUTBSYNC ? */
253 hwif->OUTB(command, IDE_COMMAND_REG);
255 return pre_task_out_intr(drive, rq);
260 * 268435455 == 137439 MB or 28bit limit
261 * 320173056 == 163929 MB or 48bit addressing
262 * 1073741822 == 549756 MB or 48bit addressing fake drive
265 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
267 ide_hwif_t *hwif = HWIF(drive);
269 BUG_ON(drive->blocked);
271 if (!blk_fs_request(rq)) {
272 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
273 ide_end_request(drive, 0, 0);
277 ledtrig_ide_activity();
279 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
280 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
281 (unsigned long long)block, rq->nr_sectors,
282 (unsigned long)rq->buffer);
285 hwif->rw_disk(drive, rq);
287 return __ide_do_rw_disk(drive, rq, block);
291 * Queries for true maximum capacity of the drive.
292 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
294 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
297 struct ide_taskfile *tf = &args.tf;
300 /* Create IDE/ATA command request structure */
301 memset(&args, 0, sizeof(ide_task_t));
303 tf->command = WIN_READ_NATIVE_MAX_EXT;
305 tf->command = WIN_READ_NATIVE_MAX;
306 tf->device = ATA_LBA;
307 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
309 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
310 /* submit command request */
311 ide_no_data_taskfile(drive, &args);
313 /* if OK, compute maximum address value */
314 if ((tf->status & 0x01) == 0) {
318 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
321 high = tf->device & 0xf;
322 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
323 addr = ((__u64)high << 24) | low;
324 addr++; /* since the return value is (maxlba - 1), we add 1 */
330 * Sets maximum virtual LBA address of the drive.
331 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
333 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
336 struct ide_taskfile *tf = &args.tf;
340 /* Create IDE/ATA command request structure */
341 memset(&args, 0, sizeof(ide_task_t));
342 tf->lbal = (addr_req >> 0) & 0xff;
343 tf->lbam = (addr_req >>= 8) & 0xff;
344 tf->lbah = (addr_req >>= 8) & 0xff;
346 tf->hob_lbal = (addr_req >>= 8) & 0xff;
347 tf->hob_lbam = (addr_req >>= 8) & 0xff;
348 tf->hob_lbah = (addr_req >>= 8) & 0xff;
349 tf->command = WIN_SET_MAX_EXT;
351 tf->device = (addr_req >>= 8) & 0x0f;
352 tf->command = WIN_SET_MAX;
354 tf->device |= ATA_LBA;
355 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
357 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_OUT_HOB);
358 /* submit command request */
359 ide_no_data_taskfile(drive, &args);
360 /* if OK, compute maximum address value */
361 if ((tf->status & 0x01) == 0) {
365 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
368 high = tf->device & 0xf;
369 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
370 addr_set = ((__u64)high << 24) | low;
376 static unsigned long long sectors_to_MB(unsigned long long n)
378 n <<= 9; /* make it bytes */
379 do_div(n, 1000000); /* make it MB */
384 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
385 * so on non-buggy drives we need test only one.
386 * However, we should also check whether these fields are valid.
388 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
390 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
396 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
398 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
399 && id->lba_capacity_2;
403 * Some disks report total number of sectors instead of
404 * maximum sector address. We list them here.
406 static const struct drive_list_entry hpa_list[] = {
407 { "ST340823A", NULL },
408 { "ST320413A", NULL },
412 static void idedisk_check_hpa(ide_drive_t *drive)
414 unsigned long long capacity, set_max;
415 int lba48 = idedisk_supports_lba48(drive->id);
417 capacity = drive->capacity64;
419 set_max = idedisk_read_native_max_address(drive, lba48);
421 if (ide_in_drive_list(drive->id, hpa_list)) {
423 * Since we are inclusive wrt to firmware revisions do this
424 * extra check and apply the workaround only when needed.
426 if (set_max == capacity + 1)
430 if (set_max <= capacity)
433 printk(KERN_INFO "%s: Host Protected Area detected.\n"
434 "\tcurrent capacity is %llu sectors (%llu MB)\n"
435 "\tnative capacity is %llu sectors (%llu MB)\n",
437 capacity, sectors_to_MB(capacity),
438 set_max, sectors_to_MB(set_max));
440 set_max = idedisk_set_max_address(drive, set_max, lba48);
443 drive->capacity64 = set_max;
444 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
450 * Compute drive->capacity, the full capacity of the drive
451 * Called with drive->id != NULL.
453 * To compute capacity, this uses either of
455 * 1. CHS value set by user (whatever user sets will be trusted)
456 * 2. LBA value from target drive (require new ATA feature)
457 * 3. LBA value from system BIOS (new one is OK, old one may break)
458 * 4. CHS value from system BIOS (traditional style)
460 * in above order (i.e., if value of higher priority is available,
461 * reset will be ignored).
463 static void init_idedisk_capacity (ide_drive_t *drive)
465 struct hd_driveid *id = drive->id;
467 * If this drive supports the Host Protected Area feature set,
468 * then we may need to change our opinion about the drive's capacity.
470 int hpa = idedisk_supports_hpa(id);
472 if (idedisk_supports_lba48(id)) {
473 /* drive speaks 48-bit LBA */
474 drive->select.b.lba = 1;
475 drive->capacity64 = id->lba_capacity_2;
477 idedisk_check_hpa(drive);
478 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
479 /* drive speaks 28-bit LBA */
480 drive->select.b.lba = 1;
481 drive->capacity64 = id->lba_capacity;
483 idedisk_check_hpa(drive);
485 /* drive speaks boring old 28-bit CHS */
486 drive->capacity64 = drive->cyl * drive->head * drive->sect;
490 static sector_t idedisk_capacity (ide_drive_t *drive)
492 return drive->capacity64 - drive->sect0;
495 #ifdef CONFIG_IDE_PROC_FS
496 static int smart_enable(ide_drive_t *drive)
499 struct ide_taskfile *tf = &args.tf;
501 memset(&args, 0, sizeof(ide_task_t));
502 tf->feature = SMART_ENABLE;
503 tf->lbam = SMART_LCYL_PASS;
504 tf->lbah = SMART_HCYL_PASS;
505 tf->command = WIN_SMART;
506 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
507 return ide_no_data_taskfile(drive, &args);
510 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
513 struct ide_taskfile *tf = &args.tf;
515 memset(&args, 0, sizeof(ide_task_t));
516 tf->feature = sub_cmd;
518 tf->lbam = SMART_LCYL_PASS;
519 tf->lbah = SMART_HCYL_PASS;
520 tf->command = WIN_SMART;
521 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
522 args.command_type = IDE_DRIVE_TASK_IN;
523 args.data_phase = TASKFILE_IN;
524 args.handler = &task_in_intr;
525 (void) smart_enable(drive);
526 return ide_raw_taskfile(drive, &args, buf);
529 static int proc_idedisk_read_cache
530 (char *page, char **start, off_t off, int count, int *eof, void *data)
532 ide_drive_t *drive = (ide_drive_t *) data;
537 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
539 len = sprintf(out,"(none)\n");
540 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
543 static int proc_idedisk_read_capacity
544 (char *page, char **start, off_t off, int count, int *eof, void *data)
546 ide_drive_t*drive = (ide_drive_t *)data;
549 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
550 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
553 static int proc_idedisk_read_smart_thresholds
554 (char *page, char **start, off_t off, int count, int *eof, void *data)
556 ide_drive_t *drive = (ide_drive_t *)data;
559 if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
560 unsigned short *val = (unsigned short *) page;
561 char *out = ((char *)val) + (SECTOR_WORDS * 4);
564 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
566 } while (i < (SECTOR_WORDS * 2));
569 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
572 static int proc_idedisk_read_smart_values
573 (char *page, char **start, off_t off, int count, int *eof, void *data)
575 ide_drive_t *drive = (ide_drive_t *)data;
578 if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
579 unsigned short *val = (unsigned short *) page;
580 char *out = ((char *)val) + (SECTOR_WORDS * 4);
583 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
585 } while (i < (SECTOR_WORDS * 2));
588 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
591 static ide_proc_entry_t idedisk_proc[] = {
592 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
593 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
594 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
595 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
596 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
597 { NULL, 0, NULL, NULL }
599 #endif /* CONFIG_IDE_PROC_FS */
601 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
603 ide_drive_t *drive = q->queuedata;
606 memset(&task, 0, sizeof(task));
607 if (ide_id_has_flush_cache_ext(drive->id) &&
608 (drive->capacity64 >= (1UL << 28)))
609 task.tf.command = WIN_FLUSH_CACHE_EXT;
611 task.tf.command = WIN_FLUSH_CACHE;
612 task.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
613 task.command_type = IDE_DRIVE_TASK_NO_DATA;
614 task.handler = task_no_data_intr;
616 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
617 rq->cmd_flags |= REQ_SOFTBARRIER;
622 * This is tightly woven into the driver->do_special can not touch.
623 * DON'T do it again until a total personality rewrite is committed.
625 static int set_multcount(ide_drive_t *drive, int arg)
629 if (arg < 0 || arg > drive->id->max_multsect)
632 if (drive->special.b.set_multmode)
634 ide_init_drive_cmd (&rq);
635 rq.cmd_type = REQ_TYPE_ATA_CMD;
636 drive->mult_req = arg;
637 drive->special.b.set_multmode = 1;
638 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
639 return (drive->mult_count == arg) ? 0 : -EIO;
642 static int set_nowerr(ide_drive_t *drive, int arg)
644 if (arg < 0 || arg > 1)
647 if (ide_spin_wait_hwgroup(drive))
650 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
651 spin_unlock_irq(&ide_lock);
655 static void update_ordered(ide_drive_t *drive)
657 struct hd_driveid *id = drive->id;
658 unsigned ordered = QUEUE_ORDERED_NONE;
659 prepare_flush_fn *prep_fn = NULL;
662 unsigned long long capacity;
665 * We must avoid issuing commands a drive does not
666 * understand or we may crash it. We check flush cache
667 * is supported. We also check we have the LBA48 flush
668 * cache if the drive capacity is too large. By this
669 * time we have trimmed the drive capacity if LBA48 is
670 * not available so we don't need to recheck that.
672 capacity = idedisk_capacity(drive);
673 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
674 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
675 ide_id_has_flush_cache_ext(id));
677 printk(KERN_INFO "%s: cache flushes %ssupported\n",
678 drive->name, barrier ? "" : "not ");
681 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
682 prep_fn = idedisk_prepare_flush;
685 ordered = QUEUE_ORDERED_DRAIN;
687 blk_queue_ordered(drive->queue, ordered, prep_fn);
690 static int write_cache(ide_drive_t *drive, int arg)
695 if (arg < 0 || arg > 1)
698 if (ide_id_has_flush_cache(drive->id)) {
699 memset(&args, 0, sizeof(ide_task_t));
700 args.tf.feature = arg ?
701 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
702 args.tf.command = WIN_SETFEATURES;
703 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
704 err = ide_no_data_taskfile(drive, &args);
709 update_ordered(drive);
714 static int do_idedisk_flushcache (ide_drive_t *drive)
718 memset(&args, 0, sizeof(ide_task_t));
719 if (ide_id_has_flush_cache_ext(drive->id))
720 args.tf.command = WIN_FLUSH_CACHE_EXT;
722 args.tf.command = WIN_FLUSH_CACHE;
723 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
724 return ide_no_data_taskfile(drive, &args);
727 static int set_acoustic (ide_drive_t *drive, int arg)
731 if (arg < 0 || arg > 254)
734 memset(&args, 0, sizeof(ide_task_t));
735 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
737 args.tf.command = WIN_SETFEATURES;
738 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
739 ide_no_data_taskfile(drive, &args);
740 drive->acoustic = arg;
748 * 2: 48-bit capable doing 28-bit
750 static int set_lba_addressing(ide_drive_t *drive, int arg)
752 if (arg < 0 || arg > 2)
755 drive->addressing = 0;
757 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
760 if (!idedisk_supports_lba48(drive->id))
762 drive->addressing = arg;
766 #ifdef CONFIG_IDE_PROC_FS
767 static void idedisk_add_settings(ide_drive_t *drive)
769 struct hd_driveid *id = drive->id;
771 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
772 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
773 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
774 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
775 ide_add_setting(drive, "bswap", SETTING_READ, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
776 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount);
777 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
778 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
779 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
780 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
781 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
782 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
785 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
788 static void idedisk_setup (ide_drive_t *drive)
790 ide_hwif_t *hwif = drive->hwif;
791 struct hd_driveid *id = drive->id;
792 unsigned long long capacity;
794 idedisk_add_settings(drive);
796 if (drive->id_read == 0)
799 if (drive->removable) {
801 * Removable disks (eg. SYQUEST); ignore 'WD' drives
803 if (id->model[0] != 'W' || id->model[1] != 'D') {
804 drive->doorlocking = 1;
808 (void)set_lba_addressing(drive, 1);
810 if (drive->addressing == 1) {
813 if (max_s > hwif->rqsize)
814 max_s = hwif->rqsize;
816 blk_queue_max_sectors(drive->queue, max_s);
819 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
821 /* calculate drive capacity, and select LBA if possible */
822 init_idedisk_capacity (drive);
824 /* limit drive capacity to 137GB if LBA48 cannot be used */
825 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
826 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
827 "%llu sectors (%llu MB)\n",
828 drive->name, (unsigned long long)drive->capacity64,
829 sectors_to_MB(drive->capacity64));
830 drive->capacity64 = 1ULL << 28;
833 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
834 if (drive->capacity64 > 1ULL << 28) {
835 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
836 " be used for accessing sectors > %u\n",
837 drive->name, 1 << 28);
839 drive->addressing = 0;
843 * if possible, give fdisk access to more of the drive,
844 * by correcting bios_cyls:
846 capacity = idedisk_capacity (drive);
847 if (!drive->forced_geom) {
849 if (idedisk_supports_lba48(drive->id)) {
851 drive->bios_sect = 63;
852 drive->bios_head = 255;
855 if (drive->bios_sect && drive->bios_head) {
856 unsigned int cap0 = capacity; /* truncate to 32 bits */
857 unsigned int cylsz, cyl;
859 if (cap0 != capacity)
860 drive->bios_cyl = 65535;
862 cylsz = drive->bios_sect * drive->bios_head;
866 if (cyl > drive->bios_cyl)
867 drive->bios_cyl = cyl;
871 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
872 drive->name, capacity, sectors_to_MB(capacity));
874 /* Only print cache size when it was specified */
876 printk (" w/%dKiB Cache", id->buf_size/2);
878 printk(KERN_CONT ", CHS=%d/%d/%d\n",
879 drive->bios_cyl, drive->bios_head, drive->bios_sect);
881 /* write cache enabled? */
882 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
885 write_cache(drive, 1);
888 static void ide_cacheflush_p(ide_drive_t *drive)
890 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
893 if (do_idedisk_flushcache(drive))
894 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
897 static void ide_disk_remove(ide_drive_t *drive)
899 struct ide_disk_obj *idkp = drive->driver_data;
900 struct gendisk *g = idkp->disk;
902 ide_proc_unregister_driver(drive, idkp->driver);
906 ide_cacheflush_p(drive);
911 static void ide_disk_release(struct kref *kref)
913 struct ide_disk_obj *idkp = to_ide_disk(kref);
914 ide_drive_t *drive = idkp->drive;
915 struct gendisk *g = idkp->disk;
917 drive->driver_data = NULL;
918 g->private_data = NULL;
923 static int ide_disk_probe(ide_drive_t *drive);
926 * On HPA drives the capacity needs to be
927 * reinitilized on resume otherwise the disk
928 * can not be used and a hard reset is required
930 static void ide_disk_resume(ide_drive_t *drive)
932 if (idedisk_supports_hpa(drive->id))
933 init_idedisk_capacity(drive);
936 static void ide_device_shutdown(ide_drive_t *drive)
939 /* On Alpha, halt(8) doesn't actually turn the machine off,
940 it puts you into the sort of firmware monitor. Typically,
941 it's used to boot another kernel image, so it's not much
942 different from reboot(8). Therefore, we don't need to
943 spin down the disk in this case, especially since Alpha
944 firmware doesn't handle disks in standby mode properly.
945 On the other hand, it's reasonably safe to turn the power
946 off when the shutdown process reaches the firmware prompt,
947 as the firmware initialization takes rather long time -
948 at least 10 seconds, which should be sufficient for
949 the disk to expire its write cache. */
950 if (system_state != SYSTEM_POWER_OFF) {
952 if (system_state == SYSTEM_RESTART) {
954 ide_cacheflush_p(drive);
958 printk("Shutdown: %s\n", drive->name);
959 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
962 static ide_driver_t idedisk_driver = {
964 .owner = THIS_MODULE,
966 .bus = &ide_bus_type,
968 .probe = ide_disk_probe,
969 .remove = ide_disk_remove,
970 .resume = ide_disk_resume,
971 .shutdown = ide_device_shutdown,
972 .version = IDEDISK_VERSION,
974 .supports_dsc_overlap = 0,
975 .do_request = ide_do_rw_disk,
976 .end_request = ide_end_request,
977 .error = __ide_error,
978 .abort = __ide_abort,
979 #ifdef CONFIG_IDE_PROC_FS
980 .proc = idedisk_proc,
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) {
999 memset(&args, 0, sizeof(ide_task_t));
1000 args.tf.command = WIN_DOORLOCK;
1001 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
1002 check_disk_change(inode->i_bdev);
1004 * Ignore the return code from door_lock,
1005 * since the open() has already succeeded,
1006 * and the door_lock is irrelevant at this point.
1008 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
1009 drive->doorlocking = 0;
1014 static int idedisk_release(struct inode *inode, struct file *filp)
1016 struct gendisk *disk = inode->i_bdev->bd_disk;
1017 struct ide_disk_obj *idkp = ide_disk_g(disk);
1018 ide_drive_t *drive = idkp->drive;
1020 if (idkp->openers == 1)
1021 ide_cacheflush_p(drive);
1023 if (drive->removable && idkp->openers == 1) {
1025 memset(&args, 0, sizeof(ide_task_t));
1026 args.tf.command = WIN_DOORUNLOCK;
1027 args.tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE;
1028 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
1029 drive->doorlocking = 0;
1039 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1041 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1042 ide_drive_t *drive = idkp->drive;
1044 geo->heads = drive->bios_head;
1045 geo->sectors = drive->bios_sect;
1046 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1050 static int idedisk_ioctl(struct inode *inode, struct file *file,
1051 unsigned int cmd, unsigned long arg)
1053 unsigned long flags;
1054 struct block_device *bdev = inode->i_bdev;
1055 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1056 ide_drive_t *drive = idkp->drive;
1057 int err, (*setfunc)(ide_drive_t *, int);
1061 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1062 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1063 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1064 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1065 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1066 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1067 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1068 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1069 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1070 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1073 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1076 mutex_lock(&ide_setting_mtx);
1077 spin_lock_irqsave(&ide_lock, flags);
1079 spin_unlock_irqrestore(&ide_lock, flags);
1080 mutex_unlock(&ide_setting_mtx);
1081 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1084 if (bdev != bdev->bd_contains)
1087 if (!capable(CAP_SYS_ADMIN))
1090 mutex_lock(&ide_setting_mtx);
1091 err = setfunc(drive, arg);
1092 mutex_unlock(&ide_setting_mtx);
1098 static int idedisk_media_changed(struct gendisk *disk)
1100 struct ide_disk_obj *idkp = ide_disk_g(disk);
1101 ide_drive_t *drive = idkp->drive;
1103 /* do not scan partitions twice if this is a removable device */
1104 if (drive->attach) {
1108 /* if removable, always assume it was changed */
1109 return drive->removable;
1112 static int idedisk_revalidate_disk(struct gendisk *disk)
1114 struct ide_disk_obj *idkp = ide_disk_g(disk);
1115 set_capacity(disk, idedisk_capacity(idkp->drive));
1119 static struct block_device_operations idedisk_ops = {
1120 .owner = THIS_MODULE,
1121 .open = idedisk_open,
1122 .release = idedisk_release,
1123 .ioctl = idedisk_ioctl,
1124 .getgeo = idedisk_getgeo,
1125 .media_changed = idedisk_media_changed,
1126 .revalidate_disk= idedisk_revalidate_disk
1129 MODULE_DESCRIPTION("ATA DISK Driver");
1131 static int ide_disk_probe(ide_drive_t *drive)
1133 struct ide_disk_obj *idkp;
1136 /* strstr("foo", "") is non-NULL */
1137 if (!strstr("ide-disk", drive->driver_req))
1139 if (!drive->present)
1141 if (drive->media != ide_disk)
1144 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1148 g = alloc_disk_node(1 << PARTN_BITS,
1149 hwif_to_node(drive->hwif));
1153 ide_init_disk(g, drive);
1155 ide_proc_register_driver(drive, &idedisk_driver);
1157 kref_init(&idkp->kref);
1159 idkp->drive = drive;
1160 idkp->driver = &idedisk_driver;
1163 g->private_data = &idkp->driver;
1165 drive->driver_data = idkp;
1167 idedisk_setup(drive);
1168 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1169 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1170 drive->name, drive->head);
1175 g->minors = 1 << PARTN_BITS;
1176 g->driverfs_dev = &drive->gendev;
1177 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1178 set_capacity(g, idedisk_capacity(drive));
1179 g->fops = &idedisk_ops;
1189 static void __exit idedisk_exit (void)
1191 driver_unregister(&idedisk_driver.gen_driver);
1194 static int __init idedisk_init(void)
1196 return driver_register(&idedisk_driver.gen_driver);
1199 MODULE_ALIAS("ide:*m-disk*");
1200 module_init(idedisk_init);
1201 module_exit(idedisk_exit);
1202 MODULE_LICENSE("GPL");