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 */
389 static inline int idedisk_supports_lba48(const u16 *id)
391 return (id[ATA_ID_COMMAND_SET_2] & 0x0400) &&
392 (id[ATA_ID_CFS_ENABLE_2] & 0x0400) &&
393 ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
397 * Some disks report total number of sectors instead of
398 * maximum sector address. We list them here.
400 static const struct drive_list_entry hpa_list[] = {
401 { "ST340823A", NULL },
402 { "ST320413A", NULL },
403 { "ST310211A", NULL },
407 static void idedisk_check_hpa(ide_drive_t *drive)
409 unsigned long long capacity, set_max;
410 int lba48 = idedisk_supports_lba48(drive->id);
412 capacity = drive->capacity64;
414 set_max = idedisk_read_native_max_address(drive, lba48);
416 if (ide_in_drive_list(drive->id, hpa_list)) {
418 * Since we are inclusive wrt to firmware revisions do this
419 * extra check and apply the workaround only when needed.
421 if (set_max == capacity + 1)
425 if (set_max <= capacity)
428 printk(KERN_INFO "%s: Host Protected Area detected.\n"
429 "\tcurrent capacity is %llu sectors (%llu MB)\n"
430 "\tnative capacity is %llu sectors (%llu MB)\n",
432 capacity, sectors_to_MB(capacity),
433 set_max, sectors_to_MB(set_max));
435 set_max = idedisk_set_max_address(drive, set_max, lba48);
438 drive->capacity64 = set_max;
439 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
444 static void init_idedisk_capacity(ide_drive_t *drive)
448 * If this drive supports the Host Protected Area feature set,
449 * then we may need to change our opinion about the drive's capacity.
451 int hpa = ata_id_hpa_enabled(id);
453 if (idedisk_supports_lba48(id)) {
454 /* drive speaks 48-bit LBA */
455 drive->select.b.lba = 1;
456 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
458 idedisk_check_hpa(drive);
459 } else if (ata_id_has_lba(id) && lba_capacity_is_ok(id)) {
460 /* drive speaks 28-bit LBA */
461 drive->select.b.lba = 1;
462 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
464 idedisk_check_hpa(drive);
466 /* drive speaks boring old 28-bit CHS */
467 drive->capacity64 = drive->cyl * drive->head * drive->sect;
471 static sector_t idedisk_capacity(ide_drive_t *drive)
473 return drive->capacity64;
476 #ifdef CONFIG_IDE_PROC_FS
477 static int smart_enable(ide_drive_t *drive)
480 struct ide_taskfile *tf = &args.tf;
482 memset(&args, 0, sizeof(ide_task_t));
483 tf->feature = ATA_SMART_ENABLE;
484 tf->lbam = ATA_SMART_LBAM_PASS;
485 tf->lbah = ATA_SMART_LBAH_PASS;
486 tf->command = ATA_CMD_SMART;
487 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
488 return ide_no_data_taskfile(drive, &args);
491 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
494 struct ide_taskfile *tf = &args.tf;
496 memset(&args, 0, sizeof(ide_task_t));
497 tf->feature = sub_cmd;
499 tf->lbam = ATA_SMART_LBAM_PASS;
500 tf->lbah = ATA_SMART_LBAH_PASS;
501 tf->command = ATA_CMD_SMART;
502 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
503 args.data_phase = TASKFILE_IN;
504 (void) smart_enable(drive);
505 return ide_raw_taskfile(drive, &args, buf, 1);
508 static int proc_idedisk_read_cache
509 (char *page, char **start, off_t off, int count, int *eof, void *data)
511 ide_drive_t *drive = (ide_drive_t *) data;
516 len = sprintf(out, "%i\n", drive->id[ATA_ID_BUF_SIZE] / 2);
518 len = sprintf(out, "(none)\n");
520 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
523 static int proc_idedisk_read_capacity
524 (char *page, char **start, off_t off, int count, int *eof, void *data)
526 ide_drive_t*drive = (ide_drive_t *)data;
529 len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
531 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
534 static int proc_idedisk_read_smart(char *page, char **start, off_t off,
535 int count, int *eof, void *data, u8 sub_cmd)
537 ide_drive_t *drive = (ide_drive_t *)data;
540 if (get_smart_data(drive, page, sub_cmd) == 0) {
541 unsigned short *val = (unsigned short *) page;
542 char *out = ((char *)val) + (SECTOR_WORDS * 4);
545 out += sprintf(out, "%04x%c", le16_to_cpu(*val),
546 (++i & 7) ? ' ' : '\n');
548 } while (i < (SECTOR_WORDS * 2));
552 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
555 static int proc_idedisk_read_sv
556 (char *page, char **start, off_t off, int count, int *eof, void *data)
558 return proc_idedisk_read_smart(page, start, off, count, eof, data,
559 ATA_SMART_READ_VALUES);
562 static int proc_idedisk_read_st
563 (char *page, char **start, off_t off, int count, int *eof, void *data)
565 return proc_idedisk_read_smart(page, start, off, count, eof, data,
566 ATA_SMART_READ_THRESHOLDS);
569 static ide_proc_entry_t idedisk_proc[] = {
570 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
571 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
572 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
573 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv, NULL },
574 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st, NULL },
575 { NULL, 0, NULL, NULL }
577 #endif /* CONFIG_IDE_PROC_FS */
579 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
581 ide_drive_t *drive = q->queuedata;
582 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
584 /* FIXME: map struct ide_taskfile on rq->cmd[] */
585 BUG_ON(task == NULL);
587 memset(task, 0, sizeof(*task));
588 if (ide_id_has_flush_cache_ext(drive->id) &&
589 (drive->capacity64 >= (1UL << 28)))
590 task->tf.command = ATA_CMD_FLUSH_EXT;
592 task->tf.command = ATA_CMD_FLUSH;
593 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
595 task->data_phase = TASKFILE_NO_DATA;
597 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
598 rq->cmd_flags |= REQ_SOFTBARRIER;
603 * This is tightly woven into the driver->do_special can not touch.
604 * DON'T do it again until a total personality rewrite is committed.
606 static int set_multcount(ide_drive_t *drive, int arg)
611 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
614 if (drive->special.b.set_multmode)
617 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
618 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
620 drive->mult_req = arg;
621 drive->special.b.set_multmode = 1;
622 error = blk_execute_rq(drive->queue, NULL, rq, 0);
625 return (drive->mult_count == arg) ? 0 : -EIO;
628 static int set_nowerr(ide_drive_t *drive, int arg)
630 if (arg < 0 || arg > 1)
633 if (ide_spin_wait_hwgroup(drive))
636 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
637 spin_unlock_irq(&ide_lock);
641 static void update_ordered(ide_drive_t *drive)
644 unsigned ordered = QUEUE_ORDERED_NONE;
645 prepare_flush_fn *prep_fn = NULL;
648 unsigned long long capacity;
651 * We must avoid issuing commands a drive does not
652 * understand or we may crash it. We check flush cache
653 * is supported. We also check we have the LBA48 flush
654 * cache if the drive capacity is too large. By this
655 * time we have trimmed the drive capacity if LBA48 is
656 * not available so we don't need to recheck that.
658 capacity = idedisk_capacity(drive);
659 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
660 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
661 ide_id_has_flush_cache_ext(id));
663 printk(KERN_INFO "%s: cache flushes %ssupported\n",
664 drive->name, barrier ? "" : "not ");
667 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
668 prep_fn = idedisk_prepare_flush;
671 ordered = QUEUE_ORDERED_DRAIN;
673 blk_queue_ordered(drive->queue, ordered, prep_fn);
676 static int write_cache(ide_drive_t *drive, int arg)
681 if (arg < 0 || arg > 1)
684 if (ide_id_has_flush_cache(drive->id)) {
685 memset(&args, 0, sizeof(ide_task_t));
686 args.tf.feature = arg ?
687 SETFEATURES_WC_ON : SETFEATURES_WC_OFF;
688 args.tf.command = ATA_CMD_SET_FEATURES;
689 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
690 err = ide_no_data_taskfile(drive, &args);
695 update_ordered(drive);
700 static int do_idedisk_flushcache(ide_drive_t *drive)
704 memset(&args, 0, sizeof(ide_task_t));
705 if (ide_id_has_flush_cache_ext(drive->id))
706 args.tf.command = ATA_CMD_FLUSH_EXT;
708 args.tf.command = ATA_CMD_FLUSH;
709 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
710 return ide_no_data_taskfile(drive, &args);
713 static int set_acoustic(ide_drive_t *drive, int arg)
717 if (arg < 0 || arg > 254)
720 memset(&args, 0, sizeof(ide_task_t));
721 args.tf.feature = arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF;
723 args.tf.command = ATA_CMD_SET_FEATURES;
724 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
725 ide_no_data_taskfile(drive, &args);
726 drive->acoustic = arg;
734 * 2: 48-bit capable doing 28-bit
736 static int set_lba_addressing(ide_drive_t *drive, int arg)
738 if (arg < 0 || arg > 2)
741 drive->addressing = 0;
743 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
746 if (!idedisk_supports_lba48(drive->id))
748 drive->addressing = arg;
752 #ifdef CONFIG_IDE_PROC_FS
753 static void idedisk_add_settings(ide_drive_t *drive)
755 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
756 &drive->bios_cyl, NULL);
757 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
758 &drive->bios_head, NULL);
759 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1,
760 &drive->bios_sect, NULL);
761 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1,
762 &drive->addressing, set_lba_addressing);
763 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0,
764 drive->id[ATA_ID_MAX_MULTSECT] & 0xff, 1, 1,
765 &drive->mult_count, set_multcount);
766 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
767 &drive->nowerr, set_nowerr);
768 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1,
770 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
771 &drive->wcache, write_cache);
772 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1,
773 &drive->acoustic, set_acoustic);
774 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
775 &drive->failures, NULL);
776 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535,
777 1, 1, &drive->max_failures, NULL);
780 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
783 static void idedisk_setup(ide_drive_t *drive)
785 ide_hwif_t *hwif = drive->hwif;
787 char *m = (char *)&id[ATA_ID_PROD];
788 unsigned long long capacity;
790 idedisk_add_settings(drive);
792 if (drive->id_read == 0)
795 if (drive->removable) {
797 * Removable disks (eg. SYQUEST); ignore 'WD' drives
799 if (m[0] != 'W' || m[1] != 'D')
800 drive->doorlocking = 1;
803 (void)set_lba_addressing(drive, 1);
805 if (drive->addressing == 1) {
808 if (max_s > hwif->rqsize)
809 max_s = hwif->rqsize;
811 blk_queue_max_sectors(drive->queue, max_s);
814 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
815 drive->queue->max_sectors / 2);
817 /* calculate drive capacity, and select LBA if possible */
818 init_idedisk_capacity(drive);
820 /* limit drive capacity to 137GB if LBA48 cannot be used */
821 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
822 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
823 "%llu sectors (%llu MB)\n",
824 drive->name, (unsigned long long)drive->capacity64,
825 sectors_to_MB(drive->capacity64));
826 drive->capacity64 = 1ULL << 28;
829 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
830 if (drive->capacity64 > 1ULL << 28) {
831 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
832 " will be used for accessing sectors "
833 "> %u\n", drive->name, 1 << 28);
835 drive->addressing = 0;
839 * if possible, give fdisk access to more of the drive,
840 * by correcting bios_cyls:
842 capacity = idedisk_capacity(drive);
844 if (!drive->forced_geom) {
846 if (idedisk_supports_lba48(drive->id)) {
848 drive->bios_sect = 63;
849 drive->bios_head = 255;
852 if (drive->bios_sect && drive->bios_head) {
853 unsigned int cap0 = capacity; /* truncate to 32 bits */
854 unsigned int cylsz, cyl;
856 if (cap0 != capacity)
857 drive->bios_cyl = 65535;
859 cylsz = drive->bios_sect * drive->bios_head;
863 if (cyl > drive->bios_cyl)
864 drive->bios_cyl = cyl;
868 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
869 drive->name, capacity, sectors_to_MB(capacity));
871 /* Only print cache size when it was specified */
872 if (id[ATA_ID_BUF_SIZE])
873 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
875 printk(KERN_CONT ", CHS=%d/%d/%d\n",
876 drive->bios_cyl, drive->bios_head, drive->bios_sect);
878 /* write cache enabled? */
879 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
882 write_cache(drive, 1);
885 static void ide_cacheflush_p(ide_drive_t *drive)
887 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
890 if (do_idedisk_flushcache(drive))
891 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
894 static void ide_disk_remove(ide_drive_t *drive)
896 struct ide_disk_obj *idkp = drive->driver_data;
897 struct gendisk *g = idkp->disk;
899 ide_proc_unregister_driver(drive, idkp->driver);
903 ide_cacheflush_p(drive);
908 static void ide_disk_release(struct kref *kref)
910 struct ide_disk_obj *idkp = to_ide_disk(kref);
911 ide_drive_t *drive = idkp->drive;
912 struct gendisk *g = idkp->disk;
914 drive->driver_data = NULL;
915 g->private_data = NULL;
920 static int ide_disk_probe(ide_drive_t *drive);
923 * On HPA drives the capacity needs to be
924 * reinitilized on resume otherwise the disk
925 * can not be used and a hard reset is required
927 static void ide_disk_resume(ide_drive_t *drive)
929 if (ata_id_hpa_enabled(drive->id))
930 init_idedisk_capacity(drive);
933 static void ide_device_shutdown(ide_drive_t *drive)
936 /* On Alpha, halt(8) doesn't actually turn the machine off,
937 it puts you into the sort of firmware monitor. Typically,
938 it's used to boot another kernel image, so it's not much
939 different from reboot(8). Therefore, we don't need to
940 spin down the disk in this case, especially since Alpha
941 firmware doesn't handle disks in standby mode properly.
942 On the other hand, it's reasonably safe to turn the power
943 off when the shutdown process reaches the firmware prompt,
944 as the firmware initialization takes rather long time -
945 at least 10 seconds, which should be sufficient for
946 the disk to expire its write cache. */
947 if (system_state != SYSTEM_POWER_OFF) {
949 if (system_state == SYSTEM_RESTART) {
951 ide_cacheflush_p(drive);
955 printk(KERN_INFO "Shutdown: %s\n", drive->name);
957 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
960 static ide_driver_t idedisk_driver = {
962 .owner = THIS_MODULE,
964 .bus = &ide_bus_type,
966 .probe = ide_disk_probe,
967 .remove = ide_disk_remove,
968 .resume = ide_disk_resume,
969 .shutdown = ide_device_shutdown,
970 .version = IDEDISK_VERSION,
972 .supports_dsc_overlap = 0,
973 .do_request = ide_do_rw_disk,
974 .end_request = ide_end_request,
975 .error = __ide_error,
976 #ifdef CONFIG_IDE_PROC_FS
977 .proc = idedisk_proc,
981 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
985 memset(&task, 0, sizeof(task));
986 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
987 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
989 return ide_no_data_taskfile(drive, &task);
992 static int idedisk_open(struct inode *inode, struct file *filp)
994 struct gendisk *disk = inode->i_bdev->bd_disk;
995 struct ide_disk_obj *idkp;
998 idkp = ide_disk_get(disk);
1002 drive = idkp->drive;
1006 if (drive->removable && idkp->openers == 1) {
1007 check_disk_change(inode->i_bdev);
1009 * Ignore the return code from door_lock,
1010 * since the open() has already succeeded,
1011 * and the door_lock is irrelevant at this point.
1013 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1014 drive->doorlocking = 0;
1019 static int idedisk_release(struct inode *inode, struct file *filp)
1021 struct gendisk *disk = inode->i_bdev->bd_disk;
1022 struct ide_disk_obj *idkp = ide_disk_g(disk);
1023 ide_drive_t *drive = idkp->drive;
1025 if (idkp->openers == 1)
1026 ide_cacheflush_p(drive);
1028 if (drive->removable && idkp->openers == 1) {
1029 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1030 drive->doorlocking = 0;
1040 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1042 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1043 ide_drive_t *drive = idkp->drive;
1045 geo->heads = drive->bios_head;
1046 geo->sectors = drive->bios_sect;
1047 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1051 static int idedisk_ioctl(struct inode *inode, struct file *file,
1052 unsigned int cmd, unsigned long arg)
1054 unsigned long flags;
1055 struct block_device *bdev = inode->i_bdev;
1056 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1057 ide_drive_t *drive = idkp->drive;
1058 int err, (*setfunc)(ide_drive_t *, int);
1062 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1063 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1064 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1065 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1066 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1067 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1068 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1069 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1070 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1071 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1074 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1077 mutex_lock(&ide_setting_mtx);
1078 spin_lock_irqsave(&ide_lock, flags);
1080 spin_unlock_irqrestore(&ide_lock, flags);
1081 mutex_unlock(&ide_setting_mtx);
1082 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1085 if (bdev != bdev->bd_contains)
1088 if (!capable(CAP_SYS_ADMIN))
1091 mutex_lock(&ide_setting_mtx);
1092 err = setfunc(drive, arg);
1093 mutex_unlock(&ide_setting_mtx);
1099 static int idedisk_media_changed(struct gendisk *disk)
1101 struct ide_disk_obj *idkp = ide_disk_g(disk);
1102 ide_drive_t *drive = idkp->drive;
1104 /* do not scan partitions twice if this is a removable device */
1105 if (drive->attach) {
1109 /* if removable, always assume it was changed */
1110 return drive->removable;
1113 static int idedisk_revalidate_disk(struct gendisk *disk)
1115 struct ide_disk_obj *idkp = ide_disk_g(disk);
1116 set_capacity(disk, idedisk_capacity(idkp->drive));
1120 static struct block_device_operations idedisk_ops = {
1121 .owner = THIS_MODULE,
1122 .open = idedisk_open,
1123 .release = idedisk_release,
1124 .ioctl = idedisk_ioctl,
1125 .getgeo = idedisk_getgeo,
1126 .media_changed = idedisk_media_changed,
1127 .revalidate_disk = idedisk_revalidate_disk
1130 MODULE_DESCRIPTION("ATA DISK Driver");
1132 static int ide_disk_probe(ide_drive_t *drive)
1134 struct ide_disk_obj *idkp;
1137 /* strstr("foo", "") is non-NULL */
1138 if (!strstr("ide-disk", drive->driver_req))
1141 if (drive->media != ide_disk)
1144 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1148 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
1152 ide_init_disk(g, drive);
1154 ide_proc_register_driver(drive, &idedisk_driver);
1156 kref_init(&idkp->kref);
1158 idkp->drive = drive;
1159 idkp->driver = &idedisk_driver;
1162 g->private_data = &idkp->driver;
1164 drive->driver_data = idkp;
1166 idedisk_setup(drive);
1167 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1168 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1169 drive->name, drive->head);
1174 g->minors = IDE_DISK_MINORS;
1175 g->driverfs_dev = &drive->gendev;
1176 g->flags |= GENHD_FL_EXT_DEVT;
1177 if (drive->removable)
1178 g->flags |= GENHD_FL_REMOVABLE;
1179 set_capacity(g, idedisk_capacity(drive));
1180 g->fops = &idedisk_ops;
1190 static void __exit idedisk_exit(void)
1192 driver_unregister(&idedisk_driver.gen_driver);
1195 static int __init idedisk_init(void)
1197 return driver_register(&idedisk_driver.gen_driver);
1200 MODULE_ALIAS("ide:*m-disk*");
1201 module_init(idedisk_init);
1202 module_exit(idedisk_exit);
1203 MODULE_LICENSE("GPL");