2 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below)
3 * Copyright (C) 1998-2002 Linux ATA Development
4 * Andre Hedrick <andre@linux-ide.org>
5 * Copyright (C) 2003 Red Hat <alan@redhat.com>
6 * Copyright (C) 2003-2005, 2007 Bartlomiej Zolnierkiewicz
10 * Mostly written by Mark Lord <mlord@pobox.com>
11 * and Gadi Oxman <gadio@netvision.net.il>
12 * and Andre Hedrick <andre@linux-ide.org>
14 * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
17 #define IDEDISK_VERSION "1.18"
19 #include <linux/module.h>
20 #include <linux/types.h>
21 #include <linux/string.h>
22 #include <linux/kernel.h>
23 #include <linux/timer.h>
25 #include <linux/interrupt.h>
26 #include <linux/major.h>
27 #include <linux/errno.h>
28 #include <linux/genhd.h>
29 #include <linux/slab.h>
30 #include <linux/delay.h>
31 #include <linux/mutex.h>
32 #include <linux/leds.h>
36 #include <linux/ide.h>
38 #include <asm/byteorder.h>
40 #include <asm/uaccess.h>
42 #include <asm/div64.h>
44 #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
45 #define IDE_DISK_MINORS (1 << PARTN_BITS)
47 #define IDE_DISK_MINORS 0
55 unsigned int openers; /* protected by BKL for now */
58 static DEFINE_MUTEX(idedisk_ref_mutex);
60 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
62 #define ide_disk_g(disk) \
63 container_of((disk)->private_data, struct ide_disk_obj, driver)
65 static void ide_disk_release(struct kref *);
67 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
69 struct ide_disk_obj *idkp = NULL;
71 mutex_lock(&idedisk_ref_mutex);
72 idkp = ide_disk_g(disk);
74 if (ide_device_get(idkp->drive))
77 kref_get(&idkp->kref);
79 mutex_unlock(&idedisk_ref_mutex);
83 static void ide_disk_put(struct ide_disk_obj *idkp)
85 ide_drive_t *drive = idkp->drive;
87 mutex_lock(&idedisk_ref_mutex);
88 kref_put(&idkp->kref, ide_disk_release);
89 ide_device_put(drive);
90 mutex_unlock(&idedisk_ref_mutex);
94 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
95 * value for this drive (from its reported identification information).
97 * Returns: 1 if lba_capacity looks sensible
100 * It is called only once for each drive.
102 static int lba_capacity_is_ok(u16 *id)
104 unsigned long lba_sects, chs_sects, head, tail;
106 /* No non-LBA info .. so valid! */
107 if (id[ATA_ID_CYLS] == 0)
110 lba_sects = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
113 * The ATA spec tells large drives to return
114 * C/H/S = 16383/16/63 independent of their size.
115 * Some drives can be jumpered to use 15 heads instead of 16.
116 * Some drives can be jumpered to use 4092 cyls instead of 16383.
118 if ((id[ATA_ID_CYLS] == 16383 ||
119 (id[ATA_ID_CYLS] == 4092 && id[ATA_ID_CUR_CYLS] == 16383)) &&
120 id[ATA_ID_SECTORS] == 63 &&
121 (id[ATA_ID_HEADS] == 15 || id[ATA_ID_HEADS] == 16) &&
122 (lba_sects >= 16383 * 63 * id[ATA_ID_HEADS]))
125 chs_sects = id[ATA_ID_CYLS] * id[ATA_ID_HEADS] * id[ATA_ID_SECTORS];
127 /* perform a rough sanity check on lba_sects: within 10% is OK */
128 if ((lba_sects - chs_sects) < chs_sects/10)
131 /* some drives have the word order reversed */
132 head = ((lba_sects >> 16) & 0xffff);
133 tail = (lba_sects & 0xffff);
134 lba_sects = (head | (tail << 16));
135 if ((lba_sects - chs_sects) < chs_sects/10) {
136 *(__le32 *)&id[ATA_ID_LBA_CAPACITY] = __cpu_to_le32(lba_sects);
137 return 1; /* lba_capacity is (now) good */
140 return 0; /* lba_capacity value may be bad */
143 static const u8 ide_rw_cmds[] = {
158 static const u8 ide_data_phases[] = {
167 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
169 u8 index, lba48, write;
171 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
172 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
177 index = drive->mult_count ? 0 : 4;
179 task->tf.command = ide_rw_cmds[index + lba48 + write];
182 index = 8; /* fixup index */
184 task->data_phase = ide_data_phases[index / 2 + write];
188 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
189 * using LBA if supported, or CHS otherwise, to address sectors.
191 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
194 ide_hwif_t *hwif = HWIF(drive);
195 unsigned int dma = drive->using_dma;
196 u16 nsectors = (u16)rq->nr_sectors;
197 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
199 struct ide_taskfile *tf = &task.tf;
202 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
203 if (block + rq->nr_sectors > 1ULL << 28)
210 ide_init_sg_cmd(drive, rq);
211 ide_map_sg(drive, rq);
214 memset(&task, 0, sizeof(task));
215 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
217 if (drive->select.b.lba) {
219 pr_debug("%s: LBA=0x%012llx\n", drive->name,
220 (unsigned long long)block);
222 tf->hob_nsect = (nsectors >> 8) & 0xff;
223 tf->hob_lbal = (u8)(block >> 24);
224 if (sizeof(block) != 4) {
225 tf->hob_lbam = (u8)((u64)block >> 32);
226 tf->hob_lbah = (u8)((u64)block >> 40);
229 tf->nsect = nsectors & 0xff;
230 tf->lbal = (u8) block;
231 tf->lbam = (u8)(block >> 8);
232 tf->lbah = (u8)(block >> 16);
234 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
236 tf->nsect = nsectors & 0xff;
238 tf->lbam = block >>= 8;
239 tf->lbah = block >>= 8;
240 tf->device = (block >> 8) & 0xf;
243 unsigned int sect, head, cyl, track;
245 track = (int)block / drive->sect;
246 sect = (int)block % drive->sect + 1;
247 head = track % drive->head;
248 cyl = track / drive->head;
250 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
252 tf->nsect = nsectors & 0xff;
260 task.tf_flags |= IDE_TFLAG_WRITE;
262 ide_tf_set_cmd(drive, &task, dma);
264 hwif->data_phase = task.data_phase;
267 rc = do_rw_taskfile(drive, &task);
269 if (rc == ide_stopped && dma) {
270 /* fallback to PIO */
271 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
272 ide_tf_set_cmd(drive, &task, 0);
273 hwif->data_phase = task.data_phase;
274 ide_init_sg_cmd(drive, rq);
275 rc = do_rw_taskfile(drive, &task);
282 * 268435455 == 137439 MB or 28bit limit
283 * 320173056 == 163929 MB or 48bit addressing
284 * 1073741822 == 549756 MB or 48bit addressing fake drive
287 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
290 ide_hwif_t *hwif = HWIF(drive);
292 BUG_ON(drive->blocked);
294 if (!blk_fs_request(rq)) {
295 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
296 ide_end_request(drive, 0, 0);
300 ledtrig_ide_activity();
302 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
303 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
304 (unsigned long long)block, rq->nr_sectors,
305 (unsigned long)rq->buffer);
308 hwif->rw_disk(drive, rq);
310 return __ide_do_rw_disk(drive, rq, block);
314 * Queries for true maximum capacity of the drive.
315 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
317 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
320 struct ide_taskfile *tf = &args.tf;
323 /* Create IDE/ATA command request structure */
324 memset(&args, 0, sizeof(ide_task_t));
326 tf->command = WIN_READ_NATIVE_MAX_EXT;
328 tf->command = WIN_READ_NATIVE_MAX;
329 tf->device = ATA_LBA;
330 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
332 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
333 /* submit command request */
334 ide_no_data_taskfile(drive, &args);
336 /* if OK, compute maximum address value */
337 if ((tf->status & 0x01) == 0)
338 addr = ide_get_lba_addr(tf, lba48) + 1;
344 * Sets maximum virtual LBA address of the drive.
345 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
347 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
350 struct ide_taskfile *tf = &args.tf;
354 /* Create IDE/ATA command request structure */
355 memset(&args, 0, sizeof(ide_task_t));
356 tf->lbal = (addr_req >> 0) & 0xff;
357 tf->lbam = (addr_req >>= 8) & 0xff;
358 tf->lbah = (addr_req >>= 8) & 0xff;
360 tf->hob_lbal = (addr_req >>= 8) & 0xff;
361 tf->hob_lbam = (addr_req >>= 8) & 0xff;
362 tf->hob_lbah = (addr_req >>= 8) & 0xff;
363 tf->command = WIN_SET_MAX_EXT;
365 tf->device = (addr_req >>= 8) & 0x0f;
366 tf->command = WIN_SET_MAX;
368 tf->device |= ATA_LBA;
369 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
371 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
372 /* submit command request */
373 ide_no_data_taskfile(drive, &args);
374 /* if OK, compute maximum address value */
375 if ((tf->status & 0x01) == 0)
376 addr_set = ide_get_lba_addr(tf, lba48) + 1;
381 static unsigned long long sectors_to_MB(unsigned long long n)
383 n <<= 9; /* make it bytes */
384 do_div(n, 1000000); /* make it MB */
389 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
390 * so on non-buggy drives we need test only one.
391 * However, we should also check whether these fields are valid.
393 static inline int idedisk_supports_hpa(const u16 *id)
395 return (id[ATA_ID_COMMAND_SET_1] & 0x0400) &&
396 (id[ATA_ID_CFS_ENABLE_1] & 0x0400);
402 static inline int idedisk_supports_lba48(const u16 *id)
404 return (id[ATA_ID_COMMAND_SET_2] & 0x0400) &&
405 (id[ATA_ID_CFS_ENABLE_2] & 0x0400) &&
406 ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
410 * Some disks report total number of sectors instead of
411 * maximum sector address. We list them here.
413 static const struct drive_list_entry hpa_list[] = {
414 { "ST340823A", NULL },
415 { "ST320413A", NULL },
416 { "ST310211A", NULL },
420 static void idedisk_check_hpa(ide_drive_t *drive)
422 unsigned long long capacity, set_max;
423 int lba48 = idedisk_supports_lba48(drive->id);
425 capacity = drive->capacity64;
427 set_max = idedisk_read_native_max_address(drive, lba48);
429 if (ide_in_drive_list(drive->id, hpa_list)) {
431 * Since we are inclusive wrt to firmware revisions do this
432 * extra check and apply the workaround only when needed.
434 if (set_max == capacity + 1)
438 if (set_max <= capacity)
441 printk(KERN_INFO "%s: Host Protected Area detected.\n"
442 "\tcurrent capacity is %llu sectors (%llu MB)\n"
443 "\tnative capacity is %llu sectors (%llu MB)\n",
445 capacity, sectors_to_MB(capacity),
446 set_max, sectors_to_MB(set_max));
448 set_max = idedisk_set_max_address(drive, set_max, lba48);
451 drive->capacity64 = set_max;
452 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
457 static void init_idedisk_capacity(ide_drive_t *drive)
461 * If this drive supports the Host Protected Area feature set,
462 * then we may need to change our opinion about the drive's capacity.
464 int hpa = idedisk_supports_hpa(id);
466 if (idedisk_supports_lba48(id)) {
467 /* drive speaks 48-bit LBA */
468 drive->select.b.lba = 1;
469 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
471 idedisk_check_hpa(drive);
472 } else if (ata_id_has_lba(id) && lba_capacity_is_ok(id)) {
473 /* drive speaks 28-bit LBA */
474 drive->select.b.lba = 1;
475 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
477 idedisk_check_hpa(drive);
479 /* drive speaks boring old 28-bit CHS */
480 drive->capacity64 = drive->cyl * drive->head * drive->sect;
484 static sector_t idedisk_capacity(ide_drive_t *drive)
486 return drive->capacity64 - drive->sect0;
489 #ifdef CONFIG_IDE_PROC_FS
490 static int smart_enable(ide_drive_t *drive)
493 struct ide_taskfile *tf = &args.tf;
495 memset(&args, 0, sizeof(ide_task_t));
496 tf->feature = SMART_ENABLE;
497 tf->lbam = SMART_LCYL_PASS;
498 tf->lbah = SMART_HCYL_PASS;
499 tf->command = WIN_SMART;
500 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
501 return ide_no_data_taskfile(drive, &args);
504 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
507 struct ide_taskfile *tf = &args.tf;
509 memset(&args, 0, sizeof(ide_task_t));
510 tf->feature = sub_cmd;
512 tf->lbam = SMART_LCYL_PASS;
513 tf->lbah = SMART_HCYL_PASS;
514 tf->command = WIN_SMART;
515 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
516 args.data_phase = TASKFILE_IN;
517 (void) smart_enable(drive);
518 return ide_raw_taskfile(drive, &args, buf, 1);
521 static int proc_idedisk_read_cache
522 (char *page, char **start, off_t off, int count, int *eof, void *data)
524 ide_drive_t *drive = (ide_drive_t *) data;
529 len = sprintf(out, "%i\n", drive->id[ATA_ID_BUF_SIZE] / 2);
531 len = sprintf(out, "(none)\n");
533 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
536 static int proc_idedisk_read_capacity
537 (char *page, char **start, off_t off, int count, int *eof, void *data)
539 ide_drive_t*drive = (ide_drive_t *)data;
542 len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
544 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
547 static int proc_idedisk_read_smart(char *page, char **start, off_t off,
548 int count, int *eof, void *data, u8 sub_cmd)
550 ide_drive_t *drive = (ide_drive_t *)data;
553 if (get_smart_data(drive, page, sub_cmd) == 0) {
554 unsigned short *val = (unsigned short *) page;
555 char *out = ((char *)val) + (SECTOR_WORDS * 4);
558 out += sprintf(out, "%04x%c", le16_to_cpu(*val),
559 (++i & 7) ? ' ' : '\n');
561 } while (i < (SECTOR_WORDS * 2));
565 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
568 static int proc_idedisk_read_sv
569 (char *page, char **start, off_t off, int count, int *eof, void *data)
571 return proc_idedisk_read_smart(page, start, off, count, eof, data,
575 static int proc_idedisk_read_st
576 (char *page, char **start, off_t off, int count, int *eof, void *data)
578 return proc_idedisk_read_smart(page, start, off, count, eof, data,
579 SMART_READ_THRESHOLDS);
582 static ide_proc_entry_t idedisk_proc[] = {
583 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
584 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
585 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
586 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv, NULL },
587 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st, NULL },
588 { NULL, 0, NULL, NULL }
590 #endif /* CONFIG_IDE_PROC_FS */
592 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
594 ide_drive_t *drive = q->queuedata;
595 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
597 /* FIXME: map struct ide_taskfile on rq->cmd[] */
598 BUG_ON(task == NULL);
600 memset(task, 0, sizeof(*task));
601 if (ide_id_has_flush_cache_ext(drive->id) &&
602 (drive->capacity64 >= (1UL << 28)))
603 task->tf.command = WIN_FLUSH_CACHE_EXT;
605 task->tf.command = WIN_FLUSH_CACHE;
606 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
608 task->data_phase = TASKFILE_NO_DATA;
610 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
611 rq->cmd_flags |= REQ_SOFTBARRIER;
616 * This is tightly woven into the driver->do_special can not touch.
617 * DON'T do it again until a total personality rewrite is committed.
619 static int set_multcount(ide_drive_t *drive, int arg)
624 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
627 if (drive->special.b.set_multmode)
630 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
631 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
633 drive->mult_req = arg;
634 drive->special.b.set_multmode = 1;
635 error = blk_execute_rq(drive->queue, NULL, rq, 0);
638 return (drive->mult_count == arg) ? 0 : -EIO;
641 static int set_nowerr(ide_drive_t *drive, int arg)
643 if (arg < 0 || arg > 1)
646 if (ide_spin_wait_hwgroup(drive))
649 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
650 spin_unlock_irq(&ide_lock);
654 static void update_ordered(ide_drive_t *drive)
657 unsigned ordered = QUEUE_ORDERED_NONE;
658 prepare_flush_fn *prep_fn = NULL;
661 unsigned long long capacity;
664 * We must avoid issuing commands a drive does not
665 * understand or we may crash it. We check flush cache
666 * is supported. We also check we have the LBA48 flush
667 * cache if the drive capacity is too large. By this
668 * time we have trimmed the drive capacity if LBA48 is
669 * not available so we don't need to recheck that.
671 capacity = idedisk_capacity(drive);
672 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
673 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
674 ide_id_has_flush_cache_ext(id));
676 printk(KERN_INFO "%s: cache flushes %ssupported\n",
677 drive->name, barrier ? "" : "not ");
680 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
681 prep_fn = idedisk_prepare_flush;
684 ordered = QUEUE_ORDERED_DRAIN;
686 blk_queue_ordered(drive->queue, ordered, prep_fn);
689 static int write_cache(ide_drive_t *drive, int arg)
694 if (arg < 0 || arg > 1)
697 if (ide_id_has_flush_cache(drive->id)) {
698 memset(&args, 0, sizeof(ide_task_t));
699 args.tf.feature = arg ?
700 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
701 args.tf.command = WIN_SETFEATURES;
702 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
703 err = ide_no_data_taskfile(drive, &args);
708 update_ordered(drive);
713 static int do_idedisk_flushcache(ide_drive_t *drive)
717 memset(&args, 0, sizeof(ide_task_t));
718 if (ide_id_has_flush_cache_ext(drive->id))
719 args.tf.command = WIN_FLUSH_CACHE_EXT;
721 args.tf.command = WIN_FLUSH_CACHE;
722 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
723 return ide_no_data_taskfile(drive, &args);
726 static int set_acoustic(ide_drive_t *drive, int arg)
730 if (arg < 0 || arg > 254)
733 memset(&args, 0, sizeof(ide_task_t));
734 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
736 args.tf.command = WIN_SETFEATURES;
737 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
738 ide_no_data_taskfile(drive, &args);
739 drive->acoustic = arg;
747 * 2: 48-bit capable doing 28-bit
749 static int set_lba_addressing(ide_drive_t *drive, int arg)
751 if (arg < 0 || arg > 2)
754 drive->addressing = 0;
756 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
759 if (!idedisk_supports_lba48(drive->id))
761 drive->addressing = arg;
765 #ifdef CONFIG_IDE_PROC_FS
766 static void idedisk_add_settings(ide_drive_t *drive)
768 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
769 &drive->bios_cyl, NULL);
770 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
771 &drive->bios_head, NULL);
772 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1,
773 &drive->bios_sect, NULL);
774 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1,
775 &drive->addressing, set_lba_addressing);
776 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0,
777 drive->id[ATA_ID_MAX_MULTSECT] & 0xff, 1, 1,
778 &drive->mult_count, set_multcount);
779 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
780 &drive->nowerr, set_nowerr);
781 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1,
783 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
784 &drive->wcache, write_cache);
785 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1,
786 &drive->acoustic, set_acoustic);
787 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
788 &drive->failures, NULL);
789 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535,
790 1, 1, &drive->max_failures, NULL);
793 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
796 static void idedisk_setup(ide_drive_t *drive)
798 ide_hwif_t *hwif = drive->hwif;
800 char *m = (char *)&id[ATA_ID_PROD];
801 unsigned long long capacity;
803 idedisk_add_settings(drive);
805 if (drive->id_read == 0)
808 if (drive->removable) {
810 * Removable disks (eg. SYQUEST); ignore 'WD' drives
812 if (m[0] != 'W' || m[1] != 'D')
813 drive->doorlocking = 1;
816 (void)set_lba_addressing(drive, 1);
818 if (drive->addressing == 1) {
821 if (max_s > hwif->rqsize)
822 max_s = hwif->rqsize;
824 blk_queue_max_sectors(drive->queue, max_s);
827 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
828 drive->queue->max_sectors / 2);
830 /* calculate drive capacity, and select LBA if possible */
831 init_idedisk_capacity(drive);
833 /* limit drive capacity to 137GB if LBA48 cannot be used */
834 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
835 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
836 "%llu sectors (%llu MB)\n",
837 drive->name, (unsigned long long)drive->capacity64,
838 sectors_to_MB(drive->capacity64));
839 drive->capacity64 = 1ULL << 28;
842 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
843 if (drive->capacity64 > 1ULL << 28) {
844 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
845 " will be used for accessing sectors "
846 "> %u\n", drive->name, 1 << 28);
848 drive->addressing = 0;
852 * if possible, give fdisk access to more of the drive,
853 * by correcting bios_cyls:
855 capacity = idedisk_capacity(drive);
857 if (!drive->forced_geom) {
859 if (idedisk_supports_lba48(drive->id)) {
861 drive->bios_sect = 63;
862 drive->bios_head = 255;
865 if (drive->bios_sect && drive->bios_head) {
866 unsigned int cap0 = capacity; /* truncate to 32 bits */
867 unsigned int cylsz, cyl;
869 if (cap0 != capacity)
870 drive->bios_cyl = 65535;
872 cylsz = drive->bios_sect * drive->bios_head;
876 if (cyl > drive->bios_cyl)
877 drive->bios_cyl = cyl;
881 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
882 drive->name, capacity, sectors_to_MB(capacity));
884 /* Only print cache size when it was specified */
885 if (id[ATA_ID_BUF_SIZE])
886 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
888 printk(KERN_CONT ", CHS=%d/%d/%d\n",
889 drive->bios_cyl, drive->bios_head, drive->bios_sect);
891 /* write cache enabled? */
892 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
895 write_cache(drive, 1);
898 static void ide_cacheflush_p(ide_drive_t *drive)
900 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
903 if (do_idedisk_flushcache(drive))
904 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
907 static void ide_disk_remove(ide_drive_t *drive)
909 struct ide_disk_obj *idkp = drive->driver_data;
910 struct gendisk *g = idkp->disk;
912 ide_proc_unregister_driver(drive, idkp->driver);
916 ide_cacheflush_p(drive);
921 static void ide_disk_release(struct kref *kref)
923 struct ide_disk_obj *idkp = to_ide_disk(kref);
924 ide_drive_t *drive = idkp->drive;
925 struct gendisk *g = idkp->disk;
927 drive->driver_data = NULL;
928 g->private_data = NULL;
933 static int ide_disk_probe(ide_drive_t *drive);
936 * On HPA drives the capacity needs to be
937 * reinitilized on resume otherwise the disk
938 * can not be used and a hard reset is required
940 static void ide_disk_resume(ide_drive_t *drive)
942 if (idedisk_supports_hpa(drive->id))
943 init_idedisk_capacity(drive);
946 static void ide_device_shutdown(ide_drive_t *drive)
949 /* On Alpha, halt(8) doesn't actually turn the machine off,
950 it puts you into the sort of firmware monitor. Typically,
951 it's used to boot another kernel image, so it's not much
952 different from reboot(8). Therefore, we don't need to
953 spin down the disk in this case, especially since Alpha
954 firmware doesn't handle disks in standby mode properly.
955 On the other hand, it's reasonably safe to turn the power
956 off when the shutdown process reaches the firmware prompt,
957 as the firmware initialization takes rather long time -
958 at least 10 seconds, which should be sufficient for
959 the disk to expire its write cache. */
960 if (system_state != SYSTEM_POWER_OFF) {
962 if (system_state == SYSTEM_RESTART) {
964 ide_cacheflush_p(drive);
968 printk(KERN_INFO "Shutdown: %s\n", drive->name);
970 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
973 static ide_driver_t idedisk_driver = {
975 .owner = THIS_MODULE,
977 .bus = &ide_bus_type,
979 .probe = ide_disk_probe,
980 .remove = ide_disk_remove,
981 .resume = ide_disk_resume,
982 .shutdown = ide_device_shutdown,
983 .version = IDEDISK_VERSION,
985 .supports_dsc_overlap = 0,
986 .do_request = ide_do_rw_disk,
987 .end_request = ide_end_request,
988 .error = __ide_error,
989 #ifdef CONFIG_IDE_PROC_FS
990 .proc = idedisk_proc,
994 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
998 memset(&task, 0, sizeof(task));
999 task.tf.command = on ? WIN_DOORLOCK : WIN_DOORUNLOCK;
1000 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
1002 return ide_no_data_taskfile(drive, &task);
1005 static int idedisk_open(struct inode *inode, struct file *filp)
1007 struct gendisk *disk = inode->i_bdev->bd_disk;
1008 struct ide_disk_obj *idkp;
1011 idkp = ide_disk_get(disk);
1015 drive = idkp->drive;
1019 if (drive->removable && idkp->openers == 1) {
1020 check_disk_change(inode->i_bdev);
1022 * Ignore the return code from door_lock,
1023 * since the open() has already succeeded,
1024 * and the door_lock is irrelevant at this point.
1026 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1027 drive->doorlocking = 0;
1032 static int idedisk_release(struct inode *inode, struct file *filp)
1034 struct gendisk *disk = inode->i_bdev->bd_disk;
1035 struct ide_disk_obj *idkp = ide_disk_g(disk);
1036 ide_drive_t *drive = idkp->drive;
1038 if (idkp->openers == 1)
1039 ide_cacheflush_p(drive);
1041 if (drive->removable && idkp->openers == 1) {
1042 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1043 drive->doorlocking = 0;
1053 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1055 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1056 ide_drive_t *drive = idkp->drive;
1058 geo->heads = drive->bios_head;
1059 geo->sectors = drive->bios_sect;
1060 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1064 static int idedisk_ioctl(struct inode *inode, struct file *file,
1065 unsigned int cmd, unsigned long arg)
1067 unsigned long flags;
1068 struct block_device *bdev = inode->i_bdev;
1069 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1070 ide_drive_t *drive = idkp->drive;
1071 int err, (*setfunc)(ide_drive_t *, int);
1075 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1076 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1077 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1078 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1079 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1080 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1081 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1082 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1083 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1084 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1087 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1090 mutex_lock(&ide_setting_mtx);
1091 spin_lock_irqsave(&ide_lock, flags);
1093 spin_unlock_irqrestore(&ide_lock, flags);
1094 mutex_unlock(&ide_setting_mtx);
1095 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1098 if (bdev != bdev->bd_contains)
1101 if (!capable(CAP_SYS_ADMIN))
1104 mutex_lock(&ide_setting_mtx);
1105 err = setfunc(drive, arg);
1106 mutex_unlock(&ide_setting_mtx);
1112 static int idedisk_media_changed(struct gendisk *disk)
1114 struct ide_disk_obj *idkp = ide_disk_g(disk);
1115 ide_drive_t *drive = idkp->drive;
1117 /* do not scan partitions twice if this is a removable device */
1118 if (drive->attach) {
1122 /* if removable, always assume it was changed */
1123 return drive->removable;
1126 static int idedisk_revalidate_disk(struct gendisk *disk)
1128 struct ide_disk_obj *idkp = ide_disk_g(disk);
1129 set_capacity(disk, idedisk_capacity(idkp->drive));
1133 static struct block_device_operations idedisk_ops = {
1134 .owner = THIS_MODULE,
1135 .open = idedisk_open,
1136 .release = idedisk_release,
1137 .ioctl = idedisk_ioctl,
1138 .getgeo = idedisk_getgeo,
1139 .media_changed = idedisk_media_changed,
1140 .revalidate_disk = idedisk_revalidate_disk
1143 MODULE_DESCRIPTION("ATA DISK Driver");
1145 static int ide_disk_probe(ide_drive_t *drive)
1147 struct ide_disk_obj *idkp;
1150 /* strstr("foo", "") is non-NULL */
1151 if (!strstr("ide-disk", drive->driver_req))
1153 if (!drive->present)
1155 if (drive->media != ide_disk)
1158 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1162 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
1166 ide_init_disk(g, drive);
1168 ide_proc_register_driver(drive, &idedisk_driver);
1170 kref_init(&idkp->kref);
1172 idkp->drive = drive;
1173 idkp->driver = &idedisk_driver;
1176 g->private_data = &idkp->driver;
1178 drive->driver_data = idkp;
1180 idedisk_setup(drive);
1181 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1182 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1183 drive->name, drive->head);
1188 g->minors = IDE_DISK_MINORS;
1189 g->driverfs_dev = &drive->gendev;
1190 g->flags |= GENHD_FL_EXT_DEVT;
1191 if (drive->removable)
1192 g->flags |= GENHD_FL_REMOVABLE;
1193 set_capacity(g, idedisk_capacity(drive));
1194 g->fops = &idedisk_ops;
1204 static void __exit idedisk_exit(void)
1206 driver_unregister(&idedisk_driver.gen_driver);
1209 static int __init idedisk_init(void)
1211 return driver_register(&idedisk_driver.gen_driver);
1214 MODULE_ALIAS("ide:*m-disk*");
1215 module_init(idedisk_init);
1216 module_exit(idedisk_exit);
1217 MODULE_LICENSE("GPL");