2 * linux/drivers/ide/ide-disk.c Version 1.18 Mar 05, 2003
4 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below)
5 * Copyright (C) 1998-2002 Linux ATA Development
6 * Andre Hedrick <andre@linux-ide.org>
7 * Copyright (C) 2003 Red Hat <alan@redhat.com>
11 * Mostly written by Mark Lord <mlord@pobox.com>
12 * and Gadi Oxman <gadio@netvision.net.il>
13 * and Andre Hedrick <andre@linux-ide.org>
15 * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
18 #define IDEDISK_VERSION "1.18"
22 #include <linux/module.h>
23 #include <linux/types.h>
24 #include <linux/string.h>
25 #include <linux/kernel.h>
26 #include <linux/timer.h>
28 #include <linux/interrupt.h>
29 #include <linux/major.h>
30 #include <linux/errno.h>
31 #include <linux/genhd.h>
32 #include <linux/slab.h>
33 #include <linux/delay.h>
34 #include <linux/mutex.h>
35 #include <linux/leds.h>
39 #include <linux/ide.h>
41 #include <asm/byteorder.h>
43 #include <asm/uaccess.h>
45 #include <asm/div64.h>
52 unsigned int openers; /* protected by BKL for now */
55 static DEFINE_MUTEX(idedisk_ref_mutex);
57 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
59 #define ide_disk_g(disk) \
60 container_of((disk)->private_data, struct ide_disk_obj, driver)
62 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
64 struct ide_disk_obj *idkp = NULL;
66 mutex_lock(&idedisk_ref_mutex);
67 idkp = ide_disk_g(disk);
69 kref_get(&idkp->kref);
70 mutex_unlock(&idedisk_ref_mutex);
74 static void ide_disk_release(struct kref *);
76 static void ide_disk_put(struct ide_disk_obj *idkp)
78 mutex_lock(&idedisk_ref_mutex);
79 kref_put(&idkp->kref, ide_disk_release);
80 mutex_unlock(&idedisk_ref_mutex);
84 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
85 * value for this drive (from its reported identification information).
87 * Returns: 1 if lba_capacity looks sensible
90 * It is called only once for each drive.
92 static int lba_capacity_is_ok (struct hd_driveid *id)
94 unsigned long lba_sects, chs_sects, head, tail;
96 /* No non-LBA info .. so valid! */
101 * The ATA spec tells large drives to return
102 * C/H/S = 16383/16/63 independent of their size.
103 * Some drives can be jumpered to use 15 heads instead of 16.
104 * Some drives can be jumpered to use 4092 cyls instead of 16383.
106 if ((id->cyls == 16383
107 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
109 (id->heads == 15 || id->heads == 16) &&
110 (id->lba_capacity >= 16383*63*id->heads))
113 lba_sects = id->lba_capacity;
114 chs_sects = id->cyls * id->heads * id->sectors;
116 /* perform a rough sanity check on lba_sects: within 10% is OK */
117 if ((lba_sects - chs_sects) < chs_sects/10)
120 /* some drives have the word order reversed */
121 head = ((lba_sects >> 16) & 0xffff);
122 tail = (lba_sects & 0xffff);
123 lba_sects = (head | (tail << 16));
124 if ((lba_sects - chs_sects) < chs_sects/10) {
125 id->lba_capacity = lba_sects;
126 return 1; /* lba_capacity is (now) good */
129 return 0; /* lba_capacity value may be bad */
133 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
134 * using LBA if supported, or CHS otherwise, to address sectors.
136 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
138 ide_hwif_t *hwif = HWIF(drive);
139 unsigned int dma = drive->using_dma;
140 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
141 u8 command = WIN_NOP;
142 ata_nsector_t nsectors;
144 struct ide_taskfile *tf = &task.tf;
146 nsectors.all = (u16) rq->nr_sectors;
148 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
149 if (block + rq->nr_sectors > 1ULL << 28)
156 ide_init_sg_cmd(drive, rq);
157 ide_map_sg(drive, rq);
160 memset(&task, 0, sizeof(task));
161 task.tf_flags = IDE_TFLAG_NO_SELECT_MASK; /* FIXME? */
163 if (drive->select.b.lba) {
165 pr_debug("%s: LBA=0x%012llx\n", drive->name,
166 (unsigned long long)block);
168 tf->hob_nsect = nsectors.b.high;
169 tf->hob_lbal = (u8)(block >> 24);
170 if (sizeof(block) != 4) {
171 tf->hob_lbam = (u8)((u64)block >> 32);
172 tf->hob_lbah = (u8)((u64)block >> 40);
175 tf->nsect = nsectors.b.low;
176 tf->lbal = (u8) block;
177 tf->lbam = (u8)(block >> 8);
178 tf->lbah = (u8)(block >> 16);
180 printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
181 drive->name, tf->hob_nsect, tf->nsect,
182 tf->hob_lbah, tf->hob_lbam, tf->hob_lbal,
183 tf->lbah, tf->lbam, tf->lbal);
185 task.tf_flags |= IDE_TFLAG_LBA48;
187 tf->nsect = nsectors.b.low;
189 tf->lbam = block >>= 8;
190 tf->lbah = block >>= 8;
191 tf->device = (block >> 8) & 0xf;
194 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.b.low;
209 ide_tf_load(drive, &task);
212 if (!hwif->dma_setup(drive)) {
213 if (rq_data_dir(rq)) {
214 command = lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
216 command = lba48 ? WIN_WRITE_EXT: WIN_WRITE;
218 command = lba48 ? WIN_READDMA_EXT : WIN_READDMA;
220 command = lba48 ? WIN_READ_EXT: WIN_READ;
222 hwif->dma_exec_cmd(drive, command);
223 hwif->dma_start(drive);
226 /* fallback to PIO */
227 ide_init_sg_cmd(drive, rq);
230 if (rq_data_dir(rq) == READ) {
232 if (drive->mult_count) {
233 hwif->data_phase = TASKFILE_MULTI_IN;
234 command = lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
236 hwif->data_phase = TASKFILE_IN;
237 command = lba48 ? WIN_READ_EXT : WIN_READ;
240 ide_execute_command(drive, command, &task_in_intr, WAIT_CMD, NULL);
243 if (drive->mult_count) {
244 hwif->data_phase = TASKFILE_MULTI_OUT;
245 command = lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
247 hwif->data_phase = TASKFILE_OUT;
248 command = lba48 ? WIN_WRITE_EXT : WIN_WRITE;
251 /* FIXME: ->OUTBSYNC ? */
252 hwif->OUTB(command, IDE_COMMAND_REG);
254 return pre_task_out_intr(drive, rq);
259 * 268435455 == 137439 MB or 28bit limit
260 * 320173056 == 163929 MB or 48bit addressing
261 * 1073741822 == 549756 MB or 48bit addressing fake drive
264 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
266 ide_hwif_t *hwif = HWIF(drive);
268 BUG_ON(drive->blocked);
270 if (!blk_fs_request(rq)) {
271 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
272 ide_end_request(drive, 0, 0);
276 ledtrig_ide_activity();
278 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
279 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
280 (unsigned long long)block, rq->nr_sectors,
281 (unsigned long)rq->buffer);
284 hwif->rw_disk(drive, rq);
286 return __ide_do_rw_disk(drive, rq, block);
290 * Queries for true maximum capacity of the drive.
291 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
293 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
296 struct ide_taskfile *tf = &args.tf;
299 /* Create IDE/ATA command request structure */
300 memset(&args, 0, sizeof(ide_task_t));
302 tf->command = WIN_READ_NATIVE_MAX_EXT;
304 tf->command = WIN_READ_NATIVE_MAX;
305 tf->device = ATA_LBA;
306 /* submit command request */
307 ide_no_data_taskfile(drive, &args);
309 /* if OK, compute maximum address value */
310 if ((tf->status & 0x01) == 0) {
314 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
317 high = tf->device & 0xf;
318 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
319 addr = ((__u64)high << 24) | low;
320 addr++; /* since the return value is (maxlba - 1), we add 1 */
326 * Sets maximum virtual LBA address of the drive.
327 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
329 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
332 struct ide_taskfile *tf = &args.tf;
336 /* Create IDE/ATA command request structure */
337 memset(&args, 0, sizeof(ide_task_t));
338 tf->lbal = (addr_req >> 0) & 0xff;
339 tf->lbam = (addr_req >>= 8) & 0xff;
340 tf->lbah = (addr_req >>= 8) & 0xff;
342 tf->hob_lbal = (addr_req >>= 8) & 0xff;
343 tf->hob_lbam = (addr_req >>= 8) & 0xff;
344 tf->hob_lbah = (addr_req >>= 8) & 0xff;
345 tf->command = WIN_SET_MAX_EXT;
347 tf->device = (addr_req >>= 8) & 0x0f;
348 tf->command = WIN_SET_MAX;
350 tf->device |= ATA_LBA;
351 /* submit command request */
352 ide_no_data_taskfile(drive, &args);
353 /* if OK, compute maximum address value */
354 if ((tf->status & 0x01) == 0) {
358 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
361 high = tf->device & 0xf;
362 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
363 addr_set = ((__u64)high << 24) | low;
369 static unsigned long long sectors_to_MB(unsigned long long n)
371 n <<= 9; /* make it bytes */
372 do_div(n, 1000000); /* make it MB */
377 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
378 * so on non-buggy drives we need test only one.
379 * However, we should also check whether these fields are valid.
381 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
383 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
389 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
391 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
392 && id->lba_capacity_2;
396 * Some disks report total number of sectors instead of
397 * maximum sector address. We list them here.
399 static const struct drive_list_entry hpa_list[] = {
400 { "ST340823A", NULL },
401 { "ST320413A", NULL },
405 static void idedisk_check_hpa(ide_drive_t *drive)
407 unsigned long long capacity, set_max;
408 int lba48 = idedisk_supports_lba48(drive->id);
410 capacity = drive->capacity64;
412 set_max = idedisk_read_native_max_address(drive, lba48);
414 if (ide_in_drive_list(drive->id, hpa_list)) {
416 * Since we are inclusive wrt to firmware revisions do this
417 * extra check and apply the workaround only when needed.
419 if (set_max == capacity + 1)
423 if (set_max <= capacity)
426 printk(KERN_INFO "%s: Host Protected Area detected.\n"
427 "\tcurrent capacity is %llu sectors (%llu MB)\n"
428 "\tnative capacity is %llu sectors (%llu MB)\n",
430 capacity, sectors_to_MB(capacity),
431 set_max, sectors_to_MB(set_max));
433 set_max = idedisk_set_max_address(drive, set_max, lba48);
436 drive->capacity64 = set_max;
437 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
443 * Compute drive->capacity, the full capacity of the drive
444 * Called with drive->id != NULL.
446 * To compute capacity, this uses either of
448 * 1. CHS value set by user (whatever user sets will be trusted)
449 * 2. LBA value from target drive (require new ATA feature)
450 * 3. LBA value from system BIOS (new one is OK, old one may break)
451 * 4. CHS value from system BIOS (traditional style)
453 * in above order (i.e., if value of higher priority is available,
454 * reset will be ignored).
456 static void init_idedisk_capacity (ide_drive_t *drive)
458 struct hd_driveid *id = drive->id;
460 * If this drive supports the Host Protected Area feature set,
461 * then we may need to change our opinion about the drive's capacity.
463 int hpa = idedisk_supports_hpa(id);
465 if (idedisk_supports_lba48(id)) {
466 /* drive speaks 48-bit LBA */
467 drive->select.b.lba = 1;
468 drive->capacity64 = id->lba_capacity_2;
470 idedisk_check_hpa(drive);
471 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
472 /* drive speaks 28-bit LBA */
473 drive->select.b.lba = 1;
474 drive->capacity64 = id->lba_capacity;
476 idedisk_check_hpa(drive);
478 /* drive speaks boring old 28-bit CHS */
479 drive->capacity64 = drive->cyl * drive->head * drive->sect;
483 static sector_t idedisk_capacity (ide_drive_t *drive)
485 return drive->capacity64 - drive->sect0;
488 #ifdef CONFIG_IDE_PROC_FS
489 static int smart_enable(ide_drive_t *drive)
492 struct ide_taskfile *tf = &args.tf;
494 memset(&args, 0, sizeof(ide_task_t));
495 tf->feature = SMART_ENABLE;
496 tf->lbam = SMART_LCYL_PASS;
497 tf->lbah = SMART_HCYL_PASS;
498 tf->command = WIN_SMART;
499 return ide_no_data_taskfile(drive, &args);
502 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
505 struct ide_taskfile *tf = &args.tf;
507 memset(&args, 0, sizeof(ide_task_t));
508 tf->feature = sub_cmd;
510 tf->lbam = SMART_LCYL_PASS;
511 tf->lbah = SMART_HCYL_PASS;
512 tf->command = WIN_SMART;
513 args.command_type = IDE_DRIVE_TASK_IN;
514 args.data_phase = TASKFILE_IN;
515 args.handler = &task_in_intr;
516 (void) smart_enable(drive);
517 return ide_raw_taskfile(drive, &args, buf);
520 static int proc_idedisk_read_cache
521 (char *page, char **start, off_t off, int count, int *eof, void *data)
523 ide_drive_t *drive = (ide_drive_t *) data;
528 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
530 len = sprintf(out,"(none)\n");
531 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
534 static int proc_idedisk_read_capacity
535 (char *page, char **start, off_t off, int count, int *eof, void *data)
537 ide_drive_t*drive = (ide_drive_t *)data;
540 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
541 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
544 static int proc_idedisk_read_smart_thresholds
545 (char *page, char **start, off_t off, int count, int *eof, void *data)
547 ide_drive_t *drive = (ide_drive_t *)data;
550 if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
551 unsigned short *val = (unsigned short *) page;
552 char *out = ((char *)val) + (SECTOR_WORDS * 4);
555 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
557 } while (i < (SECTOR_WORDS * 2));
560 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
563 static int proc_idedisk_read_smart_values
564 (char *page, char **start, off_t off, int count, int *eof, void *data)
566 ide_drive_t *drive = (ide_drive_t *)data;
569 if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
570 unsigned short *val = (unsigned short *) page;
571 char *out = ((char *)val) + (SECTOR_WORDS * 4);
574 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
576 } while (i < (SECTOR_WORDS * 2));
579 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
582 static ide_proc_entry_t idedisk_proc[] = {
583 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
584 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
585 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
586 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
587 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
588 { NULL, 0, NULL, NULL }
590 #endif /* CONFIG_IDE_PROC_FS */
592 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
594 ide_drive_t *drive = q->queuedata;
596 memset(rq->cmd, 0, sizeof(rq->cmd));
598 if (ide_id_has_flush_cache_ext(drive->id) &&
599 (drive->capacity64 >= (1UL << 28)))
600 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
602 rq->cmd[0] = WIN_FLUSH_CACHE;
605 rq->cmd_type = REQ_TYPE_ATA_TASK;
606 rq->cmd_flags |= REQ_SOFTBARRIER;
607 rq->buffer = rq->cmd;
611 * This is tightly woven into the driver->do_special can not touch.
612 * DON'T do it again until a total personality rewrite is committed.
614 static int set_multcount(ide_drive_t *drive, int arg)
618 if (arg < 0 || arg > drive->id->max_multsect)
621 if (drive->special.b.set_multmode)
623 ide_init_drive_cmd (&rq);
624 rq.cmd_type = REQ_TYPE_ATA_CMD;
625 drive->mult_req = arg;
626 drive->special.b.set_multmode = 1;
627 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
628 return (drive->mult_count == arg) ? 0 : -EIO;
631 static int set_nowerr(ide_drive_t *drive, int arg)
633 if (arg < 0 || arg > 1)
636 if (ide_spin_wait_hwgroup(drive))
639 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
640 spin_unlock_irq(&ide_lock);
644 static void update_ordered(ide_drive_t *drive)
646 struct hd_driveid *id = drive->id;
647 unsigned ordered = QUEUE_ORDERED_NONE;
648 prepare_flush_fn *prep_fn = NULL;
651 unsigned long long capacity;
654 * We must avoid issuing commands a drive does not
655 * understand or we may crash it. We check flush cache
656 * is supported. We also check we have the LBA48 flush
657 * cache if the drive capacity is too large. By this
658 * time we have trimmed the drive capacity if LBA48 is
659 * not available so we don't need to recheck that.
661 capacity = idedisk_capacity(drive);
662 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
663 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
664 ide_id_has_flush_cache_ext(id));
666 printk(KERN_INFO "%s: cache flushes %ssupported\n",
667 drive->name, barrier ? "" : "not ");
670 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
671 prep_fn = idedisk_prepare_flush;
674 ordered = QUEUE_ORDERED_DRAIN;
676 blk_queue_ordered(drive->queue, ordered, prep_fn);
679 static int write_cache(ide_drive_t *drive, int arg)
684 if (arg < 0 || arg > 1)
687 if (ide_id_has_flush_cache(drive->id)) {
688 memset(&args, 0, sizeof(ide_task_t));
689 args.tf.feature = arg ?
690 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
691 args.tf.command = WIN_SETFEATURES;
692 err = ide_no_data_taskfile(drive, &args);
697 update_ordered(drive);
702 static int do_idedisk_flushcache (ide_drive_t *drive)
706 memset(&args, 0, sizeof(ide_task_t));
707 if (ide_id_has_flush_cache_ext(drive->id))
708 args.tf.command = WIN_FLUSH_CACHE_EXT;
710 args.tf.command = WIN_FLUSH_CACHE;
711 return ide_no_data_taskfile(drive, &args);
714 static int set_acoustic (ide_drive_t *drive, int arg)
718 if (arg < 0 || arg > 254)
721 memset(&args, 0, sizeof(ide_task_t));
722 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
724 args.tf.command = WIN_SETFEATURES;
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 struct hd_driveid *id = drive->id;
757 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
758 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
759 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
760 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
761 ide_add_setting(drive, "bswap", SETTING_READ, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
762 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount);
763 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
764 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
765 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
766 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
767 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
768 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
771 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
774 static void idedisk_setup (ide_drive_t *drive)
776 ide_hwif_t *hwif = drive->hwif;
777 struct hd_driveid *id = drive->id;
778 unsigned long long capacity;
780 idedisk_add_settings(drive);
782 if (drive->id_read == 0)
785 if (drive->removable) {
787 * Removable disks (eg. SYQUEST); ignore 'WD' drives
789 if (id->model[0] != 'W' || id->model[1] != 'D') {
790 drive->doorlocking = 1;
794 (void)set_lba_addressing(drive, 1);
796 if (drive->addressing == 1) {
799 if (max_s > hwif->rqsize)
800 max_s = hwif->rqsize;
802 blk_queue_max_sectors(drive->queue, max_s);
805 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
807 /* calculate drive capacity, and select LBA if possible */
808 init_idedisk_capacity (drive);
810 /* limit drive capacity to 137GB if LBA48 cannot be used */
811 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
812 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
813 "%llu sectors (%llu MB)\n",
814 drive->name, (unsigned long long)drive->capacity64,
815 sectors_to_MB(drive->capacity64));
816 drive->capacity64 = 1ULL << 28;
819 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
820 if (drive->capacity64 > 1ULL << 28) {
821 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
822 " be used for accessing sectors > %u\n",
823 drive->name, 1 << 28);
825 drive->addressing = 0;
829 * if possible, give fdisk access to more of the drive,
830 * by correcting bios_cyls:
832 capacity = idedisk_capacity (drive);
833 if (!drive->forced_geom) {
835 if (idedisk_supports_lba48(drive->id)) {
837 drive->bios_sect = 63;
838 drive->bios_head = 255;
841 if (drive->bios_sect && drive->bios_head) {
842 unsigned int cap0 = capacity; /* truncate to 32 bits */
843 unsigned int cylsz, cyl;
845 if (cap0 != capacity)
846 drive->bios_cyl = 65535;
848 cylsz = drive->bios_sect * drive->bios_head;
852 if (cyl > drive->bios_cyl)
853 drive->bios_cyl = cyl;
857 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
858 drive->name, capacity, sectors_to_MB(capacity));
860 /* Only print cache size when it was specified */
862 printk (" w/%dKiB Cache", id->buf_size/2);
864 printk(KERN_CONT ", CHS=%d/%d/%d\n",
865 drive->bios_cyl, drive->bios_head, drive->bios_sect);
867 /* write cache enabled? */
868 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
871 write_cache(drive, 1);
874 static void ide_cacheflush_p(ide_drive_t *drive)
876 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
879 if (do_idedisk_flushcache(drive))
880 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
883 static void ide_disk_remove(ide_drive_t *drive)
885 struct ide_disk_obj *idkp = drive->driver_data;
886 struct gendisk *g = idkp->disk;
888 ide_proc_unregister_driver(drive, idkp->driver);
892 ide_cacheflush_p(drive);
897 static void ide_disk_release(struct kref *kref)
899 struct ide_disk_obj *idkp = to_ide_disk(kref);
900 ide_drive_t *drive = idkp->drive;
901 struct gendisk *g = idkp->disk;
903 drive->driver_data = NULL;
904 g->private_data = NULL;
909 static int ide_disk_probe(ide_drive_t *drive);
912 * On HPA drives the capacity needs to be
913 * reinitilized on resume otherwise the disk
914 * can not be used and a hard reset is required
916 static void ide_disk_resume(ide_drive_t *drive)
918 if (idedisk_supports_hpa(drive->id))
919 init_idedisk_capacity(drive);
922 static void ide_device_shutdown(ide_drive_t *drive)
925 /* On Alpha, halt(8) doesn't actually turn the machine off,
926 it puts you into the sort of firmware monitor. Typically,
927 it's used to boot another kernel image, so it's not much
928 different from reboot(8). Therefore, we don't need to
929 spin down the disk in this case, especially since Alpha
930 firmware doesn't handle disks in standby mode properly.
931 On the other hand, it's reasonably safe to turn the power
932 off when the shutdown process reaches the firmware prompt,
933 as the firmware initialization takes rather long time -
934 at least 10 seconds, which should be sufficient for
935 the disk to expire its write cache. */
936 if (system_state != SYSTEM_POWER_OFF) {
938 if (system_state == SYSTEM_RESTART) {
940 ide_cacheflush_p(drive);
944 printk("Shutdown: %s\n", drive->name);
945 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
948 static ide_driver_t idedisk_driver = {
950 .owner = THIS_MODULE,
952 .bus = &ide_bus_type,
954 .probe = ide_disk_probe,
955 .remove = ide_disk_remove,
956 .resume = ide_disk_resume,
957 .shutdown = ide_device_shutdown,
958 .version = IDEDISK_VERSION,
960 .supports_dsc_overlap = 0,
961 .do_request = ide_do_rw_disk,
962 .end_request = ide_end_request,
963 .error = __ide_error,
964 .abort = __ide_abort,
965 #ifdef CONFIG_IDE_PROC_FS
966 .proc = idedisk_proc,
970 static int idedisk_open(struct inode *inode, struct file *filp)
972 struct gendisk *disk = inode->i_bdev->bd_disk;
973 struct ide_disk_obj *idkp;
976 if (!(idkp = ide_disk_get(disk)))
983 if (drive->removable && idkp->openers == 1) {
985 memset(&args, 0, sizeof(ide_task_t));
986 args.tf.command = WIN_DOORLOCK;
987 check_disk_change(inode->i_bdev);
989 * Ignore the return code from door_lock,
990 * since the open() has already succeeded,
991 * and the door_lock is irrelevant at this point.
993 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
994 drive->doorlocking = 0;
999 static int idedisk_release(struct inode *inode, struct file *filp)
1001 struct gendisk *disk = inode->i_bdev->bd_disk;
1002 struct ide_disk_obj *idkp = ide_disk_g(disk);
1003 ide_drive_t *drive = idkp->drive;
1005 if (idkp->openers == 1)
1006 ide_cacheflush_p(drive);
1008 if (drive->removable && idkp->openers == 1) {
1010 memset(&args, 0, sizeof(ide_task_t));
1011 args.tf.command = WIN_DOORUNLOCK;
1012 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
1013 drive->doorlocking = 0;
1023 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1025 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1026 ide_drive_t *drive = idkp->drive;
1028 geo->heads = drive->bios_head;
1029 geo->sectors = drive->bios_sect;
1030 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1034 static int idedisk_ioctl(struct inode *inode, struct file *file,
1035 unsigned int cmd, unsigned long arg)
1037 unsigned long flags;
1038 struct block_device *bdev = inode->i_bdev;
1039 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1040 ide_drive_t *drive = idkp->drive;
1041 int err, (*setfunc)(ide_drive_t *, int);
1045 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1046 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1047 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1048 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1049 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1050 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1051 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1052 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1053 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1054 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1057 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1060 mutex_lock(&ide_setting_mtx);
1061 spin_lock_irqsave(&ide_lock, flags);
1063 spin_unlock_irqrestore(&ide_lock, flags);
1064 mutex_unlock(&ide_setting_mtx);
1065 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1068 if (bdev != bdev->bd_contains)
1071 if (!capable(CAP_SYS_ADMIN))
1074 mutex_lock(&ide_setting_mtx);
1075 err = setfunc(drive, arg);
1076 mutex_unlock(&ide_setting_mtx);
1082 static int idedisk_media_changed(struct gendisk *disk)
1084 struct ide_disk_obj *idkp = ide_disk_g(disk);
1085 ide_drive_t *drive = idkp->drive;
1087 /* do not scan partitions twice if this is a removable device */
1088 if (drive->attach) {
1092 /* if removable, always assume it was changed */
1093 return drive->removable;
1096 static int idedisk_revalidate_disk(struct gendisk *disk)
1098 struct ide_disk_obj *idkp = ide_disk_g(disk);
1099 set_capacity(disk, idedisk_capacity(idkp->drive));
1103 static struct block_device_operations idedisk_ops = {
1104 .owner = THIS_MODULE,
1105 .open = idedisk_open,
1106 .release = idedisk_release,
1107 .ioctl = idedisk_ioctl,
1108 .getgeo = idedisk_getgeo,
1109 .media_changed = idedisk_media_changed,
1110 .revalidate_disk= idedisk_revalidate_disk
1113 MODULE_DESCRIPTION("ATA DISK Driver");
1115 static int ide_disk_probe(ide_drive_t *drive)
1117 struct ide_disk_obj *idkp;
1120 /* strstr("foo", "") is non-NULL */
1121 if (!strstr("ide-disk", drive->driver_req))
1123 if (!drive->present)
1125 if (drive->media != ide_disk)
1128 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1132 g = alloc_disk_node(1 << PARTN_BITS,
1133 hwif_to_node(drive->hwif));
1137 ide_init_disk(g, drive);
1139 ide_proc_register_driver(drive, &idedisk_driver);
1141 kref_init(&idkp->kref);
1143 idkp->drive = drive;
1144 idkp->driver = &idedisk_driver;
1147 g->private_data = &idkp->driver;
1149 drive->driver_data = idkp;
1151 idedisk_setup(drive);
1152 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1153 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1154 drive->name, drive->head);
1159 g->minors = 1 << PARTN_BITS;
1160 g->driverfs_dev = &drive->gendev;
1161 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1162 set_capacity(g, idedisk_capacity(drive));
1163 g->fops = &idedisk_ops;
1173 static void __exit idedisk_exit (void)
1175 driver_unregister(&idedisk_driver.gen_driver);
1178 static int __init idedisk_init(void)
1180 return driver_register(&idedisk_driver.gen_driver);
1183 MODULE_ALIAS("ide:*m-disk*");
1184 module_init(idedisk_init);
1185 module_exit(idedisk_exit);
1186 MODULE_LICENSE("GPL");