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 #define IDE_DISK_PARTS (1 << PARTN_BITS)
45 #define IDE_DISK_MINORS IDE_DISK_PARTS
46 #define IDE_DISK_EXT_MINORS (IDE_DISK_PARTS - IDE_DISK_MINORS)
53 unsigned int openers; /* protected by BKL for now */
56 static DEFINE_MUTEX(idedisk_ref_mutex);
58 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
60 #define ide_disk_g(disk) \
61 container_of((disk)->private_data, struct ide_disk_obj, driver)
63 static void ide_disk_release(struct kref *);
65 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
67 struct ide_disk_obj *idkp = NULL;
69 mutex_lock(&idedisk_ref_mutex);
70 idkp = ide_disk_g(disk);
72 if (ide_device_get(idkp->drive))
75 kref_get(&idkp->kref);
77 mutex_unlock(&idedisk_ref_mutex);
81 static void ide_disk_put(struct ide_disk_obj *idkp)
83 ide_drive_t *drive = idkp->drive;
85 mutex_lock(&idedisk_ref_mutex);
86 kref_put(&idkp->kref, ide_disk_release);
87 ide_device_put(drive);
88 mutex_unlock(&idedisk_ref_mutex);
92 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
93 * value for this drive (from its reported identification information).
95 * Returns: 1 if lba_capacity looks sensible
98 * It is called only once for each drive.
100 static int lba_capacity_is_ok(struct hd_driveid *id)
102 unsigned long lba_sects, chs_sects, head, tail;
104 /* No non-LBA info .. so valid! */
109 * The ATA spec tells large drives to return
110 * C/H/S = 16383/16/63 independent of their size.
111 * Some drives can be jumpered to use 15 heads instead of 16.
112 * Some drives can be jumpered to use 4092 cyls instead of 16383.
114 if ((id->cyls == 16383
115 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
117 (id->heads == 15 || id->heads == 16) &&
118 (id->lba_capacity >= 16383*63*id->heads))
121 lba_sects = id->lba_capacity;
122 chs_sects = id->cyls * id->heads * id->sectors;
124 /* perform a rough sanity check on lba_sects: within 10% is OK */
125 if ((lba_sects - chs_sects) < chs_sects/10)
128 /* some drives have the word order reversed */
129 head = ((lba_sects >> 16) & 0xffff);
130 tail = (lba_sects & 0xffff);
131 lba_sects = (head | (tail << 16));
132 if ((lba_sects - chs_sects) < chs_sects/10) {
133 id->lba_capacity = lba_sects;
134 return 1; /* lba_capacity is (now) good */
137 return 0; /* lba_capacity value may be bad */
140 static const u8 ide_rw_cmds[] = {
155 static const u8 ide_data_phases[] = {
164 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
166 u8 index, lba48, write;
168 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
169 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
174 index = drive->mult_count ? 0 : 4;
176 task->tf.command = ide_rw_cmds[index + lba48 + write];
179 index = 8; /* fixup index */
181 task->data_phase = ide_data_phases[index / 2 + write];
185 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
186 * using LBA if supported, or CHS otherwise, to address sectors.
188 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
191 ide_hwif_t *hwif = HWIF(drive);
192 unsigned int dma = drive->using_dma;
193 u16 nsectors = (u16)rq->nr_sectors;
194 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
196 struct ide_taskfile *tf = &task.tf;
199 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
200 if (block + rq->nr_sectors > 1ULL << 28)
207 ide_init_sg_cmd(drive, rq);
208 ide_map_sg(drive, rq);
211 memset(&task, 0, sizeof(task));
212 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
214 if (drive->select.b.lba) {
216 pr_debug("%s: LBA=0x%012llx\n", drive->name,
217 (unsigned long long)block);
219 tf->hob_nsect = (nsectors >> 8) & 0xff;
220 tf->hob_lbal = (u8)(block >> 24);
221 if (sizeof(block) != 4) {
222 tf->hob_lbam = (u8)((u64)block >> 32);
223 tf->hob_lbah = (u8)((u64)block >> 40);
226 tf->nsect = nsectors & 0xff;
227 tf->lbal = (u8) block;
228 tf->lbam = (u8)(block >> 8);
229 tf->lbah = (u8)(block >> 16);
231 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
233 tf->nsect = nsectors & 0xff;
235 tf->lbam = block >>= 8;
236 tf->lbah = block >>= 8;
237 tf->device = (block >> 8) & 0xf;
240 unsigned int sect, head, cyl, track;
242 track = (int)block / drive->sect;
243 sect = (int)block % drive->sect + 1;
244 head = track % drive->head;
245 cyl = track / drive->head;
247 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
249 tf->nsect = nsectors & 0xff;
257 task.tf_flags |= IDE_TFLAG_WRITE;
259 ide_tf_set_cmd(drive, &task, dma);
261 hwif->data_phase = task.data_phase;
264 rc = do_rw_taskfile(drive, &task);
266 if (rc == ide_stopped && dma) {
267 /* fallback to PIO */
268 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
269 ide_tf_set_cmd(drive, &task, 0);
270 hwif->data_phase = task.data_phase;
271 ide_init_sg_cmd(drive, rq);
272 rc = do_rw_taskfile(drive, &task);
279 * 268435455 == 137439 MB or 28bit limit
280 * 320173056 == 163929 MB or 48bit addressing
281 * 1073741822 == 549756 MB or 48bit addressing fake drive
284 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
287 ide_hwif_t *hwif = HWIF(drive);
289 BUG_ON(drive->blocked);
291 if (!blk_fs_request(rq)) {
292 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
293 ide_end_request(drive, 0, 0);
297 ledtrig_ide_activity();
299 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
300 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
301 (unsigned long long)block, rq->nr_sectors,
302 (unsigned long)rq->buffer);
305 hwif->rw_disk(drive, rq);
307 return __ide_do_rw_disk(drive, rq, block);
311 * Queries for true maximum capacity of the drive.
312 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
314 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
317 struct ide_taskfile *tf = &args.tf;
320 /* Create IDE/ATA command request structure */
321 memset(&args, 0, sizeof(ide_task_t));
323 tf->command = WIN_READ_NATIVE_MAX_EXT;
325 tf->command = WIN_READ_NATIVE_MAX;
326 tf->device = ATA_LBA;
327 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
329 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
330 /* submit command request */
331 ide_no_data_taskfile(drive, &args);
333 /* if OK, compute maximum address value */
334 if ((tf->status & 0x01) == 0)
335 addr = ide_get_lba_addr(tf, lba48) + 1;
341 * Sets maximum virtual LBA address of the drive.
342 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
344 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
347 struct ide_taskfile *tf = &args.tf;
351 /* Create IDE/ATA command request structure */
352 memset(&args, 0, sizeof(ide_task_t));
353 tf->lbal = (addr_req >> 0) & 0xff;
354 tf->lbam = (addr_req >>= 8) & 0xff;
355 tf->lbah = (addr_req >>= 8) & 0xff;
357 tf->hob_lbal = (addr_req >>= 8) & 0xff;
358 tf->hob_lbam = (addr_req >>= 8) & 0xff;
359 tf->hob_lbah = (addr_req >>= 8) & 0xff;
360 tf->command = WIN_SET_MAX_EXT;
362 tf->device = (addr_req >>= 8) & 0x0f;
363 tf->command = WIN_SET_MAX;
365 tf->device |= ATA_LBA;
366 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
368 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
369 /* submit command request */
370 ide_no_data_taskfile(drive, &args);
371 /* if OK, compute maximum address value */
372 if ((tf->status & 0x01) == 0)
373 addr_set = ide_get_lba_addr(tf, lba48) + 1;
378 static unsigned long long sectors_to_MB(unsigned long long n)
380 n <<= 9; /* make it bytes */
381 do_div(n, 1000000); /* make it MB */
386 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
387 * so on non-buggy drives we need test only one.
388 * However, we should also check whether these fields are valid.
390 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
392 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
398 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
400 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
401 && id->lba_capacity_2;
405 * Some disks report total number of sectors instead of
406 * maximum sector address. We list them here.
408 static const struct drive_list_entry hpa_list[] = {
409 { "ST340823A", NULL },
410 { "ST320413A", NULL },
411 { "ST310211A", NULL },
415 static void idedisk_check_hpa(ide_drive_t *drive)
417 unsigned long long capacity, set_max;
418 int lba48 = idedisk_supports_lba48(drive->id);
420 capacity = drive->capacity64;
422 set_max = idedisk_read_native_max_address(drive, lba48);
424 if (ide_in_drive_list(drive->id, hpa_list)) {
426 * Since we are inclusive wrt to firmware revisions do this
427 * extra check and apply the workaround only when needed.
429 if (set_max == capacity + 1)
433 if (set_max <= capacity)
436 printk(KERN_INFO "%s: Host Protected Area detected.\n"
437 "\tcurrent capacity is %llu sectors (%llu MB)\n"
438 "\tnative capacity is %llu sectors (%llu MB)\n",
440 capacity, sectors_to_MB(capacity),
441 set_max, sectors_to_MB(set_max));
443 set_max = idedisk_set_max_address(drive, set_max, lba48);
446 drive->capacity64 = set_max;
447 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
452 static void init_idedisk_capacity(ide_drive_t *drive)
454 struct hd_driveid *id = drive->id;
456 * If this drive supports the Host Protected Area feature set,
457 * then we may need to change our opinion about the drive's capacity.
459 int hpa = idedisk_supports_hpa(id);
461 if (idedisk_supports_lba48(id)) {
462 /* drive speaks 48-bit LBA */
463 drive->select.b.lba = 1;
464 drive->capacity64 = id->lba_capacity_2;
466 idedisk_check_hpa(drive);
467 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
468 /* drive speaks 28-bit LBA */
469 drive->select.b.lba = 1;
470 drive->capacity64 = id->lba_capacity;
472 idedisk_check_hpa(drive);
474 /* drive speaks boring old 28-bit CHS */
475 drive->capacity64 = drive->cyl * drive->head * drive->sect;
479 static sector_t idedisk_capacity(ide_drive_t *drive)
481 return drive->capacity64 - drive->sect0;
484 #ifdef CONFIG_IDE_PROC_FS
485 static int smart_enable(ide_drive_t *drive)
488 struct ide_taskfile *tf = &args.tf;
490 memset(&args, 0, sizeof(ide_task_t));
491 tf->feature = SMART_ENABLE;
492 tf->lbam = SMART_LCYL_PASS;
493 tf->lbah = SMART_HCYL_PASS;
494 tf->command = WIN_SMART;
495 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
496 return ide_no_data_taskfile(drive, &args);
499 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
502 struct ide_taskfile *tf = &args.tf;
504 memset(&args, 0, sizeof(ide_task_t));
505 tf->feature = sub_cmd;
507 tf->lbam = SMART_LCYL_PASS;
508 tf->lbah = SMART_HCYL_PASS;
509 tf->command = WIN_SMART;
510 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
511 args.data_phase = TASKFILE_IN;
512 (void) smart_enable(drive);
513 return ide_raw_taskfile(drive, &args, buf, 1);
516 static int proc_idedisk_read_cache
517 (char *page, char **start, off_t off, int count, int *eof, void *data)
519 ide_drive_t *drive = (ide_drive_t *) data;
524 len = sprintf(out, "%i\n", drive->id->buf_size / 2);
526 len = sprintf(out, "(none)\n");
528 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
531 static int proc_idedisk_read_capacity
532 (char *page, char **start, off_t off, int count, int *eof, void *data)
534 ide_drive_t*drive = (ide_drive_t *)data;
537 len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
539 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
542 static int proc_idedisk_read_smart(char *page, char **start, off_t off,
543 int count, int *eof, void *data, u8 sub_cmd)
545 ide_drive_t *drive = (ide_drive_t *)data;
548 if (get_smart_data(drive, page, sub_cmd) == 0) {
549 unsigned short *val = (unsigned short *) page;
550 char *out = ((char *)val) + (SECTOR_WORDS * 4);
553 out += sprintf(out, "%04x%c", le16_to_cpu(*val),
554 (++i & 7) ? ' ' : '\n');
556 } while (i < (SECTOR_WORDS * 2));
560 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
563 static int proc_idedisk_read_sv
564 (char *page, char **start, off_t off, int count, int *eof, void *data)
566 return proc_idedisk_read_smart(page, start, off, count, eof, data,
570 static int proc_idedisk_read_st
571 (char *page, char **start, off_t off, int count, int *eof, void *data)
573 return proc_idedisk_read_smart(page, start, off, count, eof, data,
574 SMART_READ_THRESHOLDS);
577 static ide_proc_entry_t idedisk_proc[] = {
578 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
579 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
580 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
581 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv, NULL },
582 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st, NULL },
583 { NULL, 0, NULL, NULL }
585 #endif /* CONFIG_IDE_PROC_FS */
587 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
589 ide_drive_t *drive = q->queuedata;
590 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
592 /* FIXME: map struct ide_taskfile on rq->cmd[] */
593 BUG_ON(task == NULL);
595 memset(task, 0, sizeof(*task));
596 if (ide_id_has_flush_cache_ext(drive->id) &&
597 (drive->capacity64 >= (1UL << 28)))
598 task->tf.command = WIN_FLUSH_CACHE_EXT;
600 task->tf.command = WIN_FLUSH_CACHE;
601 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)
619 if (arg < 0 || arg > drive->id->max_multsect)
622 if (drive->special.b.set_multmode)
625 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
626 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
628 drive->mult_req = arg;
629 drive->special.b.set_multmode = 1;
630 error = blk_execute_rq(drive->queue, NULL, rq, 0);
633 return (drive->mult_count == arg) ? 0 : -EIO;
636 static int set_nowerr(ide_drive_t *drive, int arg)
638 if (arg < 0 || arg > 1)
641 if (ide_spin_wait_hwgroup(drive))
644 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
645 spin_unlock_irq(&ide_lock);
649 static void update_ordered(ide_drive_t *drive)
651 struct hd_driveid *id = drive->id;
652 unsigned ordered = QUEUE_ORDERED_NONE;
653 prepare_flush_fn *prep_fn = NULL;
656 unsigned long long capacity;
659 * We must avoid issuing commands a drive does not
660 * understand or we may crash it. We check flush cache
661 * is supported. We also check we have the LBA48 flush
662 * cache if the drive capacity is too large. By this
663 * time we have trimmed the drive capacity if LBA48 is
664 * not available so we don't need to recheck that.
666 capacity = idedisk_capacity(drive);
667 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
668 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
669 ide_id_has_flush_cache_ext(id));
671 printk(KERN_INFO "%s: cache flushes %ssupported\n",
672 drive->name, barrier ? "" : "not ");
675 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
676 prep_fn = idedisk_prepare_flush;
679 ordered = QUEUE_ORDERED_DRAIN;
681 blk_queue_ordered(drive->queue, ordered, prep_fn);
684 static int write_cache(ide_drive_t *drive, int arg)
689 if (arg < 0 || arg > 1)
692 if (ide_id_has_flush_cache(drive->id)) {
693 memset(&args, 0, sizeof(ide_task_t));
694 args.tf.feature = arg ?
695 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
696 args.tf.command = WIN_SETFEATURES;
697 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
698 err = ide_no_data_taskfile(drive, &args);
703 update_ordered(drive);
708 static int do_idedisk_flushcache(ide_drive_t *drive)
712 memset(&args, 0, sizeof(ide_task_t));
713 if (ide_id_has_flush_cache_ext(drive->id))
714 args.tf.command = WIN_FLUSH_CACHE_EXT;
716 args.tf.command = WIN_FLUSH_CACHE;
717 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
718 return ide_no_data_taskfile(drive, &args);
721 static int set_acoustic(ide_drive_t *drive, int arg)
725 if (arg < 0 || arg > 254)
728 memset(&args, 0, sizeof(ide_task_t));
729 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
731 args.tf.command = WIN_SETFEATURES;
732 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
733 ide_no_data_taskfile(drive, &args);
734 drive->acoustic = arg;
742 * 2: 48-bit capable doing 28-bit
744 static int set_lba_addressing(ide_drive_t *drive, int arg)
746 if (arg < 0 || arg > 2)
749 drive->addressing = 0;
751 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
754 if (!idedisk_supports_lba48(drive->id))
756 drive->addressing = arg;
760 #ifdef CONFIG_IDE_PROC_FS
761 static void idedisk_add_settings(ide_drive_t *drive)
763 struct hd_driveid *id = drive->id;
765 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
766 &drive->bios_cyl, NULL);
767 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
768 &drive->bios_head, NULL);
769 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1,
770 &drive->bios_sect, NULL);
771 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1,
772 &drive->addressing, set_lba_addressing);
773 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0,
774 id->max_multsect, 1, 1, &drive->mult_count,
776 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
777 &drive->nowerr, set_nowerr);
778 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1,
780 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
781 &drive->wcache, write_cache);
782 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1,
783 &drive->acoustic, set_acoustic);
784 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
785 &drive->failures, NULL);
786 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535,
787 1, 1, &drive->max_failures, NULL);
790 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
793 static void idedisk_setup(ide_drive_t *drive)
795 ide_hwif_t *hwif = drive->hwif;
796 struct hd_driveid *id = drive->id;
797 unsigned long long capacity;
799 idedisk_add_settings(drive);
801 if (drive->id_read == 0)
804 if (drive->removable) {
806 * Removable disks (eg. SYQUEST); ignore 'WD' drives
808 if (id->model[0] != 'W' || id->model[1] != 'D')
809 drive->doorlocking = 1;
812 (void)set_lba_addressing(drive, 1);
814 if (drive->addressing == 1) {
817 if (max_s > hwif->rqsize)
818 max_s = hwif->rqsize;
820 blk_queue_max_sectors(drive->queue, max_s);
823 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
824 drive->queue->max_sectors / 2);
826 /* calculate drive capacity, and select LBA if possible */
827 init_idedisk_capacity(drive);
829 /* limit drive capacity to 137GB if LBA48 cannot be used */
830 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
831 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
832 "%llu sectors (%llu MB)\n",
833 drive->name, (unsigned long long)drive->capacity64,
834 sectors_to_MB(drive->capacity64));
835 drive->capacity64 = 1ULL << 28;
838 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
839 if (drive->capacity64 > 1ULL << 28) {
840 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
841 " will be used for accessing sectors "
842 "> %u\n", drive->name, 1 << 28);
844 drive->addressing = 0;
848 * if possible, give fdisk access to more of the drive,
849 * by correcting bios_cyls:
851 capacity = idedisk_capacity(drive);
853 if (!drive->forced_geom) {
855 if (idedisk_supports_lba48(drive->id)) {
857 drive->bios_sect = 63;
858 drive->bios_head = 255;
861 if (drive->bios_sect && drive->bios_head) {
862 unsigned int cap0 = capacity; /* truncate to 32 bits */
863 unsigned int cylsz, cyl;
865 if (cap0 != capacity)
866 drive->bios_cyl = 65535;
868 cylsz = drive->bios_sect * drive->bios_head;
872 if (cyl > drive->bios_cyl)
873 drive->bios_cyl = cyl;
877 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
878 drive->name, capacity, sectors_to_MB(capacity));
880 /* Only print cache size when it was specified */
882 printk(KERN_CONT " w/%dKiB Cache", id->buf_size / 2);
884 printk(KERN_CONT ", CHS=%d/%d/%d\n",
885 drive->bios_cyl, drive->bios_head, drive->bios_sect);
887 /* write cache enabled? */
888 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
891 write_cache(drive, 1);
894 static void ide_cacheflush_p(ide_drive_t *drive)
896 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
899 if (do_idedisk_flushcache(drive))
900 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
903 static void ide_disk_remove(ide_drive_t *drive)
905 struct ide_disk_obj *idkp = drive->driver_data;
906 struct gendisk *g = idkp->disk;
908 ide_proc_unregister_driver(drive, idkp->driver);
912 ide_cacheflush_p(drive);
917 static void ide_disk_release(struct kref *kref)
919 struct ide_disk_obj *idkp = to_ide_disk(kref);
920 ide_drive_t *drive = idkp->drive;
921 struct gendisk *g = idkp->disk;
923 drive->driver_data = NULL;
924 g->private_data = NULL;
929 static int ide_disk_probe(ide_drive_t *drive);
932 * On HPA drives the capacity needs to be
933 * reinitilized on resume otherwise the disk
934 * can not be used and a hard reset is required
936 static void ide_disk_resume(ide_drive_t *drive)
938 if (idedisk_supports_hpa(drive->id))
939 init_idedisk_capacity(drive);
942 static void ide_device_shutdown(ide_drive_t *drive)
945 /* On Alpha, halt(8) doesn't actually turn the machine off,
946 it puts you into the sort of firmware monitor. Typically,
947 it's used to boot another kernel image, so it's not much
948 different from reboot(8). Therefore, we don't need to
949 spin down the disk in this case, especially since Alpha
950 firmware doesn't handle disks in standby mode properly.
951 On the other hand, it's reasonably safe to turn the power
952 off when the shutdown process reaches the firmware prompt,
953 as the firmware initialization takes rather long time -
954 at least 10 seconds, which should be sufficient for
955 the disk to expire its write cache. */
956 if (system_state != SYSTEM_POWER_OFF) {
958 if (system_state == SYSTEM_RESTART) {
960 ide_cacheflush_p(drive);
964 printk(KERN_INFO "Shutdown: %s\n", drive->name);
966 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
969 static ide_driver_t idedisk_driver = {
971 .owner = THIS_MODULE,
973 .bus = &ide_bus_type,
975 .probe = ide_disk_probe,
976 .remove = ide_disk_remove,
977 .resume = ide_disk_resume,
978 .shutdown = ide_device_shutdown,
979 .version = IDEDISK_VERSION,
981 .supports_dsc_overlap = 0,
982 .do_request = ide_do_rw_disk,
983 .end_request = ide_end_request,
984 .error = __ide_error,
985 #ifdef CONFIG_IDE_PROC_FS
986 .proc = idedisk_proc,
990 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
994 memset(&task, 0, sizeof(task));
995 task.tf.command = on ? WIN_DOORLOCK : WIN_DOORUNLOCK;
996 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
998 return ide_no_data_taskfile(drive, &task);
1001 static int idedisk_open(struct inode *inode, struct file *filp)
1003 struct gendisk *disk = inode->i_bdev->bd_disk;
1004 struct ide_disk_obj *idkp;
1007 idkp = ide_disk_get(disk);
1011 drive = idkp->drive;
1015 if (drive->removable && idkp->openers == 1) {
1016 check_disk_change(inode->i_bdev);
1018 * Ignore the return code from door_lock,
1019 * since the open() has already succeeded,
1020 * and the door_lock is irrelevant at this point.
1022 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1023 drive->doorlocking = 0;
1028 static int idedisk_release(struct inode *inode, struct file *filp)
1030 struct gendisk *disk = inode->i_bdev->bd_disk;
1031 struct ide_disk_obj *idkp = ide_disk_g(disk);
1032 ide_drive_t *drive = idkp->drive;
1034 if (idkp->openers == 1)
1035 ide_cacheflush_p(drive);
1037 if (drive->removable && idkp->openers == 1) {
1038 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1039 drive->doorlocking = 0;
1049 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1051 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1052 ide_drive_t *drive = idkp->drive;
1054 geo->heads = drive->bios_head;
1055 geo->sectors = drive->bios_sect;
1056 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1060 static int idedisk_ioctl(struct inode *inode, struct file *file,
1061 unsigned int cmd, unsigned long arg)
1063 unsigned long flags;
1064 struct block_device *bdev = inode->i_bdev;
1065 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1066 ide_drive_t *drive = idkp->drive;
1067 int err, (*setfunc)(ide_drive_t *, int);
1071 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1072 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1073 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1074 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1075 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1076 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1077 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1078 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1079 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1080 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1083 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1086 mutex_lock(&ide_setting_mtx);
1087 spin_lock_irqsave(&ide_lock, flags);
1089 spin_unlock_irqrestore(&ide_lock, flags);
1090 mutex_unlock(&ide_setting_mtx);
1091 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1094 if (bdev != bdev->bd_contains)
1097 if (!capable(CAP_SYS_ADMIN))
1100 mutex_lock(&ide_setting_mtx);
1101 err = setfunc(drive, arg);
1102 mutex_unlock(&ide_setting_mtx);
1108 static int idedisk_media_changed(struct gendisk *disk)
1110 struct ide_disk_obj *idkp = ide_disk_g(disk);
1111 ide_drive_t *drive = idkp->drive;
1113 /* do not scan partitions twice if this is a removable device */
1114 if (drive->attach) {
1118 /* if removable, always assume it was changed */
1119 return drive->removable;
1122 static int idedisk_revalidate_disk(struct gendisk *disk)
1124 struct ide_disk_obj *idkp = ide_disk_g(disk);
1125 set_capacity(disk, idedisk_capacity(idkp->drive));
1129 static struct block_device_operations idedisk_ops = {
1130 .owner = THIS_MODULE,
1131 .open = idedisk_open,
1132 .release = idedisk_release,
1133 .ioctl = idedisk_ioctl,
1134 .getgeo = idedisk_getgeo,
1135 .media_changed = idedisk_media_changed,
1136 .revalidate_disk = idedisk_revalidate_disk
1139 MODULE_DESCRIPTION("ATA DISK Driver");
1141 static int ide_disk_probe(ide_drive_t *drive)
1143 struct ide_disk_obj *idkp;
1146 /* strstr("foo", "") is non-NULL */
1147 if (!strstr("ide-disk", drive->driver_req))
1149 if (!drive->present)
1151 if (drive->media != ide_disk)
1154 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1158 g = alloc_disk_ext_node(IDE_DISK_MINORS, IDE_DISK_EXT_MINORS,
1159 hwif_to_node(drive->hwif));
1163 ide_init_disk(g, drive);
1165 ide_proc_register_driver(drive, &idedisk_driver);
1167 kref_init(&idkp->kref);
1169 idkp->drive = drive;
1170 idkp->driver = &idedisk_driver;
1173 g->private_data = &idkp->driver;
1175 drive->driver_data = idkp;
1177 idedisk_setup(drive);
1178 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1179 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1180 drive->name, drive->head);
1185 g->minors = IDE_DISK_MINORS;
1186 g->ext_minors = IDE_DISK_EXT_MINORS;
1187 g->driverfs_dev = &drive->gendev;
1188 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1189 set_capacity(g, idedisk_capacity(drive));
1190 g->fops = &idedisk_ops;
1200 static void __exit idedisk_exit(void)
1202 driver_unregister(&idedisk_driver.gen_driver);
1205 static int __init idedisk_init(void)
1207 return driver_register(&idedisk_driver.gen_driver);
1210 MODULE_ALIAS("ide:*m-disk*");
1211 module_init(idedisk_init);
1212 module_exit(idedisk_exit);
1213 MODULE_LICENSE("GPL");