2 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below)
3 * Copyright (C) 1998-2002 Linux ATA Development
4 * Andre Hedrick <andre@linux-ide.org>
5 * Copyright (C) 2003 Red Hat <alan@redhat.com>
6 * Copyright (C) 2003-2005, 2007 Bartlomiej Zolnierkiewicz
10 * Mostly written by Mark Lord <mlord@pobox.com>
11 * and Gadi Oxman <gadio@netvision.net.il>
12 * and Andre Hedrick <andre@linux-ide.org>
14 * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
17 #define IDEDISK_VERSION "1.18"
19 #include <linux/module.h>
20 #include <linux/types.h>
21 #include <linux/string.h>
22 #include <linux/kernel.h>
23 #include <linux/timer.h>
25 #include <linux/interrupt.h>
26 #include <linux/major.h>
27 #include <linux/errno.h>
28 #include <linux/genhd.h>
29 #include <linux/slab.h>
30 #include <linux/delay.h>
31 #include <linux/mutex.h>
32 #include <linux/leds.h>
36 #include <linux/ide.h>
38 #include <asm/byteorder.h>
40 #include <asm/uaccess.h>
42 #include <asm/div64.h>
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
);
68 kref_get(&idkp
->kref
);
69 if (ide_device_get(idkp
->drive
)) {
70 kref_put(&idkp
->kref
, ide_disk_release
);
74 mutex_unlock(&idedisk_ref_mutex
);
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
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! */
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)) &&
112 (id
->heads
== 15 || id
->heads
== 16) &&
113 (id
->lba_capacity
>= 16383*63*id
->heads
))
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)
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
[] = {
150 static const u8 ide_data_phases
[] = {
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;
169 index
= drive
->mult_count
? 0 : 4;
171 task
->tf
.command
= ide_rw_cmds
[index
+ lba48
+ write
];
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
,
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;
191 struct ide_taskfile
*tf
= &task
.tf
;
194 if ((hwif
->host_flags
& IDE_HFLAG_NO_LBA48_DMA
) && lba48
&& dma
) {
195 if (block
+ rq
->nr_sectors
> 1ULL << 28)
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
) {
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
);
228 tf
->nsect
= nsectors
& 0xff;
230 tf
->lbam
= block
>>= 8;
231 tf
->lbah
= block
>>= 8;
232 tf
->device
= (block
>> 8) & 0xf;
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;
252 task
.tf_flags
|= IDE_TFLAG_WRITE
;
254 ide_tf_set_cmd(drive
, &task
, dma
);
256 hwif
->data_phase
= task
.data_phase
;
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
);
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
,
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);
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
);
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
)
312 struct ide_taskfile
*tf
= &args
.tf
;
315 /* Create IDE/ATA command request structure */
316 memset(&args
, 0, sizeof(ide_task_t
));
318 tf
->command
= WIN_READ_NATIVE_MAX_EXT
;
320 tf
->command
= WIN_READ_NATIVE_MAX
;
321 tf
->device
= ATA_LBA
;
322 args
.tf_flags
= IDE_TFLAG_TF
| IDE_TFLAG_DEVICE
;
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;
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
)
342 struct ide_taskfile
*tf
= &args
.tf
;
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;
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
;
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
;
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;
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 */
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);
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
},
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)
428 if (set_max
<= capacity
)
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",
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
);
441 drive
->capacity64
= set_max
;
442 printk(KERN_INFO
"%s: Host Protected Area disabled.\n",
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
;
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
;
481 idedisk_check_hpa(drive
);
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
)
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
)
511 struct ide_taskfile
*tf
= &args
.tf
;
513 memset(&args
, 0, sizeof(ide_task_t
));
514 tf
->feature
= sub_cmd
;
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
;
533 len
= sprintf(out
, "%i\n", drive
->id
->buf_size
/ 2);
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
;
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
;
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);
562 out
+= sprintf(out
, "%04x%c", le16_to_cpu(*val
),
563 (++i
& 7) ? ' ' : '\n');
565 } while (i
< (SECTOR_WORDS
* 2));
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
,
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
;
609 task
->tf
.command
= WIN_FLUSH_CACHE
;
610 task
->tf_flags
= IDE_TFLAG_OUT_TF
| IDE_TFLAG_OUT_DEVICE
|
612 task
->data_phase
= TASKFILE_NO_DATA
;
614 rq
->cmd_type
= REQ_TYPE_ATA_TASKFILE
;
615 rq
->cmd_flags
|= REQ_SOFTBARRIER
;
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
)
628 if (arg
< 0 || arg
> drive
->id
->max_multsect
)
631 if (drive
->special
.b
.set_multmode
)
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);
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)
650 if (ide_spin_wait_hwgroup(drive
))
653 drive
->bad_wstat
= arg
? BAD_R_STAT
: BAD_W_STAT
;
654 spin_unlock_irq(&ide_lock
);
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
;
665 unsigned long long capacity
;
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 ");
684 ordered
= QUEUE_ORDERED_DRAIN_FLUSH
;
685 prep_fn
= idedisk_prepare_flush
;
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
)
698 if (arg
< 0 || arg
> 1)
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
);
712 update_ordered(drive
);
717 static int do_idedisk_flushcache(ide_drive_t
*drive
)
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
;
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
)
734 if (arg
< 0 || arg
> 254)
737 memset(&args
, 0, sizeof(ide_task_t
));
738 args
.tf
.feature
= arg
? SETFEATURES_EN_AAM
: SETFEATURES_DIS_AAM
;
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
;
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)
758 drive
->addressing
= 0;
760 if (drive
->hwif
->host_flags
& IDE_HFLAG_NO_LBA48
)
763 if (!idedisk_supports_lba48(drive
->id
))
765 drive
->addressing
= arg
;
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
,
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,
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
);
799 static inline void idedisk_add_settings(ide_drive_t
*drive
) { ; }
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)
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) {
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);
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
)) {
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(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)))
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(KERN_INFO
"Shutdown: %s\n", drive
->name
);
975 drive
->gendev
.bus
->suspend(&drive
->gendev
, PMSG_SUSPEND
);
978 static ide_driver_t idedisk_driver
= {
980 .owner
= THIS_MODULE
,
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
,
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
,
999 static int idedisk_set_doorlock(ide_drive_t
*drive
, int on
)
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
;
1016 idkp
= ide_disk_get(disk
);
1020 drive
= idkp
->drive
;
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;
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;
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 */
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);
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
);
1095 mutex_lock(&ide_setting_mtx
);
1096 spin_lock_irqsave(&ide_lock
, flags
);
1098 spin_unlock_irqrestore(&ide_lock
, flags
);
1099 mutex_unlock(&ide_setting_mtx
);
1100 return err
>= 0 ? put_user(err
, (long __user
*)arg
) : err
;
1103 if (bdev
!= bdev
->bd_contains
)
1106 if (!capable(CAP_SYS_ADMIN
))
1109 mutex_lock(&ide_setting_mtx
);
1110 err
= setfunc(drive
, arg
);
1111 mutex_unlock(&ide_setting_mtx
);
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
) {
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
));
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
;
1155 /* strstr("foo", "") is non-NULL */
1156 if (!strstr("ide-disk", drive
->driver_req
))
1158 if (!drive
->present
)
1160 if (drive
->media
!= ide_disk
)
1163 idkp
= kzalloc(sizeof(*idkp
), GFP_KERNEL
);
1167 g
= alloc_disk_node(1 << PARTN_BITS
,
1168 hwif_to_node(drive
->hwif
));
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
;
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
);
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
;
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");