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);
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(u16 *id)
102 unsigned long lba_sects, chs_sects, head, tail;
104 /* No non-LBA info .. so valid! */
105 if (id[ATA_ID_CYLS] == 0)
108 lba_sects = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
111 * The ATA spec tells large drives to return
112 * C/H/S = 16383/16/63 independent of their size.
113 * Some drives can be jumpered to use 15 heads instead of 16.
114 * Some drives can be jumpered to use 4092 cyls instead of 16383.
116 if ((id[ATA_ID_CYLS] == 16383 ||
117 (id[ATA_ID_CYLS] == 4092 && id[ATA_ID_CUR_CYLS] == 16383)) &&
118 id[ATA_ID_SECTORS] == 63 &&
119 (id[ATA_ID_HEADS] == 15 || id[ATA_ID_HEADS] == 16) &&
120 (lba_sects >= 16383 * 63 * id[ATA_ID_HEADS]))
123 chs_sects = id[ATA_ID_CYLS] * id[ATA_ID_HEADS] * id[ATA_ID_SECTORS];
125 /* perform a rough sanity check on lba_sects: within 10% is OK */
126 if ((lba_sects - chs_sects) < chs_sects/10)
129 /* some drives have the word order reversed */
130 head = ((lba_sects >> 16) & 0xffff);
131 tail = (lba_sects & 0xffff);
132 lba_sects = (head | (tail << 16));
133 if ((lba_sects - chs_sects) < chs_sects/10) {
134 *(__le32 *)&id[ATA_ID_LBA_CAPACITY] = __cpu_to_le32(lba_sects);
135 return 1; /* lba_capacity is (now) good */
138 return 0; /* lba_capacity value may be bad */
141 static const u8 ide_rw_cmds[] = {
144 ATA_CMD_READ_MULTI_EXT,
145 ATA_CMD_WRITE_MULTI_EXT,
148 ATA_CMD_PIO_READ_EXT,
149 ATA_CMD_PIO_WRITE_EXT,
156 static const u8 ide_data_phases[] = {
165 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
167 u8 index, lba48, write;
169 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
170 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
175 index = drive->mult_count ? 0 : 4;
177 task->tf.command = ide_rw_cmds[index + lba48 + write];
180 index = 8; /* fixup index */
182 task->data_phase = ide_data_phases[index / 2 + write];
186 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
187 * using LBA if supported, or CHS otherwise, to address sectors.
189 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
192 ide_hwif_t *hwif = HWIF(drive);
193 unsigned int dma = drive->using_dma;
194 u16 nsectors = (u16)rq->nr_sectors;
195 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
197 struct ide_taskfile *tf = &task.tf;
200 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
201 if (block + rq->nr_sectors > 1ULL << 28)
208 ide_init_sg_cmd(drive, rq);
209 ide_map_sg(drive, rq);
212 memset(&task, 0, sizeof(task));
213 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
215 if (drive->select.b.lba) {
217 pr_debug("%s: LBA=0x%012llx\n", drive->name,
218 (unsigned long long)block);
220 tf->hob_nsect = (nsectors >> 8) & 0xff;
221 tf->hob_lbal = (u8)(block >> 24);
222 if (sizeof(block) != 4) {
223 tf->hob_lbam = (u8)((u64)block >> 32);
224 tf->hob_lbah = (u8)((u64)block >> 40);
227 tf->nsect = nsectors & 0xff;
228 tf->lbal = (u8) block;
229 tf->lbam = (u8)(block >> 8);
230 tf->lbah = (u8)(block >> 16);
232 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
234 tf->nsect = nsectors & 0xff;
236 tf->lbam = block >>= 8;
237 tf->lbah = block >>= 8;
238 tf->device = (block >> 8) & 0xf;
241 unsigned int sect, head, cyl, track;
243 track = (int)block / drive->sect;
244 sect = (int)block % drive->sect + 1;
245 head = track % drive->head;
246 cyl = track / drive->head;
248 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
250 tf->nsect = nsectors & 0xff;
258 task.tf_flags |= IDE_TFLAG_WRITE;
260 ide_tf_set_cmd(drive, &task, dma);
262 hwif->data_phase = task.data_phase;
265 rc = do_rw_taskfile(drive, &task);
267 if (rc == ide_stopped && dma) {
268 /* fallback to PIO */
269 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
270 ide_tf_set_cmd(drive, &task, 0);
271 hwif->data_phase = task.data_phase;
272 ide_init_sg_cmd(drive, rq);
273 rc = do_rw_taskfile(drive, &task);
280 * 268435455 == 137439 MB or 28bit limit
281 * 320173056 == 163929 MB or 48bit addressing
282 * 1073741822 == 549756 MB or 48bit addressing fake drive
285 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
288 ide_hwif_t *hwif = HWIF(drive);
290 BUG_ON(drive->blocked);
292 if (!blk_fs_request(rq)) {
293 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
294 ide_end_request(drive, 0, 0);
298 ledtrig_ide_activity();
300 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
301 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
302 (unsigned long long)block, rq->nr_sectors,
303 (unsigned long)rq->buffer);
306 hwif->rw_disk(drive, rq);
308 return __ide_do_rw_disk(drive, rq, block);
312 * Queries for true maximum capacity of the drive.
313 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
315 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
318 struct ide_taskfile *tf = &args.tf;
321 /* Create IDE/ATA command request structure */
322 memset(&args, 0, sizeof(ide_task_t));
324 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
326 tf->command = ATA_CMD_READ_NATIVE_MAX;
327 tf->device = ATA_LBA;
328 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
330 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
331 /* submit command request */
332 ide_no_data_taskfile(drive, &args);
334 /* if OK, compute maximum address value */
335 if ((tf->status & 0x01) == 0)
336 addr = ide_get_lba_addr(tf, lba48) + 1;
342 * Sets maximum virtual LBA address of the drive.
343 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
345 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
348 struct ide_taskfile *tf = &args.tf;
352 /* Create IDE/ATA command request structure */
353 memset(&args, 0, sizeof(ide_task_t));
354 tf->lbal = (addr_req >> 0) & 0xff;
355 tf->lbam = (addr_req >>= 8) & 0xff;
356 tf->lbah = (addr_req >>= 8) & 0xff;
358 tf->hob_lbal = (addr_req >>= 8) & 0xff;
359 tf->hob_lbam = (addr_req >>= 8) & 0xff;
360 tf->hob_lbah = (addr_req >>= 8) & 0xff;
361 tf->command = ATA_CMD_SET_MAX_EXT;
363 tf->device = (addr_req >>= 8) & 0x0f;
364 tf->command = ATA_CMD_SET_MAX;
366 tf->device |= ATA_LBA;
367 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
369 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
370 /* submit command request */
371 ide_no_data_taskfile(drive, &args);
372 /* if OK, compute maximum address value */
373 if ((tf->status & 0x01) == 0)
374 addr_set = ide_get_lba_addr(tf, lba48) + 1;
379 static unsigned long long sectors_to_MB(unsigned long long n)
381 n <<= 9; /* make it bytes */
382 do_div(n, 1000000); /* make it MB */
387 * Some disks report total number of sectors instead of
388 * maximum sector address. We list them here.
390 static const struct drive_list_entry hpa_list[] = {
391 { "ST340823A", NULL },
392 { "ST320413A", NULL },
393 { "ST310211A", NULL },
397 static void idedisk_check_hpa(ide_drive_t *drive)
399 unsigned long long capacity, set_max;
400 int lba48 = ata_id_lba48_enabled(drive->id);
402 capacity = drive->capacity64;
404 set_max = idedisk_read_native_max_address(drive, lba48);
406 if (ide_in_drive_list(drive->id, hpa_list)) {
408 * Since we are inclusive wrt to firmware revisions do this
409 * extra check and apply the workaround only when needed.
411 if (set_max == capacity + 1)
415 if (set_max <= capacity)
418 printk(KERN_INFO "%s: Host Protected Area detected.\n"
419 "\tcurrent capacity is %llu sectors (%llu MB)\n"
420 "\tnative capacity is %llu sectors (%llu MB)\n",
422 capacity, sectors_to_MB(capacity),
423 set_max, sectors_to_MB(set_max));
425 set_max = idedisk_set_max_address(drive, set_max, lba48);
428 drive->capacity64 = set_max;
429 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
434 static void init_idedisk_capacity(ide_drive_t *drive)
438 * If this drive supports the Host Protected Area feature set,
439 * then we may need to change our opinion about the drive's capacity.
441 int hpa = ata_id_hpa_enabled(id);
443 if (ata_id_lba48_enabled(id)) {
444 /* drive speaks 48-bit LBA */
445 drive->select.b.lba = 1;
446 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
448 idedisk_check_hpa(drive);
449 } else if (ata_id_has_lba(id) && lba_capacity_is_ok(id)) {
450 /* drive speaks 28-bit LBA */
451 drive->select.b.lba = 1;
452 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
454 idedisk_check_hpa(drive);
456 /* drive speaks boring old 28-bit CHS */
457 drive->capacity64 = drive->cyl * drive->head * drive->sect;
461 static sector_t idedisk_capacity(ide_drive_t *drive)
463 return drive->capacity64;
466 #ifdef CONFIG_IDE_PROC_FS
467 static int smart_enable(ide_drive_t *drive)
470 struct ide_taskfile *tf = &args.tf;
472 memset(&args, 0, sizeof(ide_task_t));
473 tf->feature = ATA_SMART_ENABLE;
474 tf->lbam = ATA_SMART_LBAM_PASS;
475 tf->lbah = ATA_SMART_LBAH_PASS;
476 tf->command = ATA_CMD_SMART;
477 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
478 return ide_no_data_taskfile(drive, &args);
481 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
484 struct ide_taskfile *tf = &args.tf;
486 memset(&args, 0, sizeof(ide_task_t));
487 tf->feature = sub_cmd;
489 tf->lbam = ATA_SMART_LBAM_PASS;
490 tf->lbah = ATA_SMART_LBAH_PASS;
491 tf->command = ATA_CMD_SMART;
492 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
493 args.data_phase = TASKFILE_IN;
494 (void) smart_enable(drive);
495 return ide_raw_taskfile(drive, &args, buf, 1);
498 static int proc_idedisk_read_cache
499 (char *page, char **start, off_t off, int count, int *eof, void *data)
501 ide_drive_t *drive = (ide_drive_t *) data;
506 len = sprintf(out, "%i\n", drive->id[ATA_ID_BUF_SIZE] / 2);
508 len = sprintf(out, "(none)\n");
510 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
513 static int proc_idedisk_read_capacity
514 (char *page, char **start, off_t off, int count, int *eof, void *data)
516 ide_drive_t*drive = (ide_drive_t *)data;
519 len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
521 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
524 static int proc_idedisk_read_smart(char *page, char **start, off_t off,
525 int count, int *eof, void *data, u8 sub_cmd)
527 ide_drive_t *drive = (ide_drive_t *)data;
530 if (get_smart_data(drive, page, sub_cmd) == 0) {
531 unsigned short *val = (unsigned short *) page;
532 char *out = (char *)val + SECTOR_SIZE;
536 out += sprintf(out, "%04x%c", le16_to_cpu(*val),
537 (++i & 7) ? ' ' : '\n');
539 } while (i < SECTOR_SIZE / 2);
543 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
546 static int proc_idedisk_read_sv
547 (char *page, char **start, off_t off, int count, int *eof, void *data)
549 return proc_idedisk_read_smart(page, start, off, count, eof, data,
550 ATA_SMART_READ_VALUES);
553 static int proc_idedisk_read_st
554 (char *page, char **start, off_t off, int count, int *eof, void *data)
556 return proc_idedisk_read_smart(page, start, off, count, eof, data,
557 ATA_SMART_READ_THRESHOLDS);
560 static ide_proc_entry_t idedisk_proc[] = {
561 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
562 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
563 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
564 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv, NULL },
565 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st, NULL },
566 { NULL, 0, NULL, NULL }
568 #endif /* CONFIG_IDE_PROC_FS */
570 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
572 ide_drive_t *drive = q->queuedata;
573 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
575 /* FIXME: map struct ide_taskfile on rq->cmd[] */
576 BUG_ON(task == NULL);
578 memset(task, 0, sizeof(*task));
579 if (ide_id_has_flush_cache_ext(drive->id) &&
580 (drive->capacity64 >= (1UL << 28)))
581 task->tf.command = ATA_CMD_FLUSH_EXT;
583 task->tf.command = ATA_CMD_FLUSH;
584 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
586 task->data_phase = TASKFILE_NO_DATA;
588 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
589 rq->cmd_flags |= REQ_SOFTBARRIER;
593 ide_devset_get(multcount, mult_count);
596 * This is tightly woven into the driver->do_special can not touch.
597 * DON'T do it again until a total personality rewrite is committed.
599 static int set_multcount(ide_drive_t *drive, int arg)
604 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
607 if (drive->special.b.set_multmode)
610 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
611 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
613 drive->mult_req = arg;
614 drive->special.b.set_multmode = 1;
615 error = blk_execute_rq(drive->queue, NULL, rq, 0);
618 return (drive->mult_count == arg) ? 0 : -EIO;
621 ide_devset_get(nowerr, nowerr);
623 static int set_nowerr(ide_drive_t *drive, int arg)
625 if (arg < 0 || arg > 1)
628 if (ide_spin_wait_hwgroup(drive))
631 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
632 spin_unlock_irq(&ide_lock);
636 static void update_ordered(ide_drive_t *drive)
639 unsigned ordered = QUEUE_ORDERED_NONE;
640 prepare_flush_fn *prep_fn = NULL;
643 unsigned long long capacity;
646 * We must avoid issuing commands a drive does not
647 * understand or we may crash it. We check flush cache
648 * is supported. We also check we have the LBA48 flush
649 * cache if the drive capacity is too large. By this
650 * time we have trimmed the drive capacity if LBA48 is
651 * not available so we don't need to recheck that.
653 capacity = idedisk_capacity(drive);
654 barrier = ata_id_flush_enabled(id) && !drive->noflush &&
655 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
656 ide_id_has_flush_cache_ext(id));
658 printk(KERN_INFO "%s: cache flushes %ssupported\n",
659 drive->name, barrier ? "" : "not ");
662 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
663 prep_fn = idedisk_prepare_flush;
666 ordered = QUEUE_ORDERED_DRAIN;
668 blk_queue_ordered(drive->queue, ordered, prep_fn);
671 ide_devset_get(wcache, wcache);
673 static int set_wcache(ide_drive_t *drive, int arg)
678 if (arg < 0 || arg > 1)
681 if (ata_id_flush_enabled(drive->id)) {
682 memset(&args, 0, sizeof(ide_task_t));
683 args.tf.feature = arg ?
684 SETFEATURES_WC_ON : SETFEATURES_WC_OFF;
685 args.tf.command = ATA_CMD_SET_FEATURES;
686 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
687 err = ide_no_data_taskfile(drive, &args);
692 update_ordered(drive);
697 static int do_idedisk_flushcache(ide_drive_t *drive)
701 memset(&args, 0, sizeof(ide_task_t));
702 if (ide_id_has_flush_cache_ext(drive->id))
703 args.tf.command = ATA_CMD_FLUSH_EXT;
705 args.tf.command = ATA_CMD_FLUSH;
706 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
707 return ide_no_data_taskfile(drive, &args);
710 ide_devset_get(acoustic, acoustic);
712 static int set_acoustic(ide_drive_t *drive, int arg)
716 if (arg < 0 || arg > 254)
719 memset(&args, 0, sizeof(ide_task_t));
720 args.tf.feature = arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF;
722 args.tf.command = ATA_CMD_SET_FEATURES;
723 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
724 ide_no_data_taskfile(drive, &args);
725 drive->acoustic = arg;
729 ide_devset_get(lba_addressing, addressing);
735 * 2: 48-bit capable doing 28-bit
737 static int set_lba_addressing(ide_drive_t *drive, int arg)
739 if (arg < 0 || arg > 2)
742 drive->addressing = 0;
744 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
747 if (ata_id_lba48_enabled(drive->id) == 0)
750 drive->addressing = arg;
755 #ifdef CONFIG_IDE_PROC_FS
756 ide_devset_rw_nolock(acoustic, 0, 254, acoustic);
757 ide_devset_rw_nolock(address, 0, 2, lba_addressing);
758 ide_devset_rw_nolock(multcount, 0, 16, multcount);
759 ide_devset_rw_nolock(nowerr, 0, 1, nowerr);
760 ide_devset_rw_nolock(wcache, 0, 1, wcache);
762 ide_devset_rw(bios_cyl, 0, 65535, bios_cyl);
763 ide_devset_rw(bios_head, 0, 255, bios_head);
764 ide_devset_rw(bios_sect, 0, 63, bios_sect);
765 ide_devset_rw(failures, 0, 65535, failures);
766 ide_devset_rw(lun, 0, 7, lun);
767 ide_devset_rw(max_failures, 0, 65535, max_failures);
769 static const struct ide_devset *idedisk_settings[] = {
770 &ide_devset_acoustic,
772 &ide_devset_bios_cyl,
773 &ide_devset_bios_head,
774 &ide_devset_bios_sect,
775 &ide_devset_failures,
777 &ide_devset_max_failures,
778 &ide_devset_multcount,
785 static void idedisk_setup(ide_drive_t *drive)
787 struct ide_disk_obj *idkp = drive->driver_data;
788 ide_hwif_t *hwif = drive->hwif;
790 char *m = (char *)&id[ATA_ID_PROD];
791 unsigned long long capacity;
793 ide_proc_register_driver(drive, idkp->driver);
795 if (drive->id_read == 0)
798 if (drive->removable) {
800 * Removable disks (eg. SYQUEST); ignore 'WD' drives
802 if (m[0] != 'W' || m[1] != 'D')
803 drive->doorlocking = 1;
806 (void)set_lba_addressing(drive, 1);
808 if (drive->addressing == 1) {
811 if (max_s > hwif->rqsize)
812 max_s = hwif->rqsize;
814 blk_queue_max_sectors(drive->queue, max_s);
817 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
818 drive->queue->max_sectors / 2);
820 /* calculate drive capacity, and select LBA if possible */
821 init_idedisk_capacity(drive);
823 /* limit drive capacity to 137GB if LBA48 cannot be used */
824 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
825 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
826 "%llu sectors (%llu MB)\n",
827 drive->name, (unsigned long long)drive->capacity64,
828 sectors_to_MB(drive->capacity64));
829 drive->capacity64 = 1ULL << 28;
832 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
833 if (drive->capacity64 > 1ULL << 28) {
834 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
835 " will be used for accessing sectors "
836 "> %u\n", drive->name, 1 << 28);
838 drive->addressing = 0;
842 * if possible, give fdisk access to more of the drive,
843 * by correcting bios_cyls:
845 capacity = idedisk_capacity(drive);
847 if (!drive->forced_geom) {
848 if (ata_id_lba48_enabled(drive->id)) {
850 drive->bios_sect = 63;
851 drive->bios_head = 255;
854 if (drive->bios_sect && drive->bios_head) {
855 unsigned int cap0 = capacity; /* truncate to 32 bits */
856 unsigned int cylsz, cyl;
858 if (cap0 != capacity)
859 drive->bios_cyl = 65535;
861 cylsz = drive->bios_sect * drive->bios_head;
865 if (cyl > drive->bios_cyl)
866 drive->bios_cyl = cyl;
870 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
871 drive->name, capacity, sectors_to_MB(capacity));
873 /* Only print cache size when it was specified */
874 if (id[ATA_ID_BUF_SIZE])
875 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
877 printk(KERN_CONT ", CHS=%d/%d/%d\n",
878 drive->bios_cyl, drive->bios_head, drive->bios_sect);
880 /* write cache enabled? */
881 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
884 set_wcache(drive, 1);
887 static void ide_cacheflush_p(ide_drive_t *drive)
889 if (!drive->wcache || ata_id_flush_enabled(drive->id) == 0)
892 if (do_idedisk_flushcache(drive))
893 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
896 static void ide_disk_remove(ide_drive_t *drive)
898 struct ide_disk_obj *idkp = drive->driver_data;
899 struct gendisk *g = idkp->disk;
901 ide_proc_unregister_driver(drive, idkp->driver);
905 ide_cacheflush_p(drive);
910 static void ide_disk_release(struct kref *kref)
912 struct ide_disk_obj *idkp = to_ide_disk(kref);
913 ide_drive_t *drive = idkp->drive;
914 struct gendisk *g = idkp->disk;
916 drive->driver_data = NULL;
917 g->private_data = NULL;
922 static int ide_disk_probe(ide_drive_t *drive);
925 * On HPA drives the capacity needs to be
926 * reinitilized on resume otherwise the disk
927 * can not be used and a hard reset is required
929 static void ide_disk_resume(ide_drive_t *drive)
931 if (ata_id_hpa_enabled(drive->id))
932 init_idedisk_capacity(drive);
935 static void ide_device_shutdown(ide_drive_t *drive)
938 /* On Alpha, halt(8) doesn't actually turn the machine off,
939 it puts you into the sort of firmware monitor. Typically,
940 it's used to boot another kernel image, so it's not much
941 different from reboot(8). Therefore, we don't need to
942 spin down the disk in this case, especially since Alpha
943 firmware doesn't handle disks in standby mode properly.
944 On the other hand, it's reasonably safe to turn the power
945 off when the shutdown process reaches the firmware prompt,
946 as the firmware initialization takes rather long time -
947 at least 10 seconds, which should be sufficient for
948 the disk to expire its write cache. */
949 if (system_state != SYSTEM_POWER_OFF) {
951 if (system_state == SYSTEM_RESTART) {
953 ide_cacheflush_p(drive);
957 printk(KERN_INFO "Shutdown: %s\n", drive->name);
959 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
962 static ide_driver_t idedisk_driver = {
964 .owner = THIS_MODULE,
966 .bus = &ide_bus_type,
968 .probe = ide_disk_probe,
969 .remove = ide_disk_remove,
970 .resume = ide_disk_resume,
971 .shutdown = ide_device_shutdown,
972 .version = IDEDISK_VERSION,
974 .do_request = ide_do_rw_disk,
975 .end_request = ide_end_request,
976 .error = __ide_error,
977 #ifdef CONFIG_IDE_PROC_FS
978 .proc = idedisk_proc,
979 .settings = idedisk_settings,
983 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
987 memset(&task, 0, sizeof(task));
988 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
989 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
991 return ide_no_data_taskfile(drive, &task);
994 static int idedisk_open(struct inode *inode, struct file *filp)
996 struct gendisk *disk = inode->i_bdev->bd_disk;
997 struct ide_disk_obj *idkp;
1000 idkp = ide_disk_get(disk);
1004 drive = idkp->drive;
1008 if (drive->removable && idkp->openers == 1) {
1009 check_disk_change(inode->i_bdev);
1011 * Ignore the return code from door_lock,
1012 * since the open() has already succeeded,
1013 * and the door_lock is irrelevant at this point.
1015 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1016 drive->doorlocking = 0;
1021 static int idedisk_release(struct inode *inode, struct file *filp)
1023 struct gendisk *disk = inode->i_bdev->bd_disk;
1024 struct ide_disk_obj *idkp = ide_disk_g(disk);
1025 ide_drive_t *drive = idkp->drive;
1027 if (idkp->openers == 1)
1028 ide_cacheflush_p(drive);
1030 if (drive->removable && idkp->openers == 1) {
1031 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1032 drive->doorlocking = 0;
1042 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1044 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1045 ide_drive_t *drive = idkp->drive;
1047 geo->heads = drive->bios_head;
1048 geo->sectors = drive->bios_sect;
1049 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1053 static int idedisk_ioctl(struct inode *inode, struct file *file,
1054 unsigned int cmd, unsigned long arg)
1056 unsigned long flags;
1057 struct block_device *bdev = inode->i_bdev;
1058 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1059 ide_drive_t *drive = idkp->drive;
1060 int err, (*getfunc)(ide_drive_t *), (*setfunc)(ide_drive_t *, int);
1063 case HDIO_GET_ADDRESS: getfunc = get_lba_addressing; goto read_val;
1064 case HDIO_GET_MULTCOUNT: getfunc = get_multcount; goto read_val;
1065 case HDIO_GET_NOWERR: getfunc = get_nowerr; goto read_val;
1066 case HDIO_GET_WCACHE: getfunc = get_wcache; goto read_val;
1067 case HDIO_GET_ACOUSTIC: getfunc = get_acoustic; goto read_val;
1068 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1069 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1070 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1071 case HDIO_SET_WCACHE: setfunc = set_wcache; goto set_val;
1072 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1075 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1078 mutex_lock(&ide_setting_mtx);
1079 spin_lock_irqsave(&ide_lock, flags);
1080 err = getfunc(drive);
1081 spin_unlock_irqrestore(&ide_lock, flags);
1082 mutex_unlock(&ide_setting_mtx);
1083 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1086 if (bdev != bdev->bd_contains)
1089 if (!capable(CAP_SYS_ADMIN))
1092 mutex_lock(&ide_setting_mtx);
1093 err = setfunc(drive, arg);
1094 mutex_unlock(&ide_setting_mtx);
1100 static int idedisk_media_changed(struct gendisk *disk)
1102 struct ide_disk_obj *idkp = ide_disk_g(disk);
1103 ide_drive_t *drive = idkp->drive;
1105 /* do not scan partitions twice if this is a removable device */
1106 if (drive->attach) {
1110 /* if removable, always assume it was changed */
1111 return drive->removable;
1114 static int idedisk_revalidate_disk(struct gendisk *disk)
1116 struct ide_disk_obj *idkp = ide_disk_g(disk);
1117 set_capacity(disk, idedisk_capacity(idkp->drive));
1121 static struct block_device_operations idedisk_ops = {
1122 .owner = THIS_MODULE,
1123 .open = idedisk_open,
1124 .release = idedisk_release,
1125 .ioctl = idedisk_ioctl,
1126 .getgeo = idedisk_getgeo,
1127 .media_changed = idedisk_media_changed,
1128 .revalidate_disk = idedisk_revalidate_disk
1131 MODULE_DESCRIPTION("ATA DISK Driver");
1133 static int ide_disk_probe(ide_drive_t *drive)
1135 struct ide_disk_obj *idkp;
1138 /* strstr("foo", "") is non-NULL */
1139 if (!strstr("ide-disk", drive->driver_req))
1142 if (drive->media != ide_disk)
1145 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1149 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
1153 ide_init_disk(g, drive);
1155 kref_init(&idkp->kref);
1157 idkp->drive = drive;
1158 idkp->driver = &idedisk_driver;
1161 g->private_data = &idkp->driver;
1163 drive->driver_data = idkp;
1165 idedisk_setup(drive);
1166 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1167 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1168 drive->name, drive->head);
1173 g->minors = IDE_DISK_MINORS;
1174 g->driverfs_dev = &drive->gendev;
1175 g->flags |= GENHD_FL_EXT_DEVT;
1176 if (drive->removable)
1177 g->flags |= GENHD_FL_REMOVABLE;
1178 set_capacity(g, idedisk_capacity(drive));
1179 g->fops = &idedisk_ops;
1189 static void __exit idedisk_exit(void)
1191 driver_unregister(&idedisk_driver.gen_driver);
1194 static int __init idedisk_init(void)
1196 return driver_register(&idedisk_driver.gen_driver);
1199 MODULE_ALIAS("ide:*m-disk*");
1200 module_init(idedisk_init);
1201 module_exit(idedisk_exit);
1202 MODULE_LICENSE("GPL");