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 nsectors.all = (u16) rq->nr_sectors;
146 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
147 if (block + rq->nr_sectors > 1ULL << 28)
154 ide_init_sg_cmd(drive, rq);
155 ide_map_sg(drive, rq);
159 hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
161 /* FIXME: SELECT_MASK(drive, 0) ? */
163 if (drive->select.b.lba) {
167 pr_debug("%s: LBA=0x%012llx\n", drive->name,
168 (unsigned long long)block);
172 tasklets[2] = nsectors.b.low;
173 tasklets[3] = nsectors.b.high;
174 tasklets[4] = (u8) block;
175 tasklets[5] = (u8)(block >> 8);
176 tasklets[6] = (u8)(block >> 16);
177 tasklets[7] = (u8)(block >> 24);
178 if (sizeof(block) == 4) {
182 tasklets[8] = (u8)((u64)block >> 32);
183 tasklets[9] = (u8)((u64)block >> 40);
186 printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
187 drive->name, tasklets[3], tasklets[2],
188 tasklets[9], tasklets[8], tasklets[7],
189 tasklets[6], tasklets[5], tasklets[4]);
191 hwif->OUTB(tasklets[1], IDE_FEATURE_REG);
192 hwif->OUTB(tasklets[3], IDE_NSECTOR_REG);
193 hwif->OUTB(tasklets[7], IDE_SECTOR_REG);
194 hwif->OUTB(tasklets[8], IDE_LCYL_REG);
195 hwif->OUTB(tasklets[9], IDE_HCYL_REG);
197 hwif->OUTB(tasklets[0], IDE_FEATURE_REG);
198 hwif->OUTB(tasklets[2], IDE_NSECTOR_REG);
199 hwif->OUTB(tasklets[4], IDE_SECTOR_REG);
200 hwif->OUTB(tasklets[5], IDE_LCYL_REG);
201 hwif->OUTB(tasklets[6], IDE_HCYL_REG);
202 hwif->OUTB(0x00|drive->select.all,IDE_SELECT_REG);
204 hwif->OUTB(0x00, IDE_FEATURE_REG);
205 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
206 hwif->OUTB(block, IDE_SECTOR_REG);
207 hwif->OUTB(block>>=8, IDE_LCYL_REG);
208 hwif->OUTB(block>>=8, IDE_HCYL_REG);
209 hwif->OUTB(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
212 unsigned int sect,head,cyl,track;
213 track = (int)block / drive->sect;
214 sect = (int)block % drive->sect + 1;
215 head = track % drive->head;
216 cyl = track / drive->head;
218 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
220 hwif->OUTB(0x00, IDE_FEATURE_REG);
221 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
222 hwif->OUTB(sect, IDE_SECTOR_REG);
223 hwif->OUTB(cyl, IDE_LCYL_REG);
224 hwif->OUTB(cyl>>8, IDE_HCYL_REG);
225 hwif->OUTB(head|drive->select.all,IDE_SELECT_REG);
229 if (!hwif->dma_setup(drive)) {
230 if (rq_data_dir(rq)) {
231 command = lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
233 command = lba48 ? WIN_WRITE_EXT: WIN_WRITE;
235 command = lba48 ? WIN_READDMA_EXT : WIN_READDMA;
237 command = lba48 ? WIN_READ_EXT: WIN_READ;
239 hwif->dma_exec_cmd(drive, command);
240 hwif->dma_start(drive);
243 /* fallback to PIO */
244 ide_init_sg_cmd(drive, rq);
247 if (rq_data_dir(rq) == READ) {
249 if (drive->mult_count) {
250 hwif->data_phase = TASKFILE_MULTI_IN;
251 command = lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
253 hwif->data_phase = TASKFILE_IN;
254 command = lba48 ? WIN_READ_EXT : WIN_READ;
257 ide_execute_command(drive, command, &task_in_intr, WAIT_CMD, NULL);
260 if (drive->mult_count) {
261 hwif->data_phase = TASKFILE_MULTI_OUT;
262 command = lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
264 hwif->data_phase = TASKFILE_OUT;
265 command = lba48 ? WIN_WRITE_EXT : WIN_WRITE;
268 /* FIXME: ->OUTBSYNC ? */
269 hwif->OUTB(command, IDE_COMMAND_REG);
271 return pre_task_out_intr(drive, rq);
276 * 268435455 == 137439 MB or 28bit limit
277 * 320173056 == 163929 MB or 48bit addressing
278 * 1073741822 == 549756 MB or 48bit addressing fake drive
281 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
283 ide_hwif_t *hwif = HWIF(drive);
285 BUG_ON(drive->blocked);
287 if (!blk_fs_request(rq)) {
288 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
289 ide_end_request(drive, 0, 0);
293 ledtrig_ide_activity();
295 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
296 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
297 (unsigned long long)block, rq->nr_sectors,
298 (unsigned long)rq->buffer);
301 hwif->rw_disk(drive, rq);
303 return __ide_do_rw_disk(drive, rq, block);
307 * Queries for true maximum capacity of the drive.
308 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
310 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
313 struct ide_taskfile *tf = &args.tf;
316 /* Create IDE/ATA command request structure */
317 memset(&args, 0, sizeof(ide_task_t));
319 tf->command = WIN_READ_NATIVE_MAX_EXT;
321 tf->command = WIN_READ_NATIVE_MAX;
322 tf->device = ATA_LBA;
323 args.command_type = IDE_DRIVE_TASK_NO_DATA;
324 args.handler = &task_no_data_intr;
325 /* submit command request */
326 ide_raw_taskfile(drive, &args, NULL);
328 /* if OK, compute maximum address value */
329 if ((tf->status & 0x01) == 0) {
333 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
336 high = tf->device & 0xf;
337 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
338 addr = ((__u64)high << 24) | low;
339 addr++; /* since the return value is (maxlba - 1), we add 1 */
345 * Sets maximum virtual LBA address of the drive.
346 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
348 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
351 struct ide_taskfile *tf = &args.tf;
355 /* Create IDE/ATA command request structure */
356 memset(&args, 0, sizeof(ide_task_t));
357 tf->lbal = (addr_req >> 0) & 0xff;
358 tf->lbam = (addr_req >>= 8) & 0xff;
359 tf->lbah = (addr_req >>= 8) & 0xff;
361 tf->hob_lbal = (addr_req >>= 8) & 0xff;
362 tf->hob_lbam = (addr_req >>= 8) & 0xff;
363 tf->hob_lbah = (addr_req >>= 8) & 0xff;
364 tf->command = WIN_SET_MAX_EXT;
366 tf->device = (addr_req >>= 8) & 0x0f;
367 tf->command = WIN_SET_MAX;
369 tf->device |= ATA_LBA;
370 args.command_type = IDE_DRIVE_TASK_NO_DATA;
371 args.handler = &task_no_data_intr;
372 /* submit command request */
373 ide_raw_taskfile(drive, &args, NULL);
374 /* if OK, compute maximum address value */
375 if ((tf->status & 0x01) == 0) {
379 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
382 high = tf->device & 0xf;
383 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
384 addr_set = ((__u64)high << 24) | low;
390 static unsigned long long sectors_to_MB(unsigned long long n)
392 n <<= 9; /* make it bytes */
393 do_div(n, 1000000); /* make it MB */
398 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
399 * so on non-buggy drives we need test only one.
400 * However, we should also check whether these fields are valid.
402 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
404 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
410 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
412 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
413 && id->lba_capacity_2;
417 * Some disks report total number of sectors instead of
418 * maximum sector address. We list them here.
420 static const struct drive_list_entry hpa_list[] = {
421 { "ST340823A", NULL },
422 { "ST320413A", NULL },
426 static void idedisk_check_hpa(ide_drive_t *drive)
428 unsigned long long capacity, set_max;
429 int lba48 = idedisk_supports_lba48(drive->id);
431 capacity = drive->capacity64;
433 set_max = idedisk_read_native_max_address(drive, lba48);
435 if (ide_in_drive_list(drive->id, hpa_list)) {
437 * Since we are inclusive wrt to firmware revisions do this
438 * extra check and apply the workaround only when needed.
440 if (set_max == capacity + 1)
444 if (set_max <= capacity)
447 printk(KERN_INFO "%s: Host Protected Area detected.\n"
448 "\tcurrent capacity is %llu sectors (%llu MB)\n"
449 "\tnative capacity is %llu sectors (%llu MB)\n",
451 capacity, sectors_to_MB(capacity),
452 set_max, sectors_to_MB(set_max));
454 set_max = idedisk_set_max_address(drive, set_max, lba48);
457 drive->capacity64 = set_max;
458 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
464 * Compute drive->capacity, the full capacity of the drive
465 * Called with drive->id != NULL.
467 * To compute capacity, this uses either of
469 * 1. CHS value set by user (whatever user sets will be trusted)
470 * 2. LBA value from target drive (require new ATA feature)
471 * 3. LBA value from system BIOS (new one is OK, old one may break)
472 * 4. CHS value from system BIOS (traditional style)
474 * in above order (i.e., if value of higher priority is available,
475 * reset will be ignored).
477 static void init_idedisk_capacity (ide_drive_t *drive)
479 struct hd_driveid *id = drive->id;
481 * If this drive supports the Host Protected Area feature set,
482 * then we may need to change our opinion about the drive's capacity.
484 int hpa = idedisk_supports_hpa(id);
486 if (idedisk_supports_lba48(id)) {
487 /* drive speaks 48-bit LBA */
488 drive->select.b.lba = 1;
489 drive->capacity64 = id->lba_capacity_2;
491 idedisk_check_hpa(drive);
492 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
493 /* drive speaks 28-bit LBA */
494 drive->select.b.lba = 1;
495 drive->capacity64 = id->lba_capacity;
497 idedisk_check_hpa(drive);
499 /* drive speaks boring old 28-bit CHS */
500 drive->capacity64 = drive->cyl * drive->head * drive->sect;
504 static sector_t idedisk_capacity (ide_drive_t *drive)
506 return drive->capacity64 - drive->sect0;
509 #ifdef CONFIG_IDE_PROC_FS
510 static int smart_enable(ide_drive_t *drive)
513 struct ide_taskfile *tf = &args.tf;
515 memset(&args, 0, sizeof(ide_task_t));
516 tf->feature = SMART_ENABLE;
517 tf->lbam = SMART_LCYL_PASS;
518 tf->lbah = SMART_HCYL_PASS;
519 tf->command = WIN_SMART;
520 args.command_type = IDE_DRIVE_TASK_NO_DATA;
521 args.handler = &task_no_data_intr;
522 return ide_raw_taskfile(drive, &args, NULL);
525 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
528 struct ide_taskfile *tf = &args.tf;
530 memset(&args, 0, sizeof(ide_task_t));
531 tf->feature = sub_cmd;
533 tf->lbam = SMART_LCYL_PASS;
534 tf->lbah = SMART_HCYL_PASS;
535 tf->command = WIN_SMART;
536 args.command_type = IDE_DRIVE_TASK_IN;
537 args.data_phase = TASKFILE_IN;
538 args.handler = &task_in_intr;
539 (void) smart_enable(drive);
540 return ide_raw_taskfile(drive, &args, buf);
543 static int proc_idedisk_read_cache
544 (char *page, char **start, off_t off, int count, int *eof, void *data)
546 ide_drive_t *drive = (ide_drive_t *) data;
551 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
553 len = sprintf(out,"(none)\n");
554 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
557 static int proc_idedisk_read_capacity
558 (char *page, char **start, off_t off, int count, int *eof, void *data)
560 ide_drive_t*drive = (ide_drive_t *)data;
563 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
564 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
567 static int proc_idedisk_read_smart_thresholds
568 (char *page, char **start, off_t off, int count, int *eof, void *data)
570 ide_drive_t *drive = (ide_drive_t *)data;
573 if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
574 unsigned short *val = (unsigned short *) page;
575 char *out = ((char *)val) + (SECTOR_WORDS * 4);
578 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
580 } while (i < (SECTOR_WORDS * 2));
583 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
586 static int proc_idedisk_read_smart_values
587 (char *page, char **start, off_t off, int count, int *eof, void *data)
589 ide_drive_t *drive = (ide_drive_t *)data;
592 if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
593 unsigned short *val = (unsigned short *) page;
594 char *out = ((char *)val) + (SECTOR_WORDS * 4);
597 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
599 } while (i < (SECTOR_WORDS * 2));
602 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
605 static ide_proc_entry_t idedisk_proc[] = {
606 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
607 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
608 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
609 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
610 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
611 { NULL, 0, NULL, NULL }
613 #endif /* CONFIG_IDE_PROC_FS */
615 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
617 ide_drive_t *drive = q->queuedata;
619 memset(rq->cmd, 0, sizeof(rq->cmd));
621 if (ide_id_has_flush_cache_ext(drive->id) &&
622 (drive->capacity64 >= (1UL << 28)))
623 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
625 rq->cmd[0] = WIN_FLUSH_CACHE;
628 rq->cmd_type = REQ_TYPE_ATA_TASK;
629 rq->cmd_flags |= REQ_SOFTBARRIER;
630 rq->buffer = rq->cmd;
634 * This is tightly woven into the driver->do_special can not touch.
635 * DON'T do it again until a total personality rewrite is committed.
637 static int set_multcount(ide_drive_t *drive, int arg)
641 if (arg < 0 || arg > drive->id->max_multsect)
644 if (drive->special.b.set_multmode)
646 ide_init_drive_cmd (&rq);
647 rq.cmd_type = REQ_TYPE_ATA_CMD;
648 drive->mult_req = arg;
649 drive->special.b.set_multmode = 1;
650 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
651 return (drive->mult_count == arg) ? 0 : -EIO;
654 static int set_nowerr(ide_drive_t *drive, int arg)
656 if (arg < 0 || arg > 1)
659 if (ide_spin_wait_hwgroup(drive))
662 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
663 spin_unlock_irq(&ide_lock);
667 static void update_ordered(ide_drive_t *drive)
669 struct hd_driveid *id = drive->id;
670 unsigned ordered = QUEUE_ORDERED_NONE;
671 prepare_flush_fn *prep_fn = NULL;
674 unsigned long long capacity;
677 * We must avoid issuing commands a drive does not
678 * understand or we may crash it. We check flush cache
679 * is supported. We also check we have the LBA48 flush
680 * cache if the drive capacity is too large. By this
681 * time we have trimmed the drive capacity if LBA48 is
682 * not available so we don't need to recheck that.
684 capacity = idedisk_capacity(drive);
685 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
686 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
687 ide_id_has_flush_cache_ext(id));
689 printk(KERN_INFO "%s: cache flushes %ssupported\n",
690 drive->name, barrier ? "" : "not ");
693 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
694 prep_fn = idedisk_prepare_flush;
697 ordered = QUEUE_ORDERED_DRAIN;
699 blk_queue_ordered(drive->queue, ordered, prep_fn);
702 static int write_cache(ide_drive_t *drive, int arg)
707 if (arg < 0 || arg > 1)
710 if (ide_id_has_flush_cache(drive->id)) {
711 memset(&args, 0, sizeof(ide_task_t));
712 args.tf.feature = arg ?
713 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
714 args.tf.command = WIN_SETFEATURES;
715 args.command_type = IDE_DRIVE_TASK_NO_DATA;
716 args.handler = &task_no_data_intr;
717 err = ide_raw_taskfile(drive, &args, NULL);
722 update_ordered(drive);
727 static int do_idedisk_flushcache (ide_drive_t *drive)
731 memset(&args, 0, sizeof(ide_task_t));
732 if (ide_id_has_flush_cache_ext(drive->id))
733 args.tf.command = WIN_FLUSH_CACHE_EXT;
735 args.tf.command = WIN_FLUSH_CACHE;
736 args.command_type = IDE_DRIVE_TASK_NO_DATA;
737 args.handler = &task_no_data_intr;
738 return ide_raw_taskfile(drive, &args, NULL);
741 static int set_acoustic (ide_drive_t *drive, int arg)
745 if (arg < 0 || arg > 254)
748 memset(&args, 0, sizeof(ide_task_t));
749 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
751 args.tf.command = WIN_SETFEATURES;
752 args.command_type = IDE_DRIVE_TASK_NO_DATA;
753 args.handler = &task_no_data_intr;
754 ide_raw_taskfile(drive, &args, NULL);
755 drive->acoustic = arg;
763 * 2: 48-bit capable doing 28-bit
765 static int set_lba_addressing(ide_drive_t *drive, int arg)
767 if (arg < 0 || arg > 2)
770 drive->addressing = 0;
772 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
775 if (!idedisk_supports_lba48(drive->id))
777 drive->addressing = arg;
781 #ifdef CONFIG_IDE_PROC_FS
782 static void idedisk_add_settings(ide_drive_t *drive)
784 struct hd_driveid *id = drive->id;
786 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
787 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
788 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
789 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
790 ide_add_setting(drive, "bswap", SETTING_READ, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
791 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount);
792 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
793 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
794 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
795 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
796 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
797 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
800 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
803 static void idedisk_setup (ide_drive_t *drive)
805 ide_hwif_t *hwif = drive->hwif;
806 struct hd_driveid *id = drive->id;
807 unsigned long long capacity;
809 idedisk_add_settings(drive);
811 if (drive->id_read == 0)
814 if (drive->removable) {
816 * Removable disks (eg. SYQUEST); ignore 'WD' drives
818 if (id->model[0] != 'W' || id->model[1] != 'D') {
819 drive->doorlocking = 1;
823 (void)set_lba_addressing(drive, 1);
825 if (drive->addressing == 1) {
828 if (max_s > hwif->rqsize)
829 max_s = hwif->rqsize;
831 blk_queue_max_sectors(drive->queue, max_s);
834 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
836 /* calculate drive capacity, and select LBA if possible */
837 init_idedisk_capacity (drive);
839 /* limit drive capacity to 137GB if LBA48 cannot be used */
840 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
841 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
842 "%llu sectors (%llu MB)\n",
843 drive->name, (unsigned long long)drive->capacity64,
844 sectors_to_MB(drive->capacity64));
845 drive->capacity64 = 1ULL << 28;
848 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
849 if (drive->capacity64 > 1ULL << 28) {
850 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
851 " be used for accessing sectors > %u\n",
852 drive->name, 1 << 28);
854 drive->addressing = 0;
858 * if possible, give fdisk access to more of the drive,
859 * by correcting bios_cyls:
861 capacity = idedisk_capacity (drive);
862 if (!drive->forced_geom) {
864 if (idedisk_supports_lba48(drive->id)) {
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;
877 cylsz = drive->bios_sect * drive->bios_head;
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 */
891 printk (" 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)))
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))
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);
921 ide_cacheflush_p(drive);
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;
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)
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) {
967 if (system_state == SYSTEM_RESTART) {
969 ide_cacheflush_p(drive);
973 printk("Shutdown: %s\n", drive->name);
974 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
977 static ide_driver_t idedisk_driver = {
979 .owner = THIS_MODULE,
981 .bus = &ide_bus_type,
983 .probe = ide_disk_probe,
984 .remove = ide_disk_remove,
985 .resume = ide_disk_resume,
986 .shutdown = ide_device_shutdown,
987 .version = IDEDISK_VERSION,
989 .supports_dsc_overlap = 0,
990 .do_request = ide_do_rw_disk,
991 .end_request = ide_end_request,
992 .error = __ide_error,
993 .abort = __ide_abort,
994 #ifdef CONFIG_IDE_PROC_FS
995 .proc = idedisk_proc,
999 static int idedisk_open(struct inode *inode, struct file *filp)
1001 struct gendisk *disk = inode->i_bdev->bd_disk;
1002 struct ide_disk_obj *idkp;
1005 if (!(idkp = ide_disk_get(disk)))
1008 drive = idkp->drive;
1012 if (drive->removable && idkp->openers == 1) {
1014 memset(&args, 0, sizeof(ide_task_t));
1015 args.tf.command = WIN_DOORLOCK;
1016 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1017 args.handler = &task_no_data_intr;
1018 check_disk_change(inode->i_bdev);
1020 * Ignore the return code from door_lock,
1021 * since the open() has already succeeded,
1022 * and the door_lock is irrelevant at this point.
1024 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1025 drive->doorlocking = 0;
1030 static int idedisk_release(struct inode *inode, struct file *filp)
1032 struct gendisk *disk = inode->i_bdev->bd_disk;
1033 struct ide_disk_obj *idkp = ide_disk_g(disk);
1034 ide_drive_t *drive = idkp->drive;
1036 if (idkp->openers == 1)
1037 ide_cacheflush_p(drive);
1039 if (drive->removable && idkp->openers == 1) {
1041 memset(&args, 0, sizeof(ide_task_t));
1042 args.tf.command = WIN_DOORUNLOCK;
1043 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1044 args.handler = &task_no_data_intr;
1045 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1046 drive->doorlocking = 0;
1056 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1058 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1059 ide_drive_t *drive = idkp->drive;
1061 geo->heads = drive->bios_head;
1062 geo->sectors = drive->bios_sect;
1063 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1067 static int idedisk_ioctl(struct inode *inode, struct file *file,
1068 unsigned int cmd, unsigned long arg)
1070 unsigned long flags;
1071 struct block_device *bdev = inode->i_bdev;
1072 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1073 ide_drive_t *drive = idkp->drive;
1074 int err, (*setfunc)(ide_drive_t *, int);
1078 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1079 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1080 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1081 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1082 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1083 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1084 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1085 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1086 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1087 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1090 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1093 mutex_lock(&ide_setting_mtx);
1094 spin_lock_irqsave(&ide_lock, flags);
1096 spin_unlock_irqrestore(&ide_lock, flags);
1097 mutex_unlock(&ide_setting_mtx);
1098 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1101 if (bdev != bdev->bd_contains)
1104 if (!capable(CAP_SYS_ADMIN))
1107 mutex_lock(&ide_setting_mtx);
1108 err = setfunc(drive, arg);
1109 mutex_unlock(&ide_setting_mtx);
1115 static int idedisk_media_changed(struct gendisk *disk)
1117 struct ide_disk_obj *idkp = ide_disk_g(disk);
1118 ide_drive_t *drive = idkp->drive;
1120 /* do not scan partitions twice if this is a removable device */
1121 if (drive->attach) {
1125 /* if removable, always assume it was changed */
1126 return drive->removable;
1129 static int idedisk_revalidate_disk(struct gendisk *disk)
1131 struct ide_disk_obj *idkp = ide_disk_g(disk);
1132 set_capacity(disk, idedisk_capacity(idkp->drive));
1136 static struct block_device_operations idedisk_ops = {
1137 .owner = THIS_MODULE,
1138 .open = idedisk_open,
1139 .release = idedisk_release,
1140 .ioctl = idedisk_ioctl,
1141 .getgeo = idedisk_getgeo,
1142 .media_changed = idedisk_media_changed,
1143 .revalidate_disk= idedisk_revalidate_disk
1146 MODULE_DESCRIPTION("ATA DISK Driver");
1148 static int ide_disk_probe(ide_drive_t *drive)
1150 struct ide_disk_obj *idkp;
1153 /* strstr("foo", "") is non-NULL */
1154 if (!strstr("ide-disk", drive->driver_req))
1156 if (!drive->present)
1158 if (drive->media != ide_disk)
1161 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1165 g = alloc_disk_node(1 << PARTN_BITS,
1166 hwif_to_node(drive->hwif));
1170 ide_init_disk(g, drive);
1172 ide_proc_register_driver(drive, &idedisk_driver);
1174 kref_init(&idkp->kref);
1176 idkp->drive = drive;
1177 idkp->driver = &idedisk_driver;
1180 g->private_data = &idkp->driver;
1182 drive->driver_data = idkp;
1184 idedisk_setup(drive);
1185 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1186 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1187 drive->name, drive->head);
1192 g->minors = 1 << PARTN_BITS;
1193 g->driverfs_dev = &drive->gendev;
1194 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1195 set_capacity(g, idedisk_capacity(drive));
1196 g->fops = &idedisk_ops;
1206 static void __exit idedisk_exit (void)
1208 driver_unregister(&idedisk_driver.gen_driver);
1211 static int __init idedisk_init(void)
1213 return driver_register(&idedisk_driver.gen_driver);
1216 MODULE_ALIAS("ide:*m-disk*");
1217 module_init(idedisk_init);
1218 module_exit(idedisk_exit);
1219 MODULE_LICENSE("GPL");