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 void update_ordered(ide_drive_t *drive)
586 unsigned ordered = QUEUE_ORDERED_NONE;
587 prepare_flush_fn *prep_fn = NULL;
590 unsigned long long capacity;
593 * We must avoid issuing commands a drive does not
594 * understand or we may crash it. We check flush cache
595 * is supported. We also check we have the LBA48 flush
596 * cache if the drive capacity is too large. By this
597 * time we have trimmed the drive capacity if LBA48 is
598 * not available so we don't need to recheck that.
600 capacity = idedisk_capacity(drive);
601 barrier = ata_id_flush_enabled(id) && !drive->noflush &&
602 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
603 ata_id_flush_ext_enabled(id));
605 printk(KERN_INFO "%s: cache flushes %ssupported\n",
606 drive->name, barrier ? "" : "not ");
609 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
610 prep_fn = idedisk_prepare_flush;
613 ordered = QUEUE_ORDERED_DRAIN;
615 blk_queue_ordered(drive->queue, ordered, prep_fn);
618 ide_devset_get(wcache, wcache);
620 static int set_wcache(ide_drive_t *drive, int arg)
625 if (arg < 0 || arg > 1)
628 if (ata_id_flush_enabled(drive->id)) {
629 memset(&args, 0, sizeof(ide_task_t));
630 args.tf.feature = arg ?
631 SETFEATURES_WC_ON : SETFEATURES_WC_OFF;
632 args.tf.command = ATA_CMD_SET_FEATURES;
633 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
634 err = ide_no_data_taskfile(drive, &args);
639 update_ordered(drive);
644 static int do_idedisk_flushcache(ide_drive_t *drive)
648 memset(&args, 0, sizeof(ide_task_t));
649 if (ata_id_flush_ext_enabled(drive->id))
650 args.tf.command = ATA_CMD_FLUSH_EXT;
652 args.tf.command = ATA_CMD_FLUSH;
653 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
654 return ide_no_data_taskfile(drive, &args);
657 ide_devset_get(acoustic, acoustic);
659 static int set_acoustic(ide_drive_t *drive, int arg)
663 if (arg < 0 || arg > 254)
666 memset(&args, 0, sizeof(ide_task_t));
667 args.tf.feature = arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF;
669 args.tf.command = ATA_CMD_SET_FEATURES;
670 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
671 ide_no_data_taskfile(drive, &args);
672 drive->acoustic = arg;
676 ide_devset_get(addressing, addressing);
682 * 2: 48-bit capable doing 28-bit
684 static int set_addressing(ide_drive_t *drive, int arg)
686 if (arg < 0 || arg > 2)
689 if (arg && ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
690 ata_id_lba48_enabled(drive->id) == 0))
696 drive->addressing = arg;
701 ide_devset_rw(acoustic, acoustic);
702 ide_devset_rw(address, addressing);
703 ide_devset_rw(multcount, multcount);
704 ide_devset_rw(wcache, wcache);
706 ide_devset_rw_sync(nowerr, nowerr);
708 #ifdef CONFIG_IDE_PROC_FS
709 ide_devset_rw_field(bios_cyl, bios_cyl);
710 ide_devset_rw_field(bios_head, bios_head);
711 ide_devset_rw_field(bios_sect, bios_sect);
712 ide_devset_rw_field(failures, failures);
713 ide_devset_rw_field(lun, lun);
714 ide_devset_rw_field(max_failures, max_failures);
716 static const struct ide_proc_devset idedisk_settings[] = {
717 IDE_PROC_DEVSET(acoustic, 0, 254),
718 IDE_PROC_DEVSET(address, 0, 2),
719 IDE_PROC_DEVSET(bios_cyl, 0, 65535),
720 IDE_PROC_DEVSET(bios_head, 0, 255),
721 IDE_PROC_DEVSET(bios_sect, 0, 63),
722 IDE_PROC_DEVSET(failures, 0, 65535),
723 IDE_PROC_DEVSET(lun, 0, 7),
724 IDE_PROC_DEVSET(max_failures, 0, 65535),
725 IDE_PROC_DEVSET(multcount, 0, 16),
726 IDE_PROC_DEVSET(nowerr, 0, 1),
727 IDE_PROC_DEVSET(wcache, 0, 1),
732 static void idedisk_setup(ide_drive_t *drive)
734 struct ide_disk_obj *idkp = drive->driver_data;
735 ide_hwif_t *hwif = drive->hwif;
737 char *m = (char *)&id[ATA_ID_PROD];
738 unsigned long long capacity;
740 ide_proc_register_driver(drive, idkp->driver);
742 if (drive->id_read == 0)
745 if (drive->removable) {
747 * Removable disks (eg. SYQUEST); ignore 'WD' drives
749 if (m[0] != 'W' || m[1] != 'D')
750 drive->doorlocking = 1;
753 (void)set_addressing(drive, 1);
755 if (drive->addressing == 1) {
758 if (max_s > hwif->rqsize)
759 max_s = hwif->rqsize;
761 blk_queue_max_sectors(drive->queue, max_s);
764 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
765 drive->queue->max_sectors / 2);
767 /* calculate drive capacity, and select LBA if possible */
768 init_idedisk_capacity(drive);
770 /* limit drive capacity to 137GB if LBA48 cannot be used */
771 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
772 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
773 "%llu sectors (%llu MB)\n",
774 drive->name, (unsigned long long)drive->capacity64,
775 sectors_to_MB(drive->capacity64));
776 drive->capacity64 = 1ULL << 28;
779 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
780 if (drive->capacity64 > 1ULL << 28) {
781 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
782 " will be used for accessing sectors "
783 "> %u\n", drive->name, 1 << 28);
785 drive->addressing = 0;
789 * if possible, give fdisk access to more of the drive,
790 * by correcting bios_cyls:
792 capacity = idedisk_capacity(drive);
794 if (!drive->forced_geom) {
795 if (ata_id_lba48_enabled(drive->id)) {
797 drive->bios_sect = 63;
798 drive->bios_head = 255;
801 if (drive->bios_sect && drive->bios_head) {
802 unsigned int cap0 = capacity; /* truncate to 32 bits */
803 unsigned int cylsz, cyl;
805 if (cap0 != capacity)
806 drive->bios_cyl = 65535;
808 cylsz = drive->bios_sect * drive->bios_head;
812 if (cyl > drive->bios_cyl)
813 drive->bios_cyl = cyl;
817 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
818 drive->name, capacity, sectors_to_MB(capacity));
820 /* Only print cache size when it was specified */
821 if (id[ATA_ID_BUF_SIZE])
822 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
824 printk(KERN_CONT ", CHS=%d/%d/%d\n",
825 drive->bios_cyl, drive->bios_head, drive->bios_sect);
827 /* write cache enabled? */
828 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
831 set_wcache(drive, 1);
834 static void ide_cacheflush_p(ide_drive_t *drive)
836 if (!drive->wcache || ata_id_flush_enabled(drive->id) == 0)
839 if (do_idedisk_flushcache(drive))
840 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
843 static void ide_disk_remove(ide_drive_t *drive)
845 struct ide_disk_obj *idkp = drive->driver_data;
846 struct gendisk *g = idkp->disk;
848 ide_proc_unregister_driver(drive, idkp->driver);
852 ide_cacheflush_p(drive);
857 static void ide_disk_release(struct kref *kref)
859 struct ide_disk_obj *idkp = to_ide_disk(kref);
860 ide_drive_t *drive = idkp->drive;
861 struct gendisk *g = idkp->disk;
863 drive->driver_data = NULL;
864 g->private_data = NULL;
869 static int ide_disk_probe(ide_drive_t *drive);
872 * On HPA drives the capacity needs to be
873 * reinitilized on resume otherwise the disk
874 * can not be used and a hard reset is required
876 static void ide_disk_resume(ide_drive_t *drive)
878 if (ata_id_hpa_enabled(drive->id))
879 init_idedisk_capacity(drive);
882 static void ide_device_shutdown(ide_drive_t *drive)
885 /* On Alpha, halt(8) doesn't actually turn the machine off,
886 it puts you into the sort of firmware monitor. Typically,
887 it's used to boot another kernel image, so it's not much
888 different from reboot(8). Therefore, we don't need to
889 spin down the disk in this case, especially since Alpha
890 firmware doesn't handle disks in standby mode properly.
891 On the other hand, it's reasonably safe to turn the power
892 off when the shutdown process reaches the firmware prompt,
893 as the firmware initialization takes rather long time -
894 at least 10 seconds, which should be sufficient for
895 the disk to expire its write cache. */
896 if (system_state != SYSTEM_POWER_OFF) {
898 if (system_state == SYSTEM_RESTART) {
900 ide_cacheflush_p(drive);
904 printk(KERN_INFO "Shutdown: %s\n", drive->name);
906 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
909 static ide_driver_t idedisk_driver = {
911 .owner = THIS_MODULE,
913 .bus = &ide_bus_type,
915 .probe = ide_disk_probe,
916 .remove = ide_disk_remove,
917 .resume = ide_disk_resume,
918 .shutdown = ide_device_shutdown,
919 .version = IDEDISK_VERSION,
921 .do_request = ide_do_rw_disk,
922 .end_request = ide_end_request,
923 .error = __ide_error,
924 #ifdef CONFIG_IDE_PROC_FS
925 .proc = idedisk_proc,
926 .settings = idedisk_settings,
930 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
934 memset(&task, 0, sizeof(task));
935 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
936 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
938 return ide_no_data_taskfile(drive, &task);
941 static int idedisk_open(struct inode *inode, struct file *filp)
943 struct gendisk *disk = inode->i_bdev->bd_disk;
944 struct ide_disk_obj *idkp;
947 idkp = ide_disk_get(disk);
955 if (drive->removable && idkp->openers == 1) {
956 check_disk_change(inode->i_bdev);
958 * Ignore the return code from door_lock,
959 * since the open() has already succeeded,
960 * and the door_lock is irrelevant at this point.
962 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
963 drive->doorlocking = 0;
968 static int idedisk_release(struct inode *inode, struct file *filp)
970 struct gendisk *disk = inode->i_bdev->bd_disk;
971 struct ide_disk_obj *idkp = ide_disk_g(disk);
972 ide_drive_t *drive = idkp->drive;
974 if (idkp->openers == 1)
975 ide_cacheflush_p(drive);
977 if (drive->removable && idkp->openers == 1) {
978 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
979 drive->doorlocking = 0;
989 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
991 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
992 ide_drive_t *drive = idkp->drive;
994 geo->heads = drive->bios_head;
995 geo->sectors = drive->bios_sect;
996 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1000 static const struct ide_ioctl_devset ide_disk_ioctl_settings[] = {
1001 { HDIO_GET_ADDRESS, HDIO_SET_ADDRESS, &ide_devset_address },
1002 { HDIO_GET_MULTCOUNT, HDIO_SET_MULTCOUNT, &ide_devset_multcount },
1003 { HDIO_GET_NOWERR, HDIO_SET_NOWERR, &ide_devset_nowerr },
1004 { HDIO_GET_WCACHE, HDIO_SET_WCACHE, &ide_devset_wcache },
1005 { HDIO_GET_ACOUSTIC, HDIO_SET_ACOUSTIC, &ide_devset_acoustic },
1009 static int idedisk_ioctl(struct inode *inode, struct file *file,
1010 unsigned int cmd, unsigned long arg)
1012 struct block_device *bdev = inode->i_bdev;
1013 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1014 ide_drive_t *drive = idkp->drive;
1017 err = ide_setting_ioctl(drive, bdev, cmd, arg, ide_disk_ioctl_settings);
1018 if (err != -EOPNOTSUPP)
1021 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1024 static int idedisk_media_changed(struct gendisk *disk)
1026 struct ide_disk_obj *idkp = ide_disk_g(disk);
1027 ide_drive_t *drive = idkp->drive;
1029 /* do not scan partitions twice if this is a removable device */
1030 if (drive->attach) {
1034 /* if removable, always assume it was changed */
1035 return drive->removable;
1038 static int idedisk_revalidate_disk(struct gendisk *disk)
1040 struct ide_disk_obj *idkp = ide_disk_g(disk);
1041 set_capacity(disk, idedisk_capacity(idkp->drive));
1045 static struct block_device_operations idedisk_ops = {
1046 .owner = THIS_MODULE,
1047 .open = idedisk_open,
1048 .release = idedisk_release,
1049 .ioctl = idedisk_ioctl,
1050 .getgeo = idedisk_getgeo,
1051 .media_changed = idedisk_media_changed,
1052 .revalidate_disk = idedisk_revalidate_disk
1055 MODULE_DESCRIPTION("ATA DISK Driver");
1057 static int ide_disk_probe(ide_drive_t *drive)
1059 struct ide_disk_obj *idkp;
1062 /* strstr("foo", "") is non-NULL */
1063 if (!strstr("ide-disk", drive->driver_req))
1066 if (drive->media != ide_disk)
1069 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1073 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
1077 ide_init_disk(g, drive);
1079 kref_init(&idkp->kref);
1081 idkp->drive = drive;
1082 idkp->driver = &idedisk_driver;
1085 g->private_data = &idkp->driver;
1087 drive->driver_data = idkp;
1089 idedisk_setup(drive);
1090 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1091 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1092 drive->name, drive->head);
1097 g->minors = IDE_DISK_MINORS;
1098 g->driverfs_dev = &drive->gendev;
1099 g->flags |= GENHD_FL_EXT_DEVT;
1100 if (drive->removable)
1101 g->flags |= GENHD_FL_REMOVABLE;
1102 set_capacity(g, idedisk_capacity(drive));
1103 g->fops = &idedisk_ops;
1113 static void __exit idedisk_exit(void)
1115 driver_unregister(&idedisk_driver.gen_driver);
1118 static int __init idedisk_init(void)
1120 return driver_register(&idedisk_driver.gen_driver);
1123 MODULE_ALIAS("ide:*m-disk*");
1124 module_init(idedisk_init);
1125 module_exit(idedisk_exit);
1126 MODULE_LICENSE("GPL");