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 u16 nsectors = (u16)rq->nr_sectors;
144 u8 lba48 = !!(drive->dev_flags & IDE_DFLAG_LBA48);
145 u8 dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
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->dev_flags & IDE_DFLAG_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 tf->device |= ATA_LBA;
193 unsigned int sect, head, cyl, track;
195 track = (int)block / drive->sect;
196 sect = (int)block % drive->sect + 1;
197 head = track % drive->head;
198 cyl = track / drive->head;
200 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
202 tf->nsect = nsectors & 0xff;
210 task.tf_flags |= IDE_TFLAG_WRITE;
212 ide_tf_set_cmd(drive, &task, dma);
214 hwif->data_phase = task.data_phase;
217 rc = do_rw_taskfile(drive, &task);
219 if (rc == ide_stopped && dma) {
220 /* fallback to PIO */
221 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
222 ide_tf_set_cmd(drive, &task, 0);
223 hwif->data_phase = task.data_phase;
224 ide_init_sg_cmd(drive, rq);
225 rc = do_rw_taskfile(drive, &task);
232 * 268435455 == 137439 MB or 28bit limit
233 * 320173056 == 163929 MB or 48bit addressing
234 * 1073741822 == 549756 MB or 48bit addressing fake drive
237 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
240 ide_hwif_t *hwif = HWIF(drive);
242 BUG_ON(drive->dev_flags & IDE_DFLAG_BLOCKED);
244 if (!blk_fs_request(rq)) {
245 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
246 ide_end_request(drive, 0, 0);
250 ledtrig_ide_activity();
252 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
253 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
254 (unsigned long long)block, rq->nr_sectors,
255 (unsigned long)rq->buffer);
258 hwif->rw_disk(drive, rq);
260 return __ide_do_rw_disk(drive, rq, block);
264 * Queries for true maximum capacity of the drive.
265 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
267 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
270 struct ide_taskfile *tf = &args.tf;
273 /* Create IDE/ATA command request structure */
274 memset(&args, 0, sizeof(ide_task_t));
276 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
278 tf->command = ATA_CMD_READ_NATIVE_MAX;
279 tf->device = ATA_LBA;
280 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
282 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
283 /* submit command request */
284 ide_no_data_taskfile(drive, &args);
286 /* if OK, compute maximum address value */
287 if ((tf->status & 0x01) == 0)
288 addr = ide_get_lba_addr(tf, lba48) + 1;
294 * Sets maximum virtual LBA address of the drive.
295 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
297 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
300 struct ide_taskfile *tf = &args.tf;
304 /* Create IDE/ATA command request structure */
305 memset(&args, 0, sizeof(ide_task_t));
306 tf->lbal = (addr_req >> 0) & 0xff;
307 tf->lbam = (addr_req >>= 8) & 0xff;
308 tf->lbah = (addr_req >>= 8) & 0xff;
310 tf->hob_lbal = (addr_req >>= 8) & 0xff;
311 tf->hob_lbam = (addr_req >>= 8) & 0xff;
312 tf->hob_lbah = (addr_req >>= 8) & 0xff;
313 tf->command = ATA_CMD_SET_MAX_EXT;
315 tf->device = (addr_req >>= 8) & 0x0f;
316 tf->command = ATA_CMD_SET_MAX;
318 tf->device |= ATA_LBA;
319 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
321 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
322 /* submit command request */
323 ide_no_data_taskfile(drive, &args);
324 /* if OK, compute maximum address value */
325 if ((tf->status & 0x01) == 0)
326 addr_set = ide_get_lba_addr(tf, lba48) + 1;
331 static unsigned long long sectors_to_MB(unsigned long long n)
333 n <<= 9; /* make it bytes */
334 do_div(n, 1000000); /* make it MB */
339 * Some disks report total number of sectors instead of
340 * maximum sector address. We list them here.
342 static const struct drive_list_entry hpa_list[] = {
343 { "ST340823A", NULL },
344 { "ST320413A", NULL },
345 { "ST310211A", NULL },
349 static void idedisk_check_hpa(ide_drive_t *drive)
351 unsigned long long capacity, set_max;
352 int lba48 = ata_id_lba48_enabled(drive->id);
354 capacity = drive->capacity64;
356 set_max = idedisk_read_native_max_address(drive, lba48);
358 if (ide_in_drive_list(drive->id, hpa_list)) {
360 * Since we are inclusive wrt to firmware revisions do this
361 * extra check and apply the workaround only when needed.
363 if (set_max == capacity + 1)
367 if (set_max <= capacity)
370 printk(KERN_INFO "%s: Host Protected Area detected.\n"
371 "\tcurrent capacity is %llu sectors (%llu MB)\n"
372 "\tnative capacity is %llu sectors (%llu MB)\n",
374 capacity, sectors_to_MB(capacity),
375 set_max, sectors_to_MB(set_max));
377 set_max = idedisk_set_max_address(drive, set_max, lba48);
380 drive->capacity64 = set_max;
381 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
386 static void init_idedisk_capacity(ide_drive_t *drive)
391 if (ata_id_lba48_enabled(id)) {
392 /* drive speaks 48-bit LBA */
394 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
395 } else if (ata_id_has_lba(id) && ata_id_is_lba_capacity_ok(id)) {
396 /* drive speaks 28-bit LBA */
398 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
400 /* drive speaks boring old 28-bit CHS */
402 drive->capacity64 = drive->cyl * drive->head * drive->sect;
406 drive->dev_flags |= IDE_DFLAG_LBA;
409 * If this device supports the Host Protected Area feature set,
410 * then we may need to change our opinion about its capacity.
412 if (ata_id_hpa_enabled(id))
413 idedisk_check_hpa(drive);
417 static sector_t idedisk_capacity(ide_drive_t *drive)
419 return drive->capacity64;
422 #ifdef CONFIG_IDE_PROC_FS
423 static int smart_enable(ide_drive_t *drive)
426 struct ide_taskfile *tf = &args.tf;
428 memset(&args, 0, sizeof(ide_task_t));
429 tf->feature = ATA_SMART_ENABLE;
430 tf->lbam = ATA_SMART_LBAM_PASS;
431 tf->lbah = ATA_SMART_LBAH_PASS;
432 tf->command = ATA_CMD_SMART;
433 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
434 return ide_no_data_taskfile(drive, &args);
437 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
440 struct ide_taskfile *tf = &args.tf;
442 memset(&args, 0, sizeof(ide_task_t));
443 tf->feature = sub_cmd;
445 tf->lbam = ATA_SMART_LBAM_PASS;
446 tf->lbah = ATA_SMART_LBAH_PASS;
447 tf->command = ATA_CMD_SMART;
448 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
449 args.data_phase = TASKFILE_IN;
450 (void) smart_enable(drive);
451 return ide_raw_taskfile(drive, &args, buf, 1);
454 static int proc_idedisk_read_cache
455 (char *page, char **start, off_t off, int count, int *eof, void *data)
457 ide_drive_t *drive = (ide_drive_t *) data;
461 if (drive->dev_flags & IDE_DFLAG_ID_READ)
462 len = sprintf(out, "%i\n", drive->id[ATA_ID_BUF_SIZE] / 2);
464 len = sprintf(out, "(none)\n");
466 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
469 static int proc_idedisk_read_capacity
470 (char *page, char **start, off_t off, int count, int *eof, void *data)
472 ide_drive_t*drive = (ide_drive_t *)data;
475 len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
477 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
480 static int proc_idedisk_read_smart(char *page, char **start, off_t off,
481 int count, int *eof, void *data, u8 sub_cmd)
483 ide_drive_t *drive = (ide_drive_t *)data;
486 if (get_smart_data(drive, page, sub_cmd) == 0) {
487 unsigned short *val = (unsigned short *) page;
488 char *out = (char *)val + SECTOR_SIZE;
492 out += sprintf(out, "%04x%c", le16_to_cpu(*val),
493 (++i & 7) ? ' ' : '\n');
495 } while (i < SECTOR_SIZE / 2);
499 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
502 static int proc_idedisk_read_sv
503 (char *page, char **start, off_t off, int count, int *eof, void *data)
505 return proc_idedisk_read_smart(page, start, off, count, eof, data,
506 ATA_SMART_READ_VALUES);
509 static int proc_idedisk_read_st
510 (char *page, char **start, off_t off, int count, int *eof, void *data)
512 return proc_idedisk_read_smart(page, start, off, count, eof, data,
513 ATA_SMART_READ_THRESHOLDS);
516 static ide_proc_entry_t idedisk_proc[] = {
517 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
518 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
519 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
520 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv, NULL },
521 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st, NULL },
522 { NULL, 0, NULL, NULL }
524 #endif /* CONFIG_IDE_PROC_FS */
526 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
528 ide_drive_t *drive = q->queuedata;
529 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
531 /* FIXME: map struct ide_taskfile on rq->cmd[] */
532 BUG_ON(task == NULL);
534 memset(task, 0, sizeof(*task));
535 if (ata_id_flush_ext_enabled(drive->id) &&
536 (drive->capacity64 >= (1UL << 28)))
537 task->tf.command = ATA_CMD_FLUSH_EXT;
539 task->tf.command = ATA_CMD_FLUSH;
540 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
542 task->data_phase = TASKFILE_NO_DATA;
544 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
545 rq->cmd_flags |= REQ_SOFTBARRIER;
549 ide_devset_get(multcount, mult_count);
552 * This is tightly woven into the driver->do_special can not touch.
553 * DON'T do it again until a total personality rewrite is committed.
555 static int set_multcount(ide_drive_t *drive, int arg)
560 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
563 if (drive->special.b.set_multmode)
566 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
567 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
569 drive->mult_req = arg;
570 drive->special.b.set_multmode = 1;
571 error = blk_execute_rq(drive->queue, NULL, rq, 0);
574 return (drive->mult_count == arg) ? 0 : -EIO;
577 ide_devset_get_flag(nowerr, IDE_DFLAG_NOWERR);
579 static int set_nowerr(ide_drive_t *drive, int arg)
581 if (arg < 0 || arg > 1)
585 drive->dev_flags |= IDE_DFLAG_NOWERR;
587 drive->dev_flags &= ~IDE_DFLAG_NOWERR;
589 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
594 static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)
598 memset(&task, 0, sizeof(task));
599 task.tf.feature = feature;
600 task.tf.nsect = nsect;
601 task.tf.command = ATA_CMD_SET_FEATURES;
602 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
604 return ide_no_data_taskfile(drive, &task);
607 static void update_ordered(ide_drive_t *drive)
610 unsigned ordered = QUEUE_ORDERED_NONE;
611 prepare_flush_fn *prep_fn = NULL;
613 if (drive->dev_flags & IDE_DFLAG_WCACHE) {
614 unsigned long long capacity;
617 * We must avoid issuing commands a drive does not
618 * understand or we may crash it. We check flush cache
619 * is supported. We also check we have the LBA48 flush
620 * cache if the drive capacity is too large. By this
621 * time we have trimmed the drive capacity if LBA48 is
622 * not available so we don't need to recheck that.
624 capacity = idedisk_capacity(drive);
625 barrier = ata_id_flush_enabled(id) &&
626 (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 &&
627 ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 ||
628 capacity <= (1ULL << 28) ||
629 ata_id_flush_ext_enabled(id));
631 printk(KERN_INFO "%s: cache flushes %ssupported\n",
632 drive->name, barrier ? "" : "not ");
635 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
636 prep_fn = idedisk_prepare_flush;
639 ordered = QUEUE_ORDERED_DRAIN;
641 blk_queue_ordered(drive->queue, ordered, prep_fn);
644 ide_devset_get_flag(wcache, IDE_DFLAG_WCACHE);
646 static int set_wcache(ide_drive_t *drive, int arg)
650 if (arg < 0 || arg > 1)
653 if (ata_id_flush_enabled(drive->id)) {
654 err = ide_do_setfeature(drive,
655 arg ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF, 0);
658 drive->dev_flags |= IDE_DFLAG_WCACHE;
660 drive->dev_flags &= ~IDE_DFLAG_WCACHE;
664 update_ordered(drive);
669 static int do_idedisk_flushcache(ide_drive_t *drive)
673 memset(&args, 0, sizeof(ide_task_t));
674 if (ata_id_flush_ext_enabled(drive->id))
675 args.tf.command = ATA_CMD_FLUSH_EXT;
677 args.tf.command = ATA_CMD_FLUSH;
678 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
679 return ide_no_data_taskfile(drive, &args);
682 ide_devset_get(acoustic, acoustic);
684 static int set_acoustic(ide_drive_t *drive, int arg)
686 if (arg < 0 || arg > 254)
689 ide_do_setfeature(drive,
690 arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF, arg);
692 drive->acoustic = arg;
697 ide_devset_get_flag(addressing, IDE_DFLAG_LBA48);
703 * 2: 48-bit capable doing 28-bit
705 static int set_addressing(ide_drive_t *drive, int arg)
707 if (arg < 0 || arg > 2)
710 if (arg && ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
711 ata_id_lba48_enabled(drive->id) == 0))
718 drive->dev_flags |= IDE_DFLAG_LBA48;
720 drive->dev_flags &= ~IDE_DFLAG_LBA48;
725 ide_devset_rw(acoustic, acoustic);
726 ide_devset_rw(address, addressing);
727 ide_devset_rw(multcount, multcount);
728 ide_devset_rw(wcache, wcache);
730 ide_devset_rw_sync(nowerr, nowerr);
732 #ifdef CONFIG_IDE_PROC_FS
733 ide_devset_rw_field(bios_cyl, bios_cyl);
734 ide_devset_rw_field(bios_head, bios_head);
735 ide_devset_rw_field(bios_sect, bios_sect);
736 ide_devset_rw_field(failures, failures);
737 ide_devset_rw_field(lun, lun);
738 ide_devset_rw_field(max_failures, max_failures);
740 static const struct ide_proc_devset idedisk_settings[] = {
741 IDE_PROC_DEVSET(acoustic, 0, 254),
742 IDE_PROC_DEVSET(address, 0, 2),
743 IDE_PROC_DEVSET(bios_cyl, 0, 65535),
744 IDE_PROC_DEVSET(bios_head, 0, 255),
745 IDE_PROC_DEVSET(bios_sect, 0, 63),
746 IDE_PROC_DEVSET(failures, 0, 65535),
747 IDE_PROC_DEVSET(lun, 0, 7),
748 IDE_PROC_DEVSET(max_failures, 0, 65535),
749 IDE_PROC_DEVSET(multcount, 0, 16),
750 IDE_PROC_DEVSET(nowerr, 0, 1),
751 IDE_PROC_DEVSET(wcache, 0, 1),
756 static void idedisk_setup(ide_drive_t *drive)
758 struct ide_disk_obj *idkp = drive->driver_data;
759 ide_hwif_t *hwif = drive->hwif;
761 char *m = (char *)&id[ATA_ID_PROD];
762 unsigned long long capacity;
764 ide_proc_register_driver(drive, idkp->driver);
766 if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0)
769 if (drive->dev_flags & IDE_DFLAG_REMOVABLE) {
771 * Removable disks (eg. SYQUEST); ignore 'WD' drives
773 if (m[0] != 'W' || m[1] != 'D')
774 drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
777 (void)set_addressing(drive, 1);
779 if (drive->dev_flags & IDE_DFLAG_LBA48) {
782 if (max_s > hwif->rqsize)
783 max_s = hwif->rqsize;
785 blk_queue_max_sectors(drive->queue, max_s);
788 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
789 drive->queue->max_sectors / 2);
791 /* calculate drive capacity, and select LBA if possible */
792 init_idedisk_capacity(drive);
794 /* limit drive capacity to 137GB if LBA48 cannot be used */
795 if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
796 drive->capacity64 > 1ULL << 28) {
797 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
798 "%llu sectors (%llu MB)\n",
799 drive->name, (unsigned long long)drive->capacity64,
800 sectors_to_MB(drive->capacity64));
801 drive->capacity64 = 1ULL << 28;
804 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
805 (drive->dev_flags & IDE_DFLAG_LBA48)) {
806 if (drive->capacity64 > 1ULL << 28) {
807 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
808 " will be used for accessing sectors "
809 "> %u\n", drive->name, 1 << 28);
811 drive->dev_flags &= ~IDE_DFLAG_LBA48;
815 * if possible, give fdisk access to more of the drive,
816 * by correcting bios_cyls:
818 capacity = idedisk_capacity(drive);
820 if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) {
821 if (ata_id_lba48_enabled(drive->id)) {
823 drive->bios_sect = 63;
824 drive->bios_head = 255;
827 if (drive->bios_sect && drive->bios_head) {
828 unsigned int cap0 = capacity; /* truncate to 32 bits */
829 unsigned int cylsz, cyl;
831 if (cap0 != capacity)
832 drive->bios_cyl = 65535;
834 cylsz = drive->bios_sect * drive->bios_head;
838 if (cyl > drive->bios_cyl)
839 drive->bios_cyl = cyl;
843 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
844 drive->name, capacity, sectors_to_MB(capacity));
846 /* Only print cache size when it was specified */
847 if (id[ATA_ID_BUF_SIZE])
848 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
850 printk(KERN_CONT ", CHS=%d/%d/%d\n",
851 drive->bios_cyl, drive->bios_head, drive->bios_sect);
853 /* write cache enabled? */
854 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
855 drive->dev_flags |= IDE_DFLAG_WCACHE;
857 set_wcache(drive, 1);
860 static void ide_cacheflush_p(ide_drive_t *drive)
862 if (ata_id_flush_enabled(drive->id) == 0 ||
863 (drive->dev_flags & IDE_DFLAG_WCACHE) == 0)
866 if (do_idedisk_flushcache(drive))
867 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
870 static void ide_disk_remove(ide_drive_t *drive)
872 struct ide_disk_obj *idkp = drive->driver_data;
873 struct gendisk *g = idkp->disk;
875 ide_proc_unregister_driver(drive, idkp->driver);
879 ide_cacheflush_p(drive);
884 static void ide_disk_release(struct kref *kref)
886 struct ide_disk_obj *idkp = to_ide_disk(kref);
887 ide_drive_t *drive = idkp->drive;
888 struct gendisk *g = idkp->disk;
890 drive->driver_data = NULL;
891 g->private_data = NULL;
896 static int ide_disk_probe(ide_drive_t *drive);
899 * On HPA drives the capacity needs to be
900 * reinitilized on resume otherwise the disk
901 * can not be used and a hard reset is required
903 static void ide_disk_resume(ide_drive_t *drive)
905 if (ata_id_hpa_enabled(drive->id))
906 init_idedisk_capacity(drive);
909 static void ide_device_shutdown(ide_drive_t *drive)
912 /* On Alpha, halt(8) doesn't actually turn the machine off,
913 it puts you into the sort of firmware monitor. Typically,
914 it's used to boot another kernel image, so it's not much
915 different from reboot(8). Therefore, we don't need to
916 spin down the disk in this case, especially since Alpha
917 firmware doesn't handle disks in standby mode properly.
918 On the other hand, it's reasonably safe to turn the power
919 off when the shutdown process reaches the firmware prompt,
920 as the firmware initialization takes rather long time -
921 at least 10 seconds, which should be sufficient for
922 the disk to expire its write cache. */
923 if (system_state != SYSTEM_POWER_OFF) {
925 if (system_state == SYSTEM_RESTART) {
927 ide_cacheflush_p(drive);
931 printk(KERN_INFO "Shutdown: %s\n", drive->name);
933 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
936 static ide_driver_t idedisk_driver = {
938 .owner = THIS_MODULE,
940 .bus = &ide_bus_type,
942 .probe = ide_disk_probe,
943 .remove = ide_disk_remove,
944 .resume = ide_disk_resume,
945 .shutdown = ide_device_shutdown,
946 .version = IDEDISK_VERSION,
947 .do_request = ide_do_rw_disk,
948 .end_request = ide_end_request,
949 .error = __ide_error,
950 #ifdef CONFIG_IDE_PROC_FS
951 .proc = idedisk_proc,
952 .settings = idedisk_settings,
956 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
960 memset(&task, 0, sizeof(task));
961 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
962 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
964 return ide_no_data_taskfile(drive, &task);
967 static int idedisk_open(struct inode *inode, struct file *filp)
969 struct gendisk *disk = inode->i_bdev->bd_disk;
970 struct ide_disk_obj *idkp;
973 idkp = ide_disk_get(disk);
981 if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
982 check_disk_change(inode->i_bdev);
984 * Ignore the return code from door_lock,
985 * since the open() has already succeeded,
986 * and the door_lock is irrelevant at this point.
988 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
989 idedisk_set_doorlock(drive, 1))
990 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
995 static int idedisk_release(struct inode *inode, struct file *filp)
997 struct gendisk *disk = inode->i_bdev->bd_disk;
998 struct ide_disk_obj *idkp = ide_disk_g(disk);
999 ide_drive_t *drive = idkp->drive;
1001 if (idkp->openers == 1)
1002 ide_cacheflush_p(drive);
1004 if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
1005 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
1006 idedisk_set_doorlock(drive, 0))
1007 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
1017 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1019 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1020 ide_drive_t *drive = idkp->drive;
1022 geo->heads = drive->bios_head;
1023 geo->sectors = drive->bios_sect;
1024 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1028 static const struct ide_ioctl_devset ide_disk_ioctl_settings[] = {
1029 { HDIO_GET_ADDRESS, HDIO_SET_ADDRESS, &ide_devset_address },
1030 { HDIO_GET_MULTCOUNT, HDIO_SET_MULTCOUNT, &ide_devset_multcount },
1031 { HDIO_GET_NOWERR, HDIO_SET_NOWERR, &ide_devset_nowerr },
1032 { HDIO_GET_WCACHE, HDIO_SET_WCACHE, &ide_devset_wcache },
1033 { HDIO_GET_ACOUSTIC, HDIO_SET_ACOUSTIC, &ide_devset_acoustic },
1037 static int idedisk_ioctl(struct inode *inode, struct file *file,
1038 unsigned int cmd, unsigned long arg)
1040 struct block_device *bdev = inode->i_bdev;
1041 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1042 ide_drive_t *drive = idkp->drive;
1045 err = ide_setting_ioctl(drive, bdev, cmd, arg, ide_disk_ioctl_settings);
1046 if (err != -EOPNOTSUPP)
1049 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1052 static int idedisk_media_changed(struct gendisk *disk)
1054 struct ide_disk_obj *idkp = ide_disk_g(disk);
1055 ide_drive_t *drive = idkp->drive;
1057 /* do not scan partitions twice if this is a removable device */
1058 if (drive->dev_flags & IDE_DFLAG_ATTACH) {
1059 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
1063 /* if removable, always assume it was changed */
1064 return !!(drive->dev_flags & IDE_DFLAG_REMOVABLE);
1067 static int idedisk_revalidate_disk(struct gendisk *disk)
1069 struct ide_disk_obj *idkp = ide_disk_g(disk);
1070 set_capacity(disk, idedisk_capacity(idkp->drive));
1074 static struct block_device_operations idedisk_ops = {
1075 .owner = THIS_MODULE,
1076 .open = idedisk_open,
1077 .release = idedisk_release,
1078 .ioctl = idedisk_ioctl,
1079 .getgeo = idedisk_getgeo,
1080 .media_changed = idedisk_media_changed,
1081 .revalidate_disk = idedisk_revalidate_disk
1084 MODULE_DESCRIPTION("ATA DISK Driver");
1086 static int ide_disk_probe(ide_drive_t *drive)
1088 struct ide_disk_obj *idkp;
1091 /* strstr("foo", "") is non-NULL */
1092 if (!strstr("ide-disk", drive->driver_req))
1095 if (drive->media != ide_disk)
1098 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1102 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
1106 ide_init_disk(g, drive);
1108 kref_init(&idkp->kref);
1110 idkp->drive = drive;
1111 idkp->driver = &idedisk_driver;
1114 g->private_data = &idkp->driver;
1116 drive->driver_data = idkp;
1118 idedisk_setup(drive);
1119 if ((drive->dev_flags & IDE_DFLAG_LBA) == 0 &&
1120 (drive->head == 0 || drive->head > 16)) {
1121 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1122 drive->name, drive->head);
1123 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
1125 drive->dev_flags |= IDE_DFLAG_ATTACH;
1127 g->minors = IDE_DISK_MINORS;
1128 g->driverfs_dev = &drive->gendev;
1129 g->flags |= GENHD_FL_EXT_DEVT;
1130 if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
1131 g->flags = GENHD_FL_REMOVABLE;
1132 set_capacity(g, idedisk_capacity(drive));
1133 g->fops = &idedisk_ops;
1143 static void __exit idedisk_exit(void)
1145 driver_unregister(&idedisk_driver.gen_driver);
1148 static int __init idedisk_init(void)
1150 return driver_register(&idedisk_driver.gen_driver);
1153 MODULE_ALIAS("ide:*m-disk*");
1154 module_init(idedisk_init);
1155 module_exit(idedisk_exit);
1156 MODULE_LICENSE("GPL");