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>
33 #include <linux/ide.h>
34 #include <linux/hdreg.h>
36 #include <asm/byteorder.h>
38 #include <asm/uaccess.h>
40 #include <asm/div64.h>
42 #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
43 #define IDE_DISK_MINORS (1 << PARTN_BITS)
45 #define IDE_DISK_MINORS 0
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);
91 static const u8 ide_rw_cmds[] = {
94 ATA_CMD_READ_MULTI_EXT,
95 ATA_CMD_WRITE_MULTI_EXT,
99 ATA_CMD_PIO_WRITE_EXT,
106 static const u8 ide_data_phases[] = {
115 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
117 u8 index, lba48, write;
119 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
120 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
125 index = drive->mult_count ? 0 : 4;
127 task->tf.command = ide_rw_cmds[index + lba48 + write];
130 index = 8; /* fixup index */
132 task->data_phase = ide_data_phases[index / 2 + write];
136 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
137 * using LBA if supported, or CHS otherwise, to address sectors.
139 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
142 ide_hwif_t *hwif = HWIF(drive);
143 unsigned int dma = drive->using_dma;
144 u16 nsectors = (u16)rq->nr_sectors;
145 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
147 struct ide_taskfile *tf = &task.tf;
150 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
151 if (block + rq->nr_sectors > 1ULL << 28)
158 ide_init_sg_cmd(drive, rq);
159 ide_map_sg(drive, rq);
162 memset(&task, 0, sizeof(task));
163 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
165 if (drive->select.b.lba) {
167 pr_debug("%s: LBA=0x%012llx\n", drive->name,
168 (unsigned long long)block);
170 tf->hob_nsect = (nsectors >> 8) & 0xff;
171 tf->hob_lbal = (u8)(block >> 24);
172 if (sizeof(block) != 4) {
173 tf->hob_lbam = (u8)((u64)block >> 32);
174 tf->hob_lbah = (u8)((u64)block >> 40);
177 tf->nsect = nsectors & 0xff;
178 tf->lbal = (u8) block;
179 tf->lbam = (u8)(block >> 8);
180 tf->lbah = (u8)(block >> 16);
182 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
184 tf->nsect = nsectors & 0xff;
186 tf->lbam = block >>= 8;
187 tf->lbah = block >>= 8;
188 tf->device = (block >> 8) & 0xf;
191 unsigned int sect, head, cyl, track;
193 track = (int)block / drive->sect;
194 sect = (int)block % drive->sect + 1;
195 head = track % drive->head;
196 cyl = track / drive->head;
198 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
200 tf->nsect = nsectors & 0xff;
208 task.tf_flags |= IDE_TFLAG_WRITE;
210 ide_tf_set_cmd(drive, &task, dma);
212 hwif->data_phase = task.data_phase;
215 rc = do_rw_taskfile(drive, &task);
217 if (rc == ide_stopped && dma) {
218 /* fallback to PIO */
219 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
220 ide_tf_set_cmd(drive, &task, 0);
221 hwif->data_phase = task.data_phase;
222 ide_init_sg_cmd(drive, rq);
223 rc = do_rw_taskfile(drive, &task);
230 * 268435455 == 137439 MB or 28bit limit
231 * 320173056 == 163929 MB or 48bit addressing
232 * 1073741822 == 549756 MB or 48bit addressing fake drive
235 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
238 ide_hwif_t *hwif = HWIF(drive);
240 BUG_ON(drive->blocked);
242 if (!blk_fs_request(rq)) {
243 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
244 ide_end_request(drive, 0, 0);
248 ledtrig_ide_activity();
250 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
251 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
252 (unsigned long long)block, rq->nr_sectors,
253 (unsigned long)rq->buffer);
256 hwif->rw_disk(drive, rq);
258 return __ide_do_rw_disk(drive, rq, block);
262 * Queries for true maximum capacity of the drive.
263 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
265 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
268 struct ide_taskfile *tf = &args.tf;
271 /* Create IDE/ATA command request structure */
272 memset(&args, 0, sizeof(ide_task_t));
274 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
276 tf->command = ATA_CMD_READ_NATIVE_MAX;
277 tf->device = ATA_LBA;
278 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
280 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
281 /* submit command request */
282 ide_no_data_taskfile(drive, &args);
284 /* if OK, compute maximum address value */
285 if ((tf->status & 0x01) == 0)
286 addr = ide_get_lba_addr(tf, lba48) + 1;
292 * Sets maximum virtual LBA address of the drive.
293 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
295 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
298 struct ide_taskfile *tf = &args.tf;
302 /* Create IDE/ATA command request structure */
303 memset(&args, 0, sizeof(ide_task_t));
304 tf->lbal = (addr_req >> 0) & 0xff;
305 tf->lbam = (addr_req >>= 8) & 0xff;
306 tf->lbah = (addr_req >>= 8) & 0xff;
308 tf->hob_lbal = (addr_req >>= 8) & 0xff;
309 tf->hob_lbam = (addr_req >>= 8) & 0xff;
310 tf->hob_lbah = (addr_req >>= 8) & 0xff;
311 tf->command = ATA_CMD_SET_MAX_EXT;
313 tf->device = (addr_req >>= 8) & 0x0f;
314 tf->command = ATA_CMD_SET_MAX;
316 tf->device |= ATA_LBA;
317 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
319 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
320 /* submit command request */
321 ide_no_data_taskfile(drive, &args);
322 /* if OK, compute maximum address value */
323 if ((tf->status & 0x01) == 0)
324 addr_set = ide_get_lba_addr(tf, lba48) + 1;
329 static unsigned long long sectors_to_MB(unsigned long long n)
331 n <<= 9; /* make it bytes */
332 do_div(n, 1000000); /* make it MB */
337 * Some disks report total number of sectors instead of
338 * maximum sector address. We list them here.
340 static const struct drive_list_entry hpa_list[] = {
341 { "ST340823A", NULL },
342 { "ST320413A", NULL },
343 { "ST310211A", NULL },
347 static void idedisk_check_hpa(ide_drive_t *drive)
349 unsigned long long capacity, set_max;
350 int lba48 = ata_id_lba48_enabled(drive->id);
352 capacity = drive->capacity64;
354 set_max = idedisk_read_native_max_address(drive, lba48);
356 if (ide_in_drive_list(drive->id, hpa_list)) {
358 * Since we are inclusive wrt to firmware revisions do this
359 * extra check and apply the workaround only when needed.
361 if (set_max == capacity + 1)
365 if (set_max <= capacity)
368 printk(KERN_INFO "%s: Host Protected Area detected.\n"
369 "\tcurrent capacity is %llu sectors (%llu MB)\n"
370 "\tnative capacity is %llu sectors (%llu MB)\n",
372 capacity, sectors_to_MB(capacity),
373 set_max, sectors_to_MB(set_max));
375 set_max = idedisk_set_max_address(drive, set_max, lba48);
378 drive->capacity64 = set_max;
379 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
384 static void init_idedisk_capacity(ide_drive_t *drive)
388 * If this drive supports the Host Protected Area feature set,
389 * then we may need to change our opinion about the drive's capacity.
391 int hpa = ata_id_hpa_enabled(id);
393 if (ata_id_lba48_enabled(id)) {
394 /* drive speaks 48-bit LBA */
395 drive->select.b.lba = 1;
396 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
398 idedisk_check_hpa(drive);
399 } else if (ata_id_has_lba(id) && ata_id_is_lba_capacity_ok(id)) {
400 /* drive speaks 28-bit LBA */
401 drive->select.b.lba = 1;
402 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
404 idedisk_check_hpa(drive);
406 /* drive speaks boring old 28-bit CHS */
407 drive->capacity64 = drive->cyl * drive->head * drive->sect;
411 static sector_t idedisk_capacity(ide_drive_t *drive)
413 return drive->capacity64;
416 #ifdef CONFIG_IDE_PROC_FS
417 static int smart_enable(ide_drive_t *drive)
420 struct ide_taskfile *tf = &args.tf;
422 memset(&args, 0, sizeof(ide_task_t));
423 tf->feature = ATA_SMART_ENABLE;
424 tf->lbam = ATA_SMART_LBAM_PASS;
425 tf->lbah = ATA_SMART_LBAH_PASS;
426 tf->command = ATA_CMD_SMART;
427 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
428 return ide_no_data_taskfile(drive, &args);
431 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
434 struct ide_taskfile *tf = &args.tf;
436 memset(&args, 0, sizeof(ide_task_t));
437 tf->feature = sub_cmd;
439 tf->lbam = ATA_SMART_LBAM_PASS;
440 tf->lbah = ATA_SMART_LBAH_PASS;
441 tf->command = ATA_CMD_SMART;
442 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
443 args.data_phase = TASKFILE_IN;
444 (void) smart_enable(drive);
445 return ide_raw_taskfile(drive, &args, buf, 1);
448 static int proc_idedisk_read_cache
449 (char *page, char **start, off_t off, int count, int *eof, void *data)
451 ide_drive_t *drive = (ide_drive_t *) data;
456 len = sprintf(out, "%i\n", drive->id[ATA_ID_BUF_SIZE] / 2);
458 len = sprintf(out, "(none)\n");
460 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
463 static int proc_idedisk_read_capacity
464 (char *page, char **start, off_t off, int count, int *eof, void *data)
466 ide_drive_t*drive = (ide_drive_t *)data;
469 len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
471 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
474 static int proc_idedisk_read_smart(char *page, char **start, off_t off,
475 int count, int *eof, void *data, u8 sub_cmd)
477 ide_drive_t *drive = (ide_drive_t *)data;
480 if (get_smart_data(drive, page, sub_cmd) == 0) {
481 unsigned short *val = (unsigned short *) page;
482 char *out = (char *)val + SECTOR_SIZE;
486 out += sprintf(out, "%04x%c", le16_to_cpu(*val),
487 (++i & 7) ? ' ' : '\n');
489 } while (i < SECTOR_SIZE / 2);
493 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
496 static int proc_idedisk_read_sv
497 (char *page, char **start, off_t off, int count, int *eof, void *data)
499 return proc_idedisk_read_smart(page, start, off, count, eof, data,
500 ATA_SMART_READ_VALUES);
503 static int proc_idedisk_read_st
504 (char *page, char **start, off_t off, int count, int *eof, void *data)
506 return proc_idedisk_read_smart(page, start, off, count, eof, data,
507 ATA_SMART_READ_THRESHOLDS);
510 static ide_proc_entry_t idedisk_proc[] = {
511 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
512 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
513 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
514 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv, NULL },
515 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st, NULL },
516 { NULL, 0, NULL, NULL }
518 #endif /* CONFIG_IDE_PROC_FS */
520 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
522 ide_drive_t *drive = q->queuedata;
523 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
525 /* FIXME: map struct ide_taskfile on rq->cmd[] */
526 BUG_ON(task == NULL);
528 memset(task, 0, sizeof(*task));
529 if (ata_id_flush_ext_enabled(drive->id) &&
530 (drive->capacity64 >= (1UL << 28)))
531 task->tf.command = ATA_CMD_FLUSH_EXT;
533 task->tf.command = ATA_CMD_FLUSH;
534 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
536 task->data_phase = TASKFILE_NO_DATA;
538 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
539 rq->cmd_flags |= REQ_SOFTBARRIER;
543 ide_devset_get(multcount, mult_count);
546 * This is tightly woven into the driver->do_special can not touch.
547 * DON'T do it again until a total personality rewrite is committed.
549 static int set_multcount(ide_drive_t *drive, int arg)
554 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
557 if (drive->special.b.set_multmode)
560 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
561 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
563 drive->mult_req = arg;
564 drive->special.b.set_multmode = 1;
565 error = blk_execute_rq(drive->queue, NULL, rq, 0);
568 return (drive->mult_count == arg) ? 0 : -EIO;
571 ide_devset_get(nowerr, nowerr);
573 static int set_nowerr(ide_drive_t *drive, int arg)
575 if (arg < 0 || arg > 1)
579 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
583 static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)
587 memset(&task, 0, sizeof(task));
588 task.tf.feature = feature;
589 task.tf.nsect = nsect;
590 task.tf.command = ATA_CMD_SET_FEATURES;
591 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
593 return ide_no_data_taskfile(drive, &task);
596 static void update_ordered(ide_drive_t *drive)
599 unsigned ordered = QUEUE_ORDERED_NONE;
600 prepare_flush_fn *prep_fn = NULL;
603 unsigned long long capacity;
606 * We must avoid issuing commands a drive does not
607 * understand or we may crash it. We check flush cache
608 * is supported. We also check we have the LBA48 flush
609 * cache if the drive capacity is too large. By this
610 * time we have trimmed the drive capacity if LBA48 is
611 * not available so we don't need to recheck that.
613 capacity = idedisk_capacity(drive);
614 barrier = ata_id_flush_enabled(id) && !drive->noflush &&
615 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
616 ata_id_flush_ext_enabled(id));
618 printk(KERN_INFO "%s: cache flushes %ssupported\n",
619 drive->name, barrier ? "" : "not ");
622 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
623 prep_fn = idedisk_prepare_flush;
626 ordered = QUEUE_ORDERED_DRAIN;
628 blk_queue_ordered(drive->queue, ordered, prep_fn);
631 ide_devset_get(wcache, wcache);
633 static int set_wcache(ide_drive_t *drive, int arg)
637 if (arg < 0 || arg > 1)
640 if (ata_id_flush_enabled(drive->id)) {
641 err = ide_do_setfeature(drive,
642 arg ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF, 0);
647 update_ordered(drive);
652 static int do_idedisk_flushcache(ide_drive_t *drive)
656 memset(&args, 0, sizeof(ide_task_t));
657 if (ata_id_flush_ext_enabled(drive->id))
658 args.tf.command = ATA_CMD_FLUSH_EXT;
660 args.tf.command = ATA_CMD_FLUSH;
661 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
662 return ide_no_data_taskfile(drive, &args);
665 ide_devset_get(acoustic, acoustic);
667 static int set_acoustic(ide_drive_t *drive, int arg)
669 if (arg < 0 || arg > 254)
672 ide_do_setfeature(drive,
673 arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF, arg);
675 drive->acoustic = arg;
680 ide_devset_get(addressing, addressing);
686 * 2: 48-bit capable doing 28-bit
688 static int set_addressing(ide_drive_t *drive, int arg)
690 if (arg < 0 || arg > 2)
693 if (arg && ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
694 ata_id_lba48_enabled(drive->id) == 0))
700 drive->addressing = arg;
705 ide_devset_rw(acoustic, acoustic);
706 ide_devset_rw(address, addressing);
707 ide_devset_rw(multcount, multcount);
708 ide_devset_rw(wcache, wcache);
710 ide_devset_rw_sync(nowerr, nowerr);
712 #ifdef CONFIG_IDE_PROC_FS
713 ide_devset_rw_field(bios_cyl, bios_cyl);
714 ide_devset_rw_field(bios_head, bios_head);
715 ide_devset_rw_field(bios_sect, bios_sect);
716 ide_devset_rw_field(failures, failures);
717 ide_devset_rw_field(lun, lun);
718 ide_devset_rw_field(max_failures, max_failures);
720 static const struct ide_proc_devset idedisk_settings[] = {
721 IDE_PROC_DEVSET(acoustic, 0, 254),
722 IDE_PROC_DEVSET(address, 0, 2),
723 IDE_PROC_DEVSET(bios_cyl, 0, 65535),
724 IDE_PROC_DEVSET(bios_head, 0, 255),
725 IDE_PROC_DEVSET(bios_sect, 0, 63),
726 IDE_PROC_DEVSET(failures, 0, 65535),
727 IDE_PROC_DEVSET(lun, 0, 7),
728 IDE_PROC_DEVSET(max_failures, 0, 65535),
729 IDE_PROC_DEVSET(multcount, 0, 16),
730 IDE_PROC_DEVSET(nowerr, 0, 1),
731 IDE_PROC_DEVSET(wcache, 0, 1),
736 static void idedisk_setup(ide_drive_t *drive)
738 struct ide_disk_obj *idkp = drive->driver_data;
739 ide_hwif_t *hwif = drive->hwif;
741 char *m = (char *)&id[ATA_ID_PROD];
742 unsigned long long capacity;
744 ide_proc_register_driver(drive, idkp->driver);
746 if (drive->id_read == 0)
749 if (drive->removable) {
751 * Removable disks (eg. SYQUEST); ignore 'WD' drives
753 if (m[0] != 'W' || m[1] != 'D')
754 drive->doorlocking = 1;
757 (void)set_addressing(drive, 1);
759 if (drive->addressing == 1) {
762 if (max_s > hwif->rqsize)
763 max_s = hwif->rqsize;
765 blk_queue_max_sectors(drive->queue, max_s);
768 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
769 drive->queue->max_sectors / 2);
771 /* calculate drive capacity, and select LBA if possible */
772 init_idedisk_capacity(drive);
774 /* limit drive capacity to 137GB if LBA48 cannot be used */
775 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
776 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
777 "%llu sectors (%llu MB)\n",
778 drive->name, (unsigned long long)drive->capacity64,
779 sectors_to_MB(drive->capacity64));
780 drive->capacity64 = 1ULL << 28;
783 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
784 if (drive->capacity64 > 1ULL << 28) {
785 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
786 " will be used for accessing sectors "
787 "> %u\n", drive->name, 1 << 28);
789 drive->addressing = 0;
793 * if possible, give fdisk access to more of the drive,
794 * by correcting bios_cyls:
796 capacity = idedisk_capacity(drive);
798 if (!drive->forced_geom) {
799 if (ata_id_lba48_enabled(drive->id)) {
801 drive->bios_sect = 63;
802 drive->bios_head = 255;
805 if (drive->bios_sect && drive->bios_head) {
806 unsigned int cap0 = capacity; /* truncate to 32 bits */
807 unsigned int cylsz, cyl;
809 if (cap0 != capacity)
810 drive->bios_cyl = 65535;
812 cylsz = drive->bios_sect * drive->bios_head;
816 if (cyl > drive->bios_cyl)
817 drive->bios_cyl = cyl;
821 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
822 drive->name, capacity, sectors_to_MB(capacity));
824 /* Only print cache size when it was specified */
825 if (id[ATA_ID_BUF_SIZE])
826 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
828 printk(KERN_CONT ", CHS=%d/%d/%d\n",
829 drive->bios_cyl, drive->bios_head, drive->bios_sect);
831 /* write cache enabled? */
832 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
835 set_wcache(drive, 1);
838 static void ide_cacheflush_p(ide_drive_t *drive)
840 if (!drive->wcache || ata_id_flush_enabled(drive->id) == 0)
843 if (do_idedisk_flushcache(drive))
844 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
847 static void ide_disk_remove(ide_drive_t *drive)
849 struct ide_disk_obj *idkp = drive->driver_data;
850 struct gendisk *g = idkp->disk;
852 ide_proc_unregister_driver(drive, idkp->driver);
856 ide_cacheflush_p(drive);
861 static void ide_disk_release(struct kref *kref)
863 struct ide_disk_obj *idkp = to_ide_disk(kref);
864 ide_drive_t *drive = idkp->drive;
865 struct gendisk *g = idkp->disk;
867 drive->driver_data = NULL;
868 g->private_data = NULL;
873 static int ide_disk_probe(ide_drive_t *drive);
876 * On HPA drives the capacity needs to be
877 * reinitilized on resume otherwise the disk
878 * can not be used and a hard reset is required
880 static void ide_disk_resume(ide_drive_t *drive)
882 if (ata_id_hpa_enabled(drive->id))
883 init_idedisk_capacity(drive);
886 static void ide_device_shutdown(ide_drive_t *drive)
889 /* On Alpha, halt(8) doesn't actually turn the machine off,
890 it puts you into the sort of firmware monitor. Typically,
891 it's used to boot another kernel image, so it's not much
892 different from reboot(8). Therefore, we don't need to
893 spin down the disk in this case, especially since Alpha
894 firmware doesn't handle disks in standby mode properly.
895 On the other hand, it's reasonably safe to turn the power
896 off when the shutdown process reaches the firmware prompt,
897 as the firmware initialization takes rather long time -
898 at least 10 seconds, which should be sufficient for
899 the disk to expire its write cache. */
900 if (system_state != SYSTEM_POWER_OFF) {
902 if (system_state == SYSTEM_RESTART) {
904 ide_cacheflush_p(drive);
908 printk(KERN_INFO "Shutdown: %s\n", drive->name);
910 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
913 static ide_driver_t idedisk_driver = {
915 .owner = THIS_MODULE,
917 .bus = &ide_bus_type,
919 .probe = ide_disk_probe,
920 .remove = ide_disk_remove,
921 .resume = ide_disk_resume,
922 .shutdown = ide_device_shutdown,
923 .version = IDEDISK_VERSION,
925 .do_request = ide_do_rw_disk,
926 .end_request = ide_end_request,
927 .error = __ide_error,
928 #ifdef CONFIG_IDE_PROC_FS
929 .proc = idedisk_proc,
930 .settings = idedisk_settings,
934 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
938 memset(&task, 0, sizeof(task));
939 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
940 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
942 return ide_no_data_taskfile(drive, &task);
945 static int idedisk_open(struct inode *inode, struct file *filp)
947 struct gendisk *disk = inode->i_bdev->bd_disk;
948 struct ide_disk_obj *idkp;
951 idkp = ide_disk_get(disk);
959 if (drive->removable && idkp->openers == 1) {
960 check_disk_change(inode->i_bdev);
962 * Ignore the return code from door_lock,
963 * since the open() has already succeeded,
964 * and the door_lock is irrelevant at this point.
966 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
967 drive->doorlocking = 0;
972 static int idedisk_release(struct inode *inode, struct file *filp)
974 struct gendisk *disk = inode->i_bdev->bd_disk;
975 struct ide_disk_obj *idkp = ide_disk_g(disk);
976 ide_drive_t *drive = idkp->drive;
978 if (idkp->openers == 1)
979 ide_cacheflush_p(drive);
981 if (drive->removable && idkp->openers == 1) {
982 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
983 drive->doorlocking = 0;
993 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
995 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
996 ide_drive_t *drive = idkp->drive;
998 geo->heads = drive->bios_head;
999 geo->sectors = drive->bios_sect;
1000 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1004 static const struct ide_ioctl_devset ide_disk_ioctl_settings[] = {
1005 { HDIO_GET_ADDRESS, HDIO_SET_ADDRESS, &ide_devset_address },
1006 { HDIO_GET_MULTCOUNT, HDIO_SET_MULTCOUNT, &ide_devset_multcount },
1007 { HDIO_GET_NOWERR, HDIO_SET_NOWERR, &ide_devset_nowerr },
1008 { HDIO_GET_WCACHE, HDIO_SET_WCACHE, &ide_devset_wcache },
1009 { HDIO_GET_ACOUSTIC, HDIO_SET_ACOUSTIC, &ide_devset_acoustic },
1013 static int idedisk_ioctl(struct inode *inode, struct file *file,
1014 unsigned int cmd, unsigned long arg)
1016 struct block_device *bdev = inode->i_bdev;
1017 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1018 ide_drive_t *drive = idkp->drive;
1021 err = ide_setting_ioctl(drive, bdev, cmd, arg, ide_disk_ioctl_settings);
1022 if (err != -EOPNOTSUPP)
1025 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1028 static int idedisk_media_changed(struct gendisk *disk)
1030 struct ide_disk_obj *idkp = ide_disk_g(disk);
1031 ide_drive_t *drive = idkp->drive;
1033 /* do not scan partitions twice if this is a removable device */
1034 if (drive->attach) {
1038 /* if removable, always assume it was changed */
1039 return drive->removable;
1042 static int idedisk_revalidate_disk(struct gendisk *disk)
1044 struct ide_disk_obj *idkp = ide_disk_g(disk);
1045 set_capacity(disk, idedisk_capacity(idkp->drive));
1049 static struct block_device_operations idedisk_ops = {
1050 .owner = THIS_MODULE,
1051 .open = idedisk_open,
1052 .release = idedisk_release,
1053 .ioctl = idedisk_ioctl,
1054 .getgeo = idedisk_getgeo,
1055 .media_changed = idedisk_media_changed,
1056 .revalidate_disk = idedisk_revalidate_disk
1059 MODULE_DESCRIPTION("ATA DISK Driver");
1061 static int ide_disk_probe(ide_drive_t *drive)
1063 struct ide_disk_obj *idkp;
1066 /* strstr("foo", "") is non-NULL */
1067 if (!strstr("ide-disk", drive->driver_req))
1070 if (drive->media != ide_disk)
1073 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1077 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
1081 ide_init_disk(g, drive);
1083 kref_init(&idkp->kref);
1085 idkp->drive = drive;
1086 idkp->driver = &idedisk_driver;
1089 g->private_data = &idkp->driver;
1091 drive->driver_data = idkp;
1093 idedisk_setup(drive);
1094 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1095 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1096 drive->name, drive->head);
1101 g->minors = IDE_DISK_MINORS;
1102 g->driverfs_dev = &drive->gendev;
1103 g->flags |= GENHD_FL_EXT_DEVT;
1104 if (drive->removable)
1105 g->flags |= GENHD_FL_REMOVABLE;
1106 set_capacity(g, idedisk_capacity(drive));
1107 g->fops = &idedisk_ops;
1117 static void __exit idedisk_exit(void)
1119 driver_unregister(&idedisk_driver.gen_driver);
1122 static int __init idedisk_init(void)
1124 return driver_register(&idedisk_driver.gen_driver);
1127 MODULE_ALIAS("ide:*m-disk*");
1128 module_init(idedisk_init);
1129 module_exit(idedisk_exit);
1130 MODULE_LICENSE("GPL");