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
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 #include <linux/types.h>
18 #include <linux/string.h>
19 #include <linux/kernel.h>
20 #include <linux/timer.h>
22 #include <linux/interrupt.h>
23 #include <linux/major.h>
24 #include <linux/errno.h>
25 #include <linux/genhd.h>
26 #include <linux/slab.h>
27 #include <linux/delay.h>
28 #include <linux/mutex.h>
29 #include <linux/leds.h>
30 #include <linux/ide.h>
32 #include <asm/byteorder.h>
34 #include <asm/uaccess.h>
36 #include <asm/div64.h>
40 static const u8 ide_rw_cmds
[] = {
43 ATA_CMD_READ_MULTI_EXT
,
44 ATA_CMD_WRITE_MULTI_EXT
,
48 ATA_CMD_PIO_WRITE_EXT
,
55 static void ide_tf_set_cmd(ide_drive_t
*drive
, struct ide_cmd
*cmd
, u8 dma
)
57 u8 index
, lba48
, write
;
59 lba48
= (cmd
->tf_flags
& IDE_TFLAG_LBA48
) ? 2 : 0;
60 write
= (cmd
->tf_flags
& IDE_TFLAG_WRITE
) ? 1 : 0;
63 cmd
->protocol
= ATA_PROT_DMA
;
66 cmd
->protocol
= ATA_PROT_PIO
;
67 if (drive
->mult_count
) {
68 cmd
->tf_flags
|= IDE_TFLAG_MULTI_PIO
;
74 cmd
->tf
.command
= ide_rw_cmds
[index
+ lba48
+ write
];
78 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
79 * using LBA if supported, or CHS otherwise, to address sectors.
81 static ide_startstop_t
__ide_do_rw_disk(ide_drive_t
*drive
, struct request
*rq
,
84 ide_hwif_t
*hwif
= drive
->hwif
;
85 u16 nsectors
= (u16
)blk_rq_sectors(rq
);
86 u8 lba48
= !!(drive
->dev_flags
& IDE_DFLAG_LBA48
);
87 u8 dma
= !!(drive
->dev_flags
& IDE_DFLAG_USING_DMA
);
89 struct ide_taskfile
*tf
= &cmd
.tf
;
92 if ((hwif
->host_flags
& IDE_HFLAG_NO_LBA48_DMA
) && lba48
&& dma
) {
93 if (block
+ blk_rq_sectors(rq
) > 1ULL << 28)
99 memset(&cmd
, 0, sizeof(cmd
));
100 cmd
.valid
.out
.tf
= IDE_VALID_OUT_TF
| IDE_VALID_DEVICE
;
101 cmd
.valid
.in
.tf
= IDE_VALID_IN_TF
| IDE_VALID_DEVICE
;
103 if (drive
->dev_flags
& IDE_DFLAG_LBA
) {
105 pr_debug("%s: LBA=0x%012llx\n", drive
->name
,
106 (unsigned long long)block
);
108 tf
->nsect
= nsectors
& 0xff;
109 tf
->lbal
= (u8
) block
;
110 tf
->lbam
= (u8
)(block
>> 8);
111 tf
->lbah
= (u8
)(block
>> 16);
112 tf
->device
= ATA_LBA
;
115 tf
->nsect
= (nsectors
>> 8) & 0xff;
116 tf
->lbal
= (u8
)(block
>> 24);
117 if (sizeof(block
) != 4) {
118 tf
->lbam
= (u8
)((u64
)block
>> 32);
119 tf
->lbah
= (u8
)((u64
)block
>> 40);
122 cmd
.valid
.out
.hob
= IDE_VALID_OUT_HOB
;
123 cmd
.valid
.in
.hob
= IDE_VALID_IN_HOB
;
124 cmd
.tf_flags
|= IDE_TFLAG_LBA48
;
126 tf
->nsect
= nsectors
& 0xff;
128 tf
->lbam
= block
>>= 8;
129 tf
->lbah
= block
>>= 8;
130 tf
->device
= ((block
>> 8) & 0xf) | ATA_LBA
;
133 unsigned int sect
, head
, cyl
, track
;
135 track
= (int)block
/ drive
->sect
;
136 sect
= (int)block
% drive
->sect
+ 1;
137 head
= track
% drive
->head
;
138 cyl
= track
/ drive
->head
;
140 pr_debug("%s: CHS=%u/%u/%u\n", drive
->name
, cyl
, head
, sect
);
142 tf
->nsect
= nsectors
& 0xff;
149 cmd
.tf_flags
|= IDE_TFLAG_FS
;
152 cmd
.tf_flags
|= IDE_TFLAG_WRITE
;
154 ide_tf_set_cmd(drive
, &cmd
, dma
);
158 ide_init_sg_cmd(&cmd
, nsectors
<< 9);
159 ide_map_sg(drive
, &cmd
);
162 rc
= do_rw_taskfile(drive
, &cmd
);
164 if (rc
== ide_stopped
&& dma
) {
165 /* fallback to PIO */
166 cmd
.tf_flags
|= IDE_TFLAG_DMA_PIO_FALLBACK
;
167 ide_tf_set_cmd(drive
, &cmd
, 0);
168 ide_init_sg_cmd(&cmd
, nsectors
<< 9);
169 rc
= do_rw_taskfile(drive
, &cmd
);
176 * 268435455 == 137439 MB or 28bit limit
177 * 320173056 == 163929 MB or 48bit addressing
178 * 1073741822 == 549756 MB or 48bit addressing fake drive
181 static ide_startstop_t
ide_do_rw_disk(ide_drive_t
*drive
, struct request
*rq
,
184 ide_hwif_t
*hwif
= drive
->hwif
;
186 BUG_ON(drive
->dev_flags
& IDE_DFLAG_BLOCKED
);
187 BUG_ON(rq
->cmd_type
!= REQ_TYPE_FS
);
189 ledtrig_ide_activity();
191 pr_debug("%s: %sing: block=%llu, sectors=%u, buffer=0x%08lx\n",
192 drive
->name
, rq_data_dir(rq
) == READ
? "read" : "writ",
193 (unsigned long long)block
, blk_rq_sectors(rq
),
194 (unsigned long)rq
->buffer
);
197 hwif
->rw_disk(drive
, rq
);
199 return __ide_do_rw_disk(drive
, rq
, block
);
203 * Queries for true maximum capacity of the drive.
204 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
206 static u64
idedisk_read_native_max_address(ide_drive_t
*drive
, int lba48
)
209 struct ide_taskfile
*tf
= &cmd
.tf
;
212 memset(&cmd
, 0, sizeof(cmd
));
214 tf
->command
= ATA_CMD_READ_NATIVE_MAX_EXT
;
216 tf
->command
= ATA_CMD_READ_NATIVE_MAX
;
217 tf
->device
= ATA_LBA
;
219 cmd
.valid
.out
.tf
= IDE_VALID_OUT_TF
| IDE_VALID_DEVICE
;
220 cmd
.valid
.in
.tf
= IDE_VALID_IN_TF
| IDE_VALID_DEVICE
;
222 cmd
.valid
.out
.hob
= IDE_VALID_OUT_HOB
;
223 cmd
.valid
.in
.hob
= IDE_VALID_IN_HOB
;
224 cmd
.tf_flags
= IDE_TFLAG_LBA48
;
227 ide_no_data_taskfile(drive
, &cmd
);
229 /* if OK, compute maximum address value */
230 if (!(tf
->status
& ATA_ERR
))
231 addr
= ide_get_lba_addr(&cmd
, lba48
) + 1;
237 * Sets maximum virtual LBA address of the drive.
238 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
240 static u64
idedisk_set_max_address(ide_drive_t
*drive
, u64 addr_req
, int lba48
)
243 struct ide_taskfile
*tf
= &cmd
.tf
;
248 memset(&cmd
, 0, sizeof(cmd
));
249 tf
->lbal
= (addr_req
>> 0) & 0xff;
250 tf
->lbam
= (addr_req
>>= 8) & 0xff;
251 tf
->lbah
= (addr_req
>>= 8) & 0xff;
253 cmd
.hob
.lbal
= (addr_req
>>= 8) & 0xff;
254 cmd
.hob
.lbam
= (addr_req
>>= 8) & 0xff;
255 cmd
.hob
.lbah
= (addr_req
>>= 8) & 0xff;
256 tf
->command
= ATA_CMD_SET_MAX_EXT
;
258 tf
->device
= (addr_req
>>= 8) & 0x0f;
259 tf
->command
= ATA_CMD_SET_MAX
;
261 tf
->device
|= ATA_LBA
;
263 cmd
.valid
.out
.tf
= IDE_VALID_OUT_TF
| IDE_VALID_DEVICE
;
264 cmd
.valid
.in
.tf
= IDE_VALID_IN_TF
| IDE_VALID_DEVICE
;
266 cmd
.valid
.out
.hob
= IDE_VALID_OUT_HOB
;
267 cmd
.valid
.in
.hob
= IDE_VALID_IN_HOB
;
268 cmd
.tf_flags
= IDE_TFLAG_LBA48
;
271 ide_no_data_taskfile(drive
, &cmd
);
273 /* if OK, compute maximum address value */
274 if (!(tf
->status
& ATA_ERR
))
275 addr_set
= ide_get_lba_addr(&cmd
, lba48
) + 1;
280 static unsigned long long sectors_to_MB(unsigned long long n
)
282 n
<<= 9; /* make it bytes */
283 do_div(n
, 1000000); /* make it MB */
288 * Some disks report total number of sectors instead of
289 * maximum sector address. We list them here.
291 static const struct drive_list_entry hpa_list
[] = {
292 { "ST340823A", NULL
},
293 { "ST320413A", NULL
},
294 { "ST310211A", NULL
},
298 static u64
ide_disk_hpa_get_native_capacity(ide_drive_t
*drive
, int lba48
)
300 u64 capacity
, set_max
;
302 capacity
= drive
->capacity64
;
303 set_max
= idedisk_read_native_max_address(drive
, lba48
);
305 if (ide_in_drive_list(drive
->id
, hpa_list
)) {
307 * Since we are inclusive wrt to firmware revisions do this
308 * extra check and apply the workaround only when needed.
310 if (set_max
== capacity
+ 1)
317 static u64
ide_disk_hpa_set_capacity(ide_drive_t
*drive
, u64 set_max
, int lba48
)
319 set_max
= idedisk_set_max_address(drive
, set_max
, lba48
);
321 drive
->capacity64
= set_max
;
326 static void idedisk_check_hpa(ide_drive_t
*drive
)
328 u64 capacity
, set_max
;
329 int lba48
= ata_id_lba48_enabled(drive
->id
);
331 capacity
= drive
->capacity64
;
332 set_max
= ide_disk_hpa_get_native_capacity(drive
, lba48
);
334 if (set_max
<= capacity
)
337 drive
->probed_capacity
= set_max
;
339 printk(KERN_INFO
"%s: Host Protected Area detected.\n"
340 "\tcurrent capacity is %llu sectors (%llu MB)\n"
341 "\tnative capacity is %llu sectors (%llu MB)\n",
343 capacity
, sectors_to_MB(capacity
),
344 set_max
, sectors_to_MB(set_max
));
346 if ((drive
->dev_flags
& IDE_DFLAG_NOHPA
) == 0)
349 set_max
= ide_disk_hpa_set_capacity(drive
, set_max
, lba48
);
351 printk(KERN_INFO
"%s: Host Protected Area disabled.\n",
355 static int ide_disk_get_capacity(ide_drive_t
*drive
)
360 if (ata_id_lba48_enabled(id
)) {
361 /* drive speaks 48-bit LBA */
363 drive
->capacity64
= ata_id_u64(id
, ATA_ID_LBA_CAPACITY_2
);
364 } else if (ata_id_has_lba(id
) && ata_id_is_lba_capacity_ok(id
)) {
365 /* drive speaks 28-bit LBA */
367 drive
->capacity64
= ata_id_u32(id
, ATA_ID_LBA_CAPACITY
);
369 /* drive speaks boring old 28-bit CHS */
371 drive
->capacity64
= drive
->cyl
* drive
->head
* drive
->sect
;
374 drive
->probed_capacity
= drive
->capacity64
;
377 drive
->dev_flags
|= IDE_DFLAG_LBA
;
380 * If this device supports the Host Protected Area feature set,
381 * then we may need to change our opinion about its capacity.
383 if (ata_id_hpa_enabled(id
))
384 idedisk_check_hpa(drive
);
387 /* limit drive capacity to 137GB if LBA48 cannot be used */
388 if ((drive
->dev_flags
& IDE_DFLAG_LBA48
) == 0 &&
389 drive
->capacity64
> 1ULL << 28) {
390 printk(KERN_WARNING
"%s: cannot use LBA48 - full capacity "
391 "%llu sectors (%llu MB)\n",
392 drive
->name
, (unsigned long long)drive
->capacity64
,
393 sectors_to_MB(drive
->capacity64
));
394 drive
->probed_capacity
= drive
->capacity64
= 1ULL << 28;
397 if ((drive
->hwif
->host_flags
& IDE_HFLAG_NO_LBA48_DMA
) &&
398 (drive
->dev_flags
& IDE_DFLAG_LBA48
)) {
399 if (drive
->capacity64
> 1ULL << 28) {
400 printk(KERN_INFO
"%s: cannot use LBA48 DMA - PIO mode"
401 " will be used for accessing sectors "
402 "> %u\n", drive
->name
, 1 << 28);
404 drive
->dev_flags
&= ~IDE_DFLAG_LBA48
;
410 static void ide_disk_unlock_native_capacity(ide_drive_t
*drive
)
413 int lba48
= ata_id_lba48_enabled(id
);
415 if ((drive
->dev_flags
& IDE_DFLAG_LBA
) == 0 ||
416 ata_id_hpa_enabled(id
) == 0)
420 * according to the spec the SET MAX ADDRESS command shall be
421 * immediately preceded by a READ NATIVE MAX ADDRESS command
423 if (!ide_disk_hpa_get_native_capacity(drive
, lba48
))
426 if (ide_disk_hpa_set_capacity(drive
, drive
->probed_capacity
, lba48
))
427 drive
->dev_flags
|= IDE_DFLAG_NOHPA
; /* disable HPA on resume */
430 static int idedisk_prep_fn(struct request_queue
*q
, struct request
*rq
)
432 ide_drive_t
*drive
= q
->queuedata
;
435 if (!(rq
->cmd_flags
& REQ_FLUSH
))
440 memset(cmd
, 0, sizeof(*cmd
));
442 cmd
= kzalloc(sizeof(*cmd
), GFP_ATOMIC
);
445 /* FIXME: map struct ide_taskfile on rq->cmd[] */
448 if (ata_id_flush_ext_enabled(drive
->id
) &&
449 (drive
->capacity64
>= (1UL << 28)))
450 cmd
->tf
.command
= ATA_CMD_FLUSH_EXT
;
452 cmd
->tf
.command
= ATA_CMD_FLUSH
;
453 cmd
->valid
.out
.tf
= IDE_VALID_OUT_TF
| IDE_VALID_DEVICE
;
454 cmd
->tf_flags
= IDE_TFLAG_DYN
;
455 cmd
->protocol
= ATA_PROT_NODATA
;
457 rq
->cmd_type
= REQ_TYPE_ATA_TASKFILE
;
464 ide_devset_get(multcount
, mult_count
);
467 * This is tightly woven into the driver->do_special can not touch.
468 * DON'T do it again until a total personality rewrite is committed.
470 static int set_multcount(ide_drive_t
*drive
, int arg
)
475 if (arg
< 0 || arg
> (drive
->id
[ATA_ID_MAX_MULTSECT
] & 0xff))
478 if (drive
->special_flags
& IDE_SFLAG_SET_MULTMODE
)
481 rq
= blk_get_request(drive
->queue
, READ
, __GFP_WAIT
);
482 rq
->cmd_type
= REQ_TYPE_ATA_TASKFILE
;
484 drive
->mult_req
= arg
;
485 drive
->special_flags
|= IDE_SFLAG_SET_MULTMODE
;
486 error
= blk_execute_rq(drive
->queue
, NULL
, rq
, 0);
489 return (drive
->mult_count
== arg
) ? 0 : -EIO
;
492 ide_devset_get_flag(nowerr
, IDE_DFLAG_NOWERR
);
494 static int set_nowerr(ide_drive_t
*drive
, int arg
)
496 if (arg
< 0 || arg
> 1)
500 drive
->dev_flags
|= IDE_DFLAG_NOWERR
;
502 drive
->dev_flags
&= ~IDE_DFLAG_NOWERR
;
504 drive
->bad_wstat
= arg
? BAD_R_STAT
: BAD_W_STAT
;
509 static int ide_do_setfeature(ide_drive_t
*drive
, u8 feature
, u8 nsect
)
513 memset(&cmd
, 0, sizeof(cmd
));
514 cmd
.tf
.feature
= feature
;
515 cmd
.tf
.nsect
= nsect
;
516 cmd
.tf
.command
= ATA_CMD_SET_FEATURES
;
517 cmd
.valid
.out
.tf
= IDE_VALID_OUT_TF
| IDE_VALID_DEVICE
;
518 cmd
.valid
.in
.tf
= IDE_VALID_IN_TF
| IDE_VALID_DEVICE
;
520 return ide_no_data_taskfile(drive
, &cmd
);
523 static void update_flush(ide_drive_t
*drive
)
528 if (drive
->dev_flags
& IDE_DFLAG_WCACHE
) {
529 unsigned long long capacity
;
532 * We must avoid issuing commands a drive does not
533 * understand or we may crash it. We check flush cache
534 * is supported. We also check we have the LBA48 flush
535 * cache if the drive capacity is too large. By this
536 * time we have trimmed the drive capacity if LBA48 is
537 * not available so we don't need to recheck that.
539 capacity
= ide_gd_capacity(drive
);
540 barrier
= ata_id_flush_enabled(id
) &&
541 (drive
->dev_flags
& IDE_DFLAG_NOFLUSH
) == 0 &&
542 ((drive
->dev_flags
& IDE_DFLAG_LBA48
) == 0 ||
543 capacity
<= (1ULL << 28) ||
544 ata_id_flush_ext_enabled(id
));
546 printk(KERN_INFO
"%s: cache flushes %ssupported\n",
547 drive
->name
, barrier
? "" : "not ");
551 blk_queue_prep_rq(drive
->queue
, idedisk_prep_fn
);
555 blk_queue_flush(drive
->queue
, flush
);
558 ide_devset_get_flag(wcache
, IDE_DFLAG_WCACHE
);
560 static int set_wcache(ide_drive_t
*drive
, int arg
)
564 if (arg
< 0 || arg
> 1)
567 if (ata_id_flush_enabled(drive
->id
)) {
568 err
= ide_do_setfeature(drive
,
569 arg
? SETFEATURES_WC_ON
: SETFEATURES_WC_OFF
, 0);
572 drive
->dev_flags
|= IDE_DFLAG_WCACHE
;
574 drive
->dev_flags
&= ~IDE_DFLAG_WCACHE
;
583 static int do_idedisk_flushcache(ide_drive_t
*drive
)
587 memset(&cmd
, 0, sizeof(cmd
));
588 if (ata_id_flush_ext_enabled(drive
->id
))
589 cmd
.tf
.command
= ATA_CMD_FLUSH_EXT
;
591 cmd
.tf
.command
= ATA_CMD_FLUSH
;
592 cmd
.valid
.out
.tf
= IDE_VALID_OUT_TF
| IDE_VALID_DEVICE
;
593 cmd
.valid
.in
.tf
= IDE_VALID_IN_TF
| IDE_VALID_DEVICE
;
595 return ide_no_data_taskfile(drive
, &cmd
);
598 ide_devset_get(acoustic
, acoustic
);
600 static int set_acoustic(ide_drive_t
*drive
, int arg
)
602 if (arg
< 0 || arg
> 254)
605 ide_do_setfeature(drive
,
606 arg
? SETFEATURES_AAM_ON
: SETFEATURES_AAM_OFF
, arg
);
608 drive
->acoustic
= arg
;
613 ide_devset_get_flag(addressing
, IDE_DFLAG_LBA48
);
619 * 2: 48-bit capable doing 28-bit
621 static int set_addressing(ide_drive_t
*drive
, int arg
)
623 if (arg
< 0 || arg
> 2)
626 if (arg
&& ((drive
->hwif
->host_flags
& IDE_HFLAG_NO_LBA48
) ||
627 ata_id_lba48_enabled(drive
->id
) == 0))
634 drive
->dev_flags
|= IDE_DFLAG_LBA48
;
636 drive
->dev_flags
&= ~IDE_DFLAG_LBA48
;
641 ide_ext_devset_rw(acoustic
, acoustic
);
642 ide_ext_devset_rw(address
, addressing
);
643 ide_ext_devset_rw(multcount
, multcount
);
644 ide_ext_devset_rw(wcache
, wcache
);
646 ide_ext_devset_rw_sync(nowerr
, nowerr
);
648 static int ide_disk_check(ide_drive_t
*drive
, const char *s
)
653 static void ide_disk_setup(ide_drive_t
*drive
)
655 struct ide_disk_obj
*idkp
= drive
->driver_data
;
656 struct request_queue
*q
= drive
->queue
;
657 ide_hwif_t
*hwif
= drive
->hwif
;
659 char *m
= (char *)&id
[ATA_ID_PROD
];
660 unsigned long long capacity
;
662 ide_proc_register_driver(drive
, idkp
->driver
);
664 if ((drive
->dev_flags
& IDE_DFLAG_ID_READ
) == 0)
667 if (drive
->dev_flags
& IDE_DFLAG_REMOVABLE
) {
669 * Removable disks (eg. SYQUEST); ignore 'WD' drives
671 if (m
[0] != 'W' || m
[1] != 'D')
672 drive
->dev_flags
|= IDE_DFLAG_DOORLOCKING
;
675 (void)set_addressing(drive
, 1);
677 if (drive
->dev_flags
& IDE_DFLAG_LBA48
) {
680 if (max_s
> hwif
->rqsize
)
681 max_s
= hwif
->rqsize
;
683 blk_queue_max_hw_sectors(q
, max_s
);
686 printk(KERN_INFO
"%s: max request size: %dKiB\n", drive
->name
,
687 queue_max_sectors(q
) / 2);
689 if (ata_id_is_ssd(id
))
690 queue_flag_set_unlocked(QUEUE_FLAG_NONROT
, q
);
692 /* calculate drive capacity, and select LBA if possible */
693 ide_disk_get_capacity(drive
);
696 * if possible, give fdisk access to more of the drive,
697 * by correcting bios_cyls:
699 capacity
= ide_gd_capacity(drive
);
701 if ((drive
->dev_flags
& IDE_DFLAG_FORCED_GEOM
) == 0) {
702 if (ata_id_lba48_enabled(drive
->id
)) {
704 drive
->bios_sect
= 63;
705 drive
->bios_head
= 255;
708 if (drive
->bios_sect
&& drive
->bios_head
) {
709 unsigned int cap0
= capacity
; /* truncate to 32 bits */
710 unsigned int cylsz
, cyl
;
712 if (cap0
!= capacity
)
713 drive
->bios_cyl
= 65535;
715 cylsz
= drive
->bios_sect
* drive
->bios_head
;
719 if (cyl
> drive
->bios_cyl
)
720 drive
->bios_cyl
= cyl
;
724 printk(KERN_INFO
"%s: %llu sectors (%llu MB)",
725 drive
->name
, capacity
, sectors_to_MB(capacity
));
727 /* Only print cache size when it was specified */
728 if (id
[ATA_ID_BUF_SIZE
])
729 printk(KERN_CONT
" w/%dKiB Cache", id
[ATA_ID_BUF_SIZE
] / 2);
731 printk(KERN_CONT
", CHS=%d/%d/%d\n",
732 drive
->bios_cyl
, drive
->bios_head
, drive
->bios_sect
);
734 /* write cache enabled? */
735 if ((id
[ATA_ID_CSFO
] & 1) || ata_id_wcache_enabled(id
))
736 drive
->dev_flags
|= IDE_DFLAG_WCACHE
;
738 set_wcache(drive
, 1);
740 if ((drive
->dev_flags
& IDE_DFLAG_LBA
) == 0 &&
741 (drive
->head
== 0 || drive
->head
> 16)) {
742 printk(KERN_ERR
"%s: invalid geometry: %d physical heads?\n",
743 drive
->name
, drive
->head
);
744 drive
->dev_flags
&= ~IDE_DFLAG_ATTACH
;
746 drive
->dev_flags
|= IDE_DFLAG_ATTACH
;
749 static void ide_disk_flush(ide_drive_t
*drive
)
751 if (ata_id_flush_enabled(drive
->id
) == 0 ||
752 (drive
->dev_flags
& IDE_DFLAG_WCACHE
) == 0)
755 if (do_idedisk_flushcache(drive
))
756 printk(KERN_INFO
"%s: wcache flush failed!\n", drive
->name
);
759 static int ide_disk_init_media(ide_drive_t
*drive
, struct gendisk
*disk
)
764 static int ide_disk_set_doorlock(ide_drive_t
*drive
, struct gendisk
*disk
,
770 if ((drive
->dev_flags
& IDE_DFLAG_DOORLOCKING
) == 0)
773 memset(&cmd
, 0, sizeof(cmd
));
774 cmd
.tf
.command
= on
? ATA_CMD_MEDIA_LOCK
: ATA_CMD_MEDIA_UNLOCK
;
775 cmd
.valid
.out
.tf
= IDE_VALID_OUT_TF
| IDE_VALID_DEVICE
;
776 cmd
.valid
.in
.tf
= IDE_VALID_IN_TF
| IDE_VALID_DEVICE
;
778 ret
= ide_no_data_taskfile(drive
, &cmd
);
781 drive
->dev_flags
&= ~IDE_DFLAG_DOORLOCKING
;
786 const struct ide_disk_ops ide_ata_disk_ops
= {
787 .check
= ide_disk_check
,
788 .unlock_native_capacity
= ide_disk_unlock_native_capacity
,
789 .get_capacity
= ide_disk_get_capacity
,
790 .setup
= ide_disk_setup
,
791 .flush
= ide_disk_flush
,
792 .init_media
= ide_disk_init_media
,
793 .set_doorlock
= ide_disk_set_doorlock
,
794 .do_request
= ide_do_rw_disk
,
795 .ioctl
= ide_disk_ioctl
,