PCI: add an option to allow ASPM enabled forcibly
[linux-2.6/next.git] / drivers / ide / ide-disk.c
blob28d85b410f7ce03361ddec4c957c930a9aa08518
1 /*
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
7 */
9 /*
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>
24 #include <linux/mm.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>
34 #define _IDE_DISK
36 #include <linux/ide.h>
38 #include <asm/byteorder.h>
39 #include <asm/irq.h>
40 #include <asm/uaccess.h>
41 #include <asm/io.h>
42 #include <asm/div64.h>
44 struct ide_disk_obj {
45 ide_drive_t *drive;
46 ide_driver_t *driver;
47 struct gendisk *disk;
48 struct kref kref;
49 unsigned int openers; /* protected by BKL for now */
52 static DEFINE_MUTEX(idedisk_ref_mutex);
54 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
56 #define ide_disk_g(disk) \
57 container_of((disk)->private_data, struct ide_disk_obj, driver)
59 static void ide_disk_release(struct kref *);
61 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
63 struct ide_disk_obj *idkp = NULL;
65 mutex_lock(&idedisk_ref_mutex);
66 idkp = ide_disk_g(disk);
67 if (idkp) {
68 kref_get(&idkp->kref);
69 if (ide_device_get(idkp->drive)) {
70 kref_put(&idkp->kref, ide_disk_release);
71 idkp = NULL;
74 mutex_unlock(&idedisk_ref_mutex);
75 return idkp;
78 static void ide_disk_put(struct ide_disk_obj *idkp)
80 mutex_lock(&idedisk_ref_mutex);
81 ide_device_put(idkp->drive);
82 kref_put(&idkp->kref, ide_disk_release);
83 mutex_unlock(&idedisk_ref_mutex);
87 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
88 * value for this drive (from its reported identification information).
90 * Returns: 1 if lba_capacity looks sensible
91 * 0 otherwise
93 * It is called only once for each drive.
95 static int lba_capacity_is_ok(struct hd_driveid *id)
97 unsigned long lba_sects, chs_sects, head, tail;
99 /* No non-LBA info .. so valid! */
100 if (id->cyls == 0)
101 return 1;
104 * The ATA spec tells large drives to return
105 * C/H/S = 16383/16/63 independent of their size.
106 * Some drives can be jumpered to use 15 heads instead of 16.
107 * Some drives can be jumpered to use 4092 cyls instead of 16383.
109 if ((id->cyls == 16383
110 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
111 id->sectors == 63 &&
112 (id->heads == 15 || id->heads == 16) &&
113 (id->lba_capacity >= 16383*63*id->heads))
114 return 1;
116 lba_sects = id->lba_capacity;
117 chs_sects = id->cyls * id->heads * id->sectors;
119 /* perform a rough sanity check on lba_sects: within 10% is OK */
120 if ((lba_sects - chs_sects) < chs_sects/10)
121 return 1;
123 /* some drives have the word order reversed */
124 head = ((lba_sects >> 16) & 0xffff);
125 tail = (lba_sects & 0xffff);
126 lba_sects = (head | (tail << 16));
127 if ((lba_sects - chs_sects) < chs_sects/10) {
128 id->lba_capacity = lba_sects;
129 return 1; /* lba_capacity is (now) good */
132 return 0; /* lba_capacity value may be bad */
135 static const u8 ide_rw_cmds[] = {
136 WIN_MULTREAD,
137 WIN_MULTWRITE,
138 WIN_MULTREAD_EXT,
139 WIN_MULTWRITE_EXT,
140 WIN_READ,
141 WIN_WRITE,
142 WIN_READ_EXT,
143 WIN_WRITE_EXT,
144 WIN_READDMA,
145 WIN_WRITEDMA,
146 WIN_READDMA_EXT,
147 WIN_WRITEDMA_EXT,
150 static const u8 ide_data_phases[] = {
151 TASKFILE_MULTI_IN,
152 TASKFILE_MULTI_OUT,
153 TASKFILE_IN,
154 TASKFILE_OUT,
155 TASKFILE_IN_DMA,
156 TASKFILE_OUT_DMA,
159 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
161 u8 index, lba48, write;
163 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
164 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
166 if (dma)
167 index = 8;
168 else
169 index = drive->mult_count ? 0 : 4;
171 task->tf.command = ide_rw_cmds[index + lba48 + write];
173 if (dma)
174 index = 8; /* fixup index */
176 task->data_phase = ide_data_phases[index / 2 + write];
180 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
181 * using LBA if supported, or CHS otherwise, to address sectors.
183 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
184 sector_t block)
186 ide_hwif_t *hwif = HWIF(drive);
187 unsigned int dma = drive->using_dma;
188 u16 nsectors = (u16)rq->nr_sectors;
189 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
190 ide_task_t task;
191 struct ide_taskfile *tf = &task.tf;
192 ide_startstop_t rc;
194 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
195 if (block + rq->nr_sectors > 1ULL << 28)
196 dma = 0;
197 else
198 lba48 = 0;
201 if (!dma) {
202 ide_init_sg_cmd(drive, rq);
203 ide_map_sg(drive, rq);
206 memset(&task, 0, sizeof(task));
207 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
209 if (drive->select.b.lba) {
210 if (lba48) {
211 pr_debug("%s: LBA=0x%012llx\n", drive->name,
212 (unsigned long long)block);
214 tf->hob_nsect = (nsectors >> 8) & 0xff;
215 tf->hob_lbal = (u8)(block >> 24);
216 if (sizeof(block) != 4) {
217 tf->hob_lbam = (u8)((u64)block >> 32);
218 tf->hob_lbah = (u8)((u64)block >> 40);
221 tf->nsect = nsectors & 0xff;
222 tf->lbal = (u8) block;
223 tf->lbam = (u8)(block >> 8);
224 tf->lbah = (u8)(block >> 16);
226 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
227 } else {
228 tf->nsect = nsectors & 0xff;
229 tf->lbal = block;
230 tf->lbam = block >>= 8;
231 tf->lbah = block >>= 8;
232 tf->device = (block >> 8) & 0xf;
234 } else {
235 unsigned int sect, head, cyl, track;
237 track = (int)block / drive->sect;
238 sect = (int)block % drive->sect + 1;
239 head = track % drive->head;
240 cyl = track / drive->head;
242 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
244 tf->nsect = nsectors & 0xff;
245 tf->lbal = sect;
246 tf->lbam = cyl;
247 tf->lbah = cyl >> 8;
248 tf->device = head;
251 if (rq_data_dir(rq))
252 task.tf_flags |= IDE_TFLAG_WRITE;
254 ide_tf_set_cmd(drive, &task, dma);
255 if (!dma)
256 hwif->data_phase = task.data_phase;
257 task.rq = rq;
259 rc = do_rw_taskfile(drive, &task);
261 if (rc == ide_stopped && dma) {
262 /* fallback to PIO */
263 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
264 ide_tf_set_cmd(drive, &task, 0);
265 hwif->data_phase = task.data_phase;
266 ide_init_sg_cmd(drive, rq);
267 rc = do_rw_taskfile(drive, &task);
270 return rc;
274 * 268435455 == 137439 MB or 28bit limit
275 * 320173056 == 163929 MB or 48bit addressing
276 * 1073741822 == 549756 MB or 48bit addressing fake drive
279 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
280 sector_t block)
282 ide_hwif_t *hwif = HWIF(drive);
284 BUG_ON(drive->blocked);
286 if (!blk_fs_request(rq)) {
287 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
288 ide_end_request(drive, 0, 0);
289 return ide_stopped;
292 ledtrig_ide_activity();
294 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
295 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
296 (unsigned long long)block, rq->nr_sectors,
297 (unsigned long)rq->buffer);
299 if (hwif->rw_disk)
300 hwif->rw_disk(drive, rq);
302 return __ide_do_rw_disk(drive, rq, block);
306 * Queries for true maximum capacity of the drive.
307 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
309 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
311 ide_task_t args;
312 struct ide_taskfile *tf = &args.tf;
313 u64 addr = 0;
315 /* Create IDE/ATA command request structure */
316 memset(&args, 0, sizeof(ide_task_t));
317 if (lba48)
318 tf->command = WIN_READ_NATIVE_MAX_EXT;
319 else
320 tf->command = WIN_READ_NATIVE_MAX;
321 tf->device = ATA_LBA;
322 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
323 if (lba48)
324 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
325 /* submit command request */
326 ide_no_data_taskfile(drive, &args);
328 /* if OK, compute maximum address value */
329 if ((tf->status & 0x01) == 0)
330 addr = ide_get_lba_addr(tf, lba48) + 1;
332 return addr;
336 * Sets maximum virtual LBA address of the drive.
337 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
339 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
341 ide_task_t args;
342 struct ide_taskfile *tf = &args.tf;
343 u64 addr_set = 0;
345 addr_req--;
346 /* Create IDE/ATA command request structure */
347 memset(&args, 0, sizeof(ide_task_t));
348 tf->lbal = (addr_req >> 0) & 0xff;
349 tf->lbam = (addr_req >>= 8) & 0xff;
350 tf->lbah = (addr_req >>= 8) & 0xff;
351 if (lba48) {
352 tf->hob_lbal = (addr_req >>= 8) & 0xff;
353 tf->hob_lbam = (addr_req >>= 8) & 0xff;
354 tf->hob_lbah = (addr_req >>= 8) & 0xff;
355 tf->command = WIN_SET_MAX_EXT;
356 } else {
357 tf->device = (addr_req >>= 8) & 0x0f;
358 tf->command = WIN_SET_MAX;
360 tf->device |= ATA_LBA;
361 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
362 if (lba48)
363 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
364 /* submit command request */
365 ide_no_data_taskfile(drive, &args);
366 /* if OK, compute maximum address value */
367 if ((tf->status & 0x01) == 0)
368 addr_set = ide_get_lba_addr(tf, lba48) + 1;
370 return addr_set;
373 static unsigned long long sectors_to_MB(unsigned long long n)
375 n <<= 9; /* make it bytes */
376 do_div(n, 1000000); /* make it MB */
377 return n;
381 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
382 * so on non-buggy drives we need test only one.
383 * However, we should also check whether these fields are valid.
385 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
387 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
391 * The same here.
393 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
395 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
396 && id->lba_capacity_2;
400 * Some disks report total number of sectors instead of
401 * maximum sector address. We list them here.
403 static const struct drive_list_entry hpa_list[] = {
404 { "ST340823A", NULL },
405 { "ST320413A", NULL },
406 { "ST310211A", NULL },
407 { NULL, NULL }
410 static void idedisk_check_hpa(ide_drive_t *drive)
412 unsigned long long capacity, set_max;
413 int lba48 = idedisk_supports_lba48(drive->id);
415 capacity = drive->capacity64;
417 set_max = idedisk_read_native_max_address(drive, lba48);
419 if (ide_in_drive_list(drive->id, hpa_list)) {
421 * Since we are inclusive wrt to firmware revisions do this
422 * extra check and apply the workaround only when needed.
424 if (set_max == capacity + 1)
425 set_max--;
428 if (set_max <= capacity)
429 return;
431 printk(KERN_INFO "%s: Host Protected Area detected.\n"
432 "\tcurrent capacity is %llu sectors (%llu MB)\n"
433 "\tnative capacity is %llu sectors (%llu MB)\n",
434 drive->name,
435 capacity, sectors_to_MB(capacity),
436 set_max, sectors_to_MB(set_max));
438 set_max = idedisk_set_max_address(drive, set_max, lba48);
440 if (set_max) {
441 drive->capacity64 = set_max;
442 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
443 drive->name);
448 * Compute drive->capacity, the full capacity of the drive
449 * Called with drive->id != NULL.
451 * To compute capacity, this uses either of
453 * 1. CHS value set by user (whatever user sets will be trusted)
454 * 2. LBA value from target drive (require new ATA feature)
455 * 3. LBA value from system BIOS (new one is OK, old one may break)
456 * 4. CHS value from system BIOS (traditional style)
458 * in above order (i.e., if value of higher priority is available,
459 * reset will be ignored).
461 static void init_idedisk_capacity(ide_drive_t *drive)
463 struct hd_driveid *id = drive->id;
465 * If this drive supports the Host Protected Area feature set,
466 * then we may need to change our opinion about the drive's capacity.
468 int hpa = idedisk_supports_hpa(id);
470 if (idedisk_supports_lba48(id)) {
471 /* drive speaks 48-bit LBA */
472 drive->select.b.lba = 1;
473 drive->capacity64 = id->lba_capacity_2;
474 if (hpa)
475 idedisk_check_hpa(drive);
476 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
477 /* drive speaks 28-bit LBA */
478 drive->select.b.lba = 1;
479 drive->capacity64 = id->lba_capacity;
480 if (hpa)
481 idedisk_check_hpa(drive);
482 } else {
483 /* drive speaks boring old 28-bit CHS */
484 drive->capacity64 = drive->cyl * drive->head * drive->sect;
488 static sector_t idedisk_capacity(ide_drive_t *drive)
490 return drive->capacity64 - drive->sect0;
493 #ifdef CONFIG_IDE_PROC_FS
494 static int smart_enable(ide_drive_t *drive)
496 ide_task_t args;
497 struct ide_taskfile *tf = &args.tf;
499 memset(&args, 0, sizeof(ide_task_t));
500 tf->feature = SMART_ENABLE;
501 tf->lbam = SMART_LCYL_PASS;
502 tf->lbah = SMART_HCYL_PASS;
503 tf->command = WIN_SMART;
504 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
505 return ide_no_data_taskfile(drive, &args);
508 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
510 ide_task_t args;
511 struct ide_taskfile *tf = &args.tf;
513 memset(&args, 0, sizeof(ide_task_t));
514 tf->feature = sub_cmd;
515 tf->nsect = 0x01;
516 tf->lbam = SMART_LCYL_PASS;
517 tf->lbah = SMART_HCYL_PASS;
518 tf->command = WIN_SMART;
519 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
520 args.data_phase = TASKFILE_IN;
521 (void) smart_enable(drive);
522 return ide_raw_taskfile(drive, &args, buf, 1);
525 static int proc_idedisk_read_cache
526 (char *page, char **start, off_t off, int count, int *eof, void *data)
528 ide_drive_t *drive = (ide_drive_t *) data;
529 char *out = page;
530 int len;
532 if (drive->id_read)
533 len = sprintf(out, "%i\n", drive->id->buf_size / 2);
534 else
535 len = sprintf(out, "(none)\n");
537 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
540 static int proc_idedisk_read_capacity
541 (char *page, char **start, off_t off, int count, int *eof, void *data)
543 ide_drive_t*drive = (ide_drive_t *)data;
544 int len;
546 len = sprintf(page, "%llu\n", (long long)idedisk_capacity(drive));
548 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
551 static int proc_idedisk_read_smart(char *page, char **start, off_t off,
552 int count, int *eof, void *data, u8 sub_cmd)
554 ide_drive_t *drive = (ide_drive_t *)data;
555 int len = 0, i = 0;
557 if (get_smart_data(drive, page, sub_cmd) == 0) {
558 unsigned short *val = (unsigned short *) page;
559 char *out = ((char *)val) + (SECTOR_WORDS * 4);
560 page = out;
561 do {
562 out += sprintf(out, "%04x%c", le16_to_cpu(*val),
563 (++i & 7) ? ' ' : '\n');
564 val += 1;
565 } while (i < (SECTOR_WORDS * 2));
566 len = out - page;
569 PROC_IDE_READ_RETURN(page, start, off, count, eof, len);
572 static int proc_idedisk_read_sv
573 (char *page, char **start, off_t off, int count, int *eof, void *data)
575 return proc_idedisk_read_smart(page, start, off, count, eof, data,
576 SMART_READ_VALUES);
579 static int proc_idedisk_read_st
580 (char *page, char **start, off_t off, int count, int *eof, void *data)
582 return proc_idedisk_read_smart(page, start, off, count, eof, data,
583 SMART_READ_THRESHOLDS);
586 static ide_proc_entry_t idedisk_proc[] = {
587 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
588 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
589 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
590 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_sv, NULL },
591 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_st, NULL },
592 { NULL, 0, NULL, NULL }
594 #endif /* CONFIG_IDE_PROC_FS */
596 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
598 ide_drive_t *drive = q->queuedata;
599 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
601 /* FIXME: map struct ide_taskfile on rq->cmd[] */
602 BUG_ON(task == NULL);
604 memset(task, 0, sizeof(*task));
605 if (ide_id_has_flush_cache_ext(drive->id) &&
606 (drive->capacity64 >= (1UL << 28)))
607 task->tf.command = WIN_FLUSH_CACHE_EXT;
608 else
609 task->tf.command = WIN_FLUSH_CACHE;
610 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
611 IDE_TFLAG_DYN;
612 task->data_phase = TASKFILE_NO_DATA;
614 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
615 rq->cmd_flags |= REQ_SOFTBARRIER;
616 rq->special = task;
620 * This is tightly woven into the driver->do_special can not touch.
621 * DON'T do it again until a total personality rewrite is committed.
623 static int set_multcount(ide_drive_t *drive, int arg)
625 struct request *rq;
626 int error;
628 if (arg < 0 || arg > drive->id->max_multsect)
629 return -EINVAL;
631 if (drive->special.b.set_multmode)
632 return -EBUSY;
634 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
635 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
637 drive->mult_req = arg;
638 drive->special.b.set_multmode = 1;
639 error = blk_execute_rq(drive->queue, NULL, rq, 0);
640 blk_put_request(rq);
642 return (drive->mult_count == arg) ? 0 : -EIO;
645 static int set_nowerr(ide_drive_t *drive, int arg)
647 if (arg < 0 || arg > 1)
648 return -EINVAL;
650 if (ide_spin_wait_hwgroup(drive))
651 return -EBUSY;
652 drive->nowerr = arg;
653 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
654 spin_unlock_irq(&ide_lock);
655 return 0;
658 static void update_ordered(ide_drive_t *drive)
660 struct hd_driveid *id = drive->id;
661 unsigned ordered = QUEUE_ORDERED_NONE;
662 prepare_flush_fn *prep_fn = NULL;
664 if (drive->wcache) {
665 unsigned long long capacity;
666 int barrier;
668 * We must avoid issuing commands a drive does not
669 * understand or we may crash it. We check flush cache
670 * is supported. We also check we have the LBA48 flush
671 * cache if the drive capacity is too large. By this
672 * time we have trimmed the drive capacity if LBA48 is
673 * not available so we don't need to recheck that.
675 capacity = idedisk_capacity(drive);
676 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
677 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
678 ide_id_has_flush_cache_ext(id));
680 printk(KERN_INFO "%s: cache flushes %ssupported\n",
681 drive->name, barrier ? "" : "not ");
683 if (barrier) {
684 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
685 prep_fn = idedisk_prepare_flush;
687 } else
688 ordered = QUEUE_ORDERED_DRAIN;
690 blk_queue_ordered(drive->queue, ordered, prep_fn);
693 static int write_cache(ide_drive_t *drive, int arg)
695 ide_task_t args;
696 int err = 1;
698 if (arg < 0 || arg > 1)
699 return -EINVAL;
701 if (ide_id_has_flush_cache(drive->id)) {
702 memset(&args, 0, sizeof(ide_task_t));
703 args.tf.feature = arg ?
704 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
705 args.tf.command = WIN_SETFEATURES;
706 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
707 err = ide_no_data_taskfile(drive, &args);
708 if (err == 0)
709 drive->wcache = arg;
712 update_ordered(drive);
714 return err;
717 static int do_idedisk_flushcache(ide_drive_t *drive)
719 ide_task_t args;
721 memset(&args, 0, sizeof(ide_task_t));
722 if (ide_id_has_flush_cache_ext(drive->id))
723 args.tf.command = WIN_FLUSH_CACHE_EXT;
724 else
725 args.tf.command = WIN_FLUSH_CACHE;
726 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
727 return ide_no_data_taskfile(drive, &args);
730 static int set_acoustic(ide_drive_t *drive, int arg)
732 ide_task_t args;
734 if (arg < 0 || arg > 254)
735 return -EINVAL;
737 memset(&args, 0, sizeof(ide_task_t));
738 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
739 args.tf.nsect = arg;
740 args.tf.command = WIN_SETFEATURES;
741 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
742 ide_no_data_taskfile(drive, &args);
743 drive->acoustic = arg;
744 return 0;
748 * drive->addressing:
749 * 0: 28-bit
750 * 1: 48-bit
751 * 2: 48-bit capable doing 28-bit
753 static int set_lba_addressing(ide_drive_t *drive, int arg)
755 if (arg < 0 || arg > 2)
756 return -EINVAL;
758 drive->addressing = 0;
760 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
761 return 0;
763 if (!idedisk_supports_lba48(drive->id))
764 return -EIO;
765 drive->addressing = arg;
766 return 0;
769 #ifdef CONFIG_IDE_PROC_FS
770 static void idedisk_add_settings(ide_drive_t *drive)
772 struct hd_driveid *id = drive->id;
774 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
775 &drive->bios_cyl, NULL);
776 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1,
777 &drive->bios_head, NULL);
778 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1,
779 &drive->bios_sect, NULL);
780 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1,
781 &drive->addressing, set_lba_addressing);
782 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0,
783 id->max_multsect, 1, 1, &drive->mult_count,
784 set_multcount);
785 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
786 &drive->nowerr, set_nowerr);
787 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1,
788 &drive->lun, NULL);
789 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1,
790 &drive->wcache, write_cache);
791 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1,
792 &drive->acoustic, set_acoustic);
793 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1,
794 &drive->failures, NULL);
795 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535,
796 1, 1, &drive->max_failures, NULL);
798 #else
799 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
800 #endif
802 static void idedisk_setup(ide_drive_t *drive)
804 ide_hwif_t *hwif = drive->hwif;
805 struct hd_driveid *id = drive->id;
806 unsigned long long capacity;
808 idedisk_add_settings(drive);
810 if (drive->id_read == 0)
811 return;
813 if (drive->removable) {
815 * Removable disks (eg. SYQUEST); ignore 'WD' drives
817 if (id->model[0] != 'W' || id->model[1] != 'D')
818 drive->doorlocking = 1;
821 (void)set_lba_addressing(drive, 1);
823 if (drive->addressing == 1) {
824 int max_s = 2048;
826 if (max_s > hwif->rqsize)
827 max_s = hwif->rqsize;
829 blk_queue_max_sectors(drive->queue, max_s);
832 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
833 drive->queue->max_sectors / 2);
835 /* calculate drive capacity, and select LBA if possible */
836 init_idedisk_capacity(drive);
838 /* limit drive capacity to 137GB if LBA48 cannot be used */
839 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
840 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
841 "%llu sectors (%llu MB)\n",
842 drive->name, (unsigned long long)drive->capacity64,
843 sectors_to_MB(drive->capacity64));
844 drive->capacity64 = 1ULL << 28;
847 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
848 if (drive->capacity64 > 1ULL << 28) {
849 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
850 " will be used for accessing sectors "
851 "> %u\n", drive->name, 1 << 28);
852 } else
853 drive->addressing = 0;
857 * if possible, give fdisk access to more of the drive,
858 * by correcting bios_cyls:
860 capacity = idedisk_capacity(drive);
862 if (!drive->forced_geom) {
864 if (idedisk_supports_lba48(drive->id)) {
865 /* compatibility */
866 drive->bios_sect = 63;
867 drive->bios_head = 255;
870 if (drive->bios_sect && drive->bios_head) {
871 unsigned int cap0 = capacity; /* truncate to 32 bits */
872 unsigned int cylsz, cyl;
874 if (cap0 != capacity)
875 drive->bios_cyl = 65535;
876 else {
877 cylsz = drive->bios_sect * drive->bios_head;
878 cyl = cap0 / cylsz;
879 if (cyl > 65535)
880 cyl = 65535;
881 if (cyl > drive->bios_cyl)
882 drive->bios_cyl = cyl;
886 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
887 drive->name, capacity, sectors_to_MB(capacity));
889 /* Only print cache size when it was specified */
890 if (id->buf_size)
891 printk(KERN_CONT " w/%dKiB Cache", id->buf_size / 2);
893 printk(KERN_CONT ", CHS=%d/%d/%d\n",
894 drive->bios_cyl, drive->bios_head, drive->bios_sect);
896 /* write cache enabled? */
897 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
898 drive->wcache = 1;
900 write_cache(drive, 1);
903 static void ide_cacheflush_p(ide_drive_t *drive)
905 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
906 return;
908 if (do_idedisk_flushcache(drive))
909 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
912 static void ide_disk_remove(ide_drive_t *drive)
914 struct ide_disk_obj *idkp = drive->driver_data;
915 struct gendisk *g = idkp->disk;
917 ide_proc_unregister_driver(drive, idkp->driver);
919 del_gendisk(g);
921 ide_cacheflush_p(drive);
923 ide_disk_put(idkp);
926 static void ide_disk_release(struct kref *kref)
928 struct ide_disk_obj *idkp = to_ide_disk(kref);
929 ide_drive_t *drive = idkp->drive;
930 struct gendisk *g = idkp->disk;
932 drive->driver_data = NULL;
933 g->private_data = NULL;
934 put_disk(g);
935 kfree(idkp);
938 static int ide_disk_probe(ide_drive_t *drive);
941 * On HPA drives the capacity needs to be
942 * reinitilized on resume otherwise the disk
943 * can not be used and a hard reset is required
945 static void ide_disk_resume(ide_drive_t *drive)
947 if (idedisk_supports_hpa(drive->id))
948 init_idedisk_capacity(drive);
951 static void ide_device_shutdown(ide_drive_t *drive)
953 #ifdef CONFIG_ALPHA
954 /* On Alpha, halt(8) doesn't actually turn the machine off,
955 it puts you into the sort of firmware monitor. Typically,
956 it's used to boot another kernel image, so it's not much
957 different from reboot(8). Therefore, we don't need to
958 spin down the disk in this case, especially since Alpha
959 firmware doesn't handle disks in standby mode properly.
960 On the other hand, it's reasonably safe to turn the power
961 off when the shutdown process reaches the firmware prompt,
962 as the firmware initialization takes rather long time -
963 at least 10 seconds, which should be sufficient for
964 the disk to expire its write cache. */
965 if (system_state != SYSTEM_POWER_OFF) {
966 #else
967 if (system_state == SYSTEM_RESTART) {
968 #endif
969 ide_cacheflush_p(drive);
970 return;
973 printk(KERN_INFO "Shutdown: %s\n", drive->name);
975 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
978 static ide_driver_t idedisk_driver = {
979 .gen_driver = {
980 .owner = THIS_MODULE,
981 .name = "ide-disk",
982 .bus = &ide_bus_type,
984 .probe = ide_disk_probe,
985 .remove = ide_disk_remove,
986 .resume = ide_disk_resume,
987 .shutdown = ide_device_shutdown,
988 .version = IDEDISK_VERSION,
989 .media = ide_disk,
990 .supports_dsc_overlap = 0,
991 .do_request = ide_do_rw_disk,
992 .end_request = ide_end_request,
993 .error = __ide_error,
994 #ifdef CONFIG_IDE_PROC_FS
995 .proc = idedisk_proc,
996 #endif
999 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
1001 ide_task_t task;
1003 memset(&task, 0, sizeof(task));
1004 task.tf.command = on ? WIN_DOORLOCK : WIN_DOORUNLOCK;
1005 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
1007 return ide_no_data_taskfile(drive, &task);
1010 static int idedisk_open(struct inode *inode, struct file *filp)
1012 struct gendisk *disk = inode->i_bdev->bd_disk;
1013 struct ide_disk_obj *idkp;
1014 ide_drive_t *drive;
1016 idkp = ide_disk_get(disk);
1017 if (idkp == NULL)
1018 return -ENXIO;
1020 drive = idkp->drive;
1022 idkp->openers++;
1024 if (drive->removable && idkp->openers == 1) {
1025 check_disk_change(inode->i_bdev);
1027 * Ignore the return code from door_lock,
1028 * since the open() has already succeeded,
1029 * and the door_lock is irrelevant at this point.
1031 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1032 drive->doorlocking = 0;
1034 return 0;
1037 static int idedisk_release(struct inode *inode, struct file *filp)
1039 struct gendisk *disk = inode->i_bdev->bd_disk;
1040 struct ide_disk_obj *idkp = ide_disk_g(disk);
1041 ide_drive_t *drive = idkp->drive;
1043 if (idkp->openers == 1)
1044 ide_cacheflush_p(drive);
1046 if (drive->removable && idkp->openers == 1) {
1047 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1048 drive->doorlocking = 0;
1051 idkp->openers--;
1053 ide_disk_put(idkp);
1055 return 0;
1058 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1060 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1061 ide_drive_t *drive = idkp->drive;
1063 geo->heads = drive->bios_head;
1064 geo->sectors = drive->bios_sect;
1065 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1066 return 0;
1069 static int idedisk_ioctl(struct inode *inode, struct file *file,
1070 unsigned int cmd, unsigned long arg)
1072 unsigned long flags;
1073 struct block_device *bdev = inode->i_bdev;
1074 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1075 ide_drive_t *drive = idkp->drive;
1076 int err, (*setfunc)(ide_drive_t *, int);
1077 u8 *val;
1079 switch (cmd) {
1080 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1081 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1082 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1083 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1084 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1085 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1086 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1087 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1088 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1089 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1092 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1094 read_val:
1095 mutex_lock(&ide_setting_mtx);
1096 spin_lock_irqsave(&ide_lock, flags);
1097 err = *val;
1098 spin_unlock_irqrestore(&ide_lock, flags);
1099 mutex_unlock(&ide_setting_mtx);
1100 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1102 set_val:
1103 if (bdev != bdev->bd_contains)
1104 err = -EINVAL;
1105 else {
1106 if (!capable(CAP_SYS_ADMIN))
1107 err = -EACCES;
1108 else {
1109 mutex_lock(&ide_setting_mtx);
1110 err = setfunc(drive, arg);
1111 mutex_unlock(&ide_setting_mtx);
1114 return err;
1117 static int idedisk_media_changed(struct gendisk *disk)
1119 struct ide_disk_obj *idkp = ide_disk_g(disk);
1120 ide_drive_t *drive = idkp->drive;
1122 /* do not scan partitions twice if this is a removable device */
1123 if (drive->attach) {
1124 drive->attach = 0;
1125 return 0;
1127 /* if removable, always assume it was changed */
1128 return drive->removable;
1131 static int idedisk_revalidate_disk(struct gendisk *disk)
1133 struct ide_disk_obj *idkp = ide_disk_g(disk);
1134 set_capacity(disk, idedisk_capacity(idkp->drive));
1135 return 0;
1138 static struct block_device_operations idedisk_ops = {
1139 .owner = THIS_MODULE,
1140 .open = idedisk_open,
1141 .release = idedisk_release,
1142 .ioctl = idedisk_ioctl,
1143 .getgeo = idedisk_getgeo,
1144 .media_changed = idedisk_media_changed,
1145 .revalidate_disk = idedisk_revalidate_disk
1148 MODULE_DESCRIPTION("ATA DISK Driver");
1150 static int ide_disk_probe(ide_drive_t *drive)
1152 struct ide_disk_obj *idkp;
1153 struct gendisk *g;
1155 /* strstr("foo", "") is non-NULL */
1156 if (!strstr("ide-disk", drive->driver_req))
1157 goto failed;
1158 if (!drive->present)
1159 goto failed;
1160 if (drive->media != ide_disk)
1161 goto failed;
1163 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1164 if (!idkp)
1165 goto failed;
1167 g = alloc_disk_node(1 << PARTN_BITS,
1168 hwif_to_node(drive->hwif));
1169 if (!g)
1170 goto out_free_idkp;
1172 ide_init_disk(g, drive);
1174 ide_proc_register_driver(drive, &idedisk_driver);
1176 kref_init(&idkp->kref);
1178 idkp->drive = drive;
1179 idkp->driver = &idedisk_driver;
1180 idkp->disk = g;
1182 g->private_data = &idkp->driver;
1184 drive->driver_data = idkp;
1186 idedisk_setup(drive);
1187 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1188 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1189 drive->name, drive->head);
1190 drive->attach = 0;
1191 } else
1192 drive->attach = 1;
1194 g->minors = 1 << PARTN_BITS;
1195 g->driverfs_dev = &drive->gendev;
1196 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1197 set_capacity(g, idedisk_capacity(drive));
1198 g->fops = &idedisk_ops;
1199 add_disk(g);
1200 return 0;
1202 out_free_idkp:
1203 kfree(idkp);
1204 failed:
1205 return -ENODEV;
1208 static void __exit idedisk_exit(void)
1210 driver_unregister(&idedisk_driver.gen_driver);
1213 static int __init idedisk_init(void)
1215 return driver_register(&idedisk_driver.gen_driver);
1218 MODULE_ALIAS("ide:*m-disk*");
1219 module_init(idedisk_init);
1220 module_exit(idedisk_exit);
1221 MODULE_LICENSE("GPL");