]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/ide/ide-disk.c
ide-cd: fix DMA alignment regression
[mirror_ubuntu-bionic-kernel.git] / drivers / ide / ide-disk.c
CommitLineData
1da177e4 1/*
59bca8cc
BZ
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
1da177e4
LT
7 */
8
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>
13 *
14 * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
1da177e4
LT
15 */
16
1da177e4
LT
17#include <linux/types.h>
18#include <linux/string.h>
19#include <linux/kernel.h>
20#include <linux/timer.h>
21#include <linux/mm.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>
cf8b8975 28#include <linux/mutex.h>
2bfb646c 29#include <linux/leds.h>
1da177e4 30#include <linux/ide.h>
3ceca727 31#include <linux/hdreg.h>
1da177e4
LT
32
33#include <asm/byteorder.h>
34#include <asm/irq.h>
35#include <asm/uaccess.h>
36#include <asm/io.h>
37#include <asm/div64.h>
38
f8790489 39#include "ide-disk.h"
1da177e4 40
ba76ae38 41static const u8 ide_rw_cmds[] = {
aaaade3f
BZ
42 ATA_CMD_READ_MULTI,
43 ATA_CMD_WRITE_MULTI,
44 ATA_CMD_READ_MULTI_EXT,
45 ATA_CMD_WRITE_MULTI_EXT,
46 ATA_CMD_PIO_READ,
47 ATA_CMD_PIO_WRITE,
48 ATA_CMD_PIO_READ_EXT,
49 ATA_CMD_PIO_WRITE_EXT,
50 ATA_CMD_READ,
51 ATA_CMD_WRITE,
52 ATA_CMD_READ_EXT,
53 ATA_CMD_WRITE_EXT,
ba76ae38
BZ
54};
55
56static const u8 ide_data_phases[] = {
57 TASKFILE_MULTI_IN,
58 TASKFILE_MULTI_OUT,
59 TASKFILE_IN,
60 TASKFILE_OUT,
61 TASKFILE_IN_DMA,
62 TASKFILE_OUT_DMA,
63};
64
65static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
66{
67 u8 index, lba48, write;
68
69 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
70 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
71
72 if (dma)
ba4b2e60 73 index = 8;
ba76ae38
BZ
74 else
75 index = drive->mult_count ? 0 : 4;
76
77 task->tf.command = ide_rw_cmds[index + lba48 + write];
78
79 if (dma)
80 index = 8; /* fixup index */
81
82 task->data_phase = ide_data_phases[index / 2 + write];
83}
84
1da177e4
LT
85/*
86 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
87 * using LBA if supported, or CHS otherwise, to address sectors.
88 */
98416549
BZ
89static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
90 sector_t block)
1da177e4
LT
91{
92 ide_hwif_t *hwif = HWIF(drive);
790d1239 93 u16 nsectors = (u16)rq->nr_sectors;
97100fc8
BZ
94 u8 lba48 = !!(drive->dev_flags & IDE_DFLAG_LBA48);
95 u8 dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
9e42237f
BZ
96 ide_task_t task;
97 struct ide_taskfile *tf = &task.tf;
f6e29e35 98 ide_startstop_t rc;
1da177e4 99
238e4f14 100 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
1da177e4
LT
101 if (block + rq->nr_sectors > 1ULL << 28)
102 dma = 0;
103 else
104 lba48 = 0;
105 }
106
107 if (!dma) {
108 ide_init_sg_cmd(drive, rq);
109 ide_map_sg(drive, rq);
110 }
111
9e42237f 112 memset(&task, 0, sizeof(task));
9a410e79 113 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
2bd06b23 114
d1d76714 115 if (drive->dev_flags & IDE_DFLAG_LBA) {
1da177e4 116 if (lba48) {
c2f8311d
MR
117 pr_debug("%s: LBA=0x%012llx\n", drive->name,
118 (unsigned long long)block);
1da177e4 119
790d1239 120 tf->hob_nsect = (nsectors >> 8) & 0xff;
2bd06b23
BZ
121 tf->hob_lbal = (u8)(block >> 24);
122 if (sizeof(block) != 4) {
123 tf->hob_lbam = (u8)((u64)block >> 32);
124 tf->hob_lbah = (u8)((u64)block >> 40);
1da177e4 125 }
2bd06b23 126
790d1239 127 tf->nsect = nsectors & 0xff;
2bd06b23
BZ
128 tf->lbal = (u8) block;
129 tf->lbam = (u8)(block >> 8);
130 tf->lbah = (u8)(block >> 16);
6dd9b837 131
657cc1a8 132 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
1da177e4 133 } else {
790d1239 134 tf->nsect = nsectors & 0xff;
2bd06b23
BZ
135 tf->lbal = block;
136 tf->lbam = block >>= 8;
137 tf->lbah = block >>= 8;
138 tf->device = (block >> 8) & 0xf;
1da177e4 139 }
d1d76714
BZ
140
141 tf->device |= ATA_LBA;
1da177e4 142 } else {
98416549
BZ
143 unsigned int sect, head, cyl, track;
144
1da177e4
LT
145 track = (int)block / drive->sect;
146 sect = (int)block % drive->sect + 1;
1da177e4
LT
147 head = track % drive->head;
148 cyl = track / drive->head;
149
150 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
151
790d1239 152 tf->nsect = nsectors & 0xff;
2bd06b23
BZ
153 tf->lbal = sect;
154 tf->lbam = cyl;
155 tf->lbah = cyl >> 8;
156 tf->device = head;
1da177e4
LT
157 }
158
ba76ae38
BZ
159 if (rq_data_dir(rq))
160 task.tf_flags |= IDE_TFLAG_WRITE;
161
162 ide_tf_set_cmd(drive, &task, dma);
f6e29e35
BZ
163 if (!dma)
164 hwif->data_phase = task.data_phase;
165 task.rq = rq;
ba76ae38 166
f6e29e35 167 rc = do_rw_taskfile(drive, &task);
2bd06b23 168
f6e29e35 169 if (rc == ide_stopped && dma) {
1da177e4 170 /* fallback to PIO */
f6e29e35 171 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
ba76ae38 172 ide_tf_set_cmd(drive, &task, 0);
f6e29e35 173 hwif->data_phase = task.data_phase;
1da177e4 174 ide_init_sg_cmd(drive, rq);
f6e29e35 175 rc = do_rw_taskfile(drive, &task);
1da177e4
LT
176 }
177
f6e29e35 178 return rc;
1da177e4
LT
179}
180
181/*
182 * 268435455 == 137439 MB or 28bit limit
183 * 320173056 == 163929 MB or 48bit addressing
184 * 1073741822 == 549756 MB or 48bit addressing fake drive
185 */
186
806f80a6
BZ
187static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
188 sector_t block)
1da177e4
LT
189{
190 ide_hwif_t *hwif = HWIF(drive);
191
97100fc8 192 BUG_ON(drive->dev_flags & IDE_DFLAG_BLOCKED);
1da177e4
LT
193
194 if (!blk_fs_request(rq)) {
195 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
196 ide_end_request(drive, 0, 0);
197 return ide_stopped;
198 }
199
2bfb646c
RP
200 ledtrig_ide_activity();
201
1da177e4
LT
202 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
203 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
c2f8311d
MR
204 (unsigned long long)block, rq->nr_sectors,
205 (unsigned long)rq->buffer);
1da177e4
LT
206
207 if (hwif->rw_disk)
208 hwif->rw_disk(drive, rq);
209
210 return __ide_do_rw_disk(drive, rq, block);
211}
212
213/*
214 * Queries for true maximum capacity of the drive.
215 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
216 */
7a3b7512 217static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
1da177e4
LT
218{
219 ide_task_t args;
650d841d 220 struct ide_taskfile *tf = &args.tf;
7a3b7512 221 u64 addr = 0;
1da177e4
LT
222
223 /* Create IDE/ATA command request structure */
224 memset(&args, 0, sizeof(ide_task_t));
7a3b7512 225 if (lba48)
aaaade3f 226 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
7a3b7512 227 else
aaaade3f 228 tf->command = ATA_CMD_READ_NATIVE_MAX;
650d841d 229 tf->device = ATA_LBA;
657cc1a8 230 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
a3bbb9d8 231 if (lba48)
657cc1a8 232 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
1da177e4 233 /* submit command request */
9a3c49be 234 ide_no_data_taskfile(drive, &args);
1da177e4 235
1da177e4 236 /* if OK, compute maximum address value */
a501633c
BZ
237 if ((tf->status & 0x01) == 0)
238 addr = ide_get_lba_addr(tf, lba48) + 1;
650d841d 239
1da177e4
LT
240 return addr;
241}
242
243/*
244 * Sets maximum virtual LBA address of the drive.
245 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
246 */
7a3b7512 247static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
1da177e4
LT
248{
249 ide_task_t args;
650d841d 250 struct ide_taskfile *tf = &args.tf;
7a3b7512 251 u64 addr_set = 0;
1da177e4
LT
252
253 addr_req--;
254 /* Create IDE/ATA command request structure */
255 memset(&args, 0, sizeof(ide_task_t));
650d841d
BZ
256 tf->lbal = (addr_req >> 0) & 0xff;
257 tf->lbam = (addr_req >>= 8) & 0xff;
258 tf->lbah = (addr_req >>= 8) & 0xff;
7a3b7512
BZ
259 if (lba48) {
260 tf->hob_lbal = (addr_req >>= 8) & 0xff;
261 tf->hob_lbam = (addr_req >>= 8) & 0xff;
262 tf->hob_lbah = (addr_req >>= 8) & 0xff;
aaaade3f 263 tf->command = ATA_CMD_SET_MAX_EXT;
7a3b7512
BZ
264 } else {
265 tf->device = (addr_req >>= 8) & 0x0f;
aaaade3f 266 tf->command = ATA_CMD_SET_MAX;
7a3b7512
BZ
267 }
268 tf->device |= ATA_LBA;
657cc1a8 269 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
a3bbb9d8 270 if (lba48)
657cc1a8 271 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
1da177e4 272 /* submit command request */
9a3c49be 273 ide_no_data_taskfile(drive, &args);
1da177e4 274 /* if OK, compute maximum address value */
a501633c
BZ
275 if ((tf->status & 0x01) == 0)
276 addr_set = ide_get_lba_addr(tf, lba48) + 1;
650d841d 277
1da177e4
LT
278 return addr_set;
279}
280
281static unsigned long long sectors_to_MB(unsigned long long n)
282{
283 n <<= 9; /* make it bytes */
284 do_div(n, 1000000); /* make it MB */
285 return n;
286}
287
b0244a00
BZ
288/*
289 * Some disks report total number of sectors instead of
290 * maximum sector address. We list them here.
291 */
292static const struct drive_list_entry hpa_list[] = {
293 { "ST340823A", NULL },
7062cdc5 294 { "ST320413A", NULL },
b152fcd3 295 { "ST310211A", NULL },
b0244a00
BZ
296 { NULL, NULL }
297};
298
858119e1 299static void idedisk_check_hpa(ide_drive_t *drive)
1da177e4
LT
300{
301 unsigned long long capacity, set_max;
942dcd85 302 int lba48 = ata_id_lba48_enabled(drive->id);
1da177e4
LT
303
304 capacity = drive->capacity64;
7a3b7512
BZ
305
306 set_max = idedisk_read_native_max_address(drive, lba48);
1da177e4 307
b0244a00
BZ
308 if (ide_in_drive_list(drive->id, hpa_list)) {
309 /*
310 * Since we are inclusive wrt to firmware revisions do this
311 * extra check and apply the workaround only when needed.
312 */
313 if (set_max == capacity + 1)
314 set_max--;
315 }
316
1da177e4
LT
317 if (set_max <= capacity)
318 return;
319
320 printk(KERN_INFO "%s: Host Protected Area detected.\n"
321 "\tcurrent capacity is %llu sectors (%llu MB)\n"
322 "\tnative capacity is %llu sectors (%llu MB)\n",
323 drive->name,
324 capacity, sectors_to_MB(capacity),
325 set_max, sectors_to_MB(set_max));
326
7a3b7512
BZ
327 set_max = idedisk_set_max_address(drive, set_max, lba48);
328
1da177e4
LT
329 if (set_max) {
330 drive->capacity64 = set_max;
331 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
332 drive->name);
333 }
334}
335
806f80a6 336static int ide_disk_get_capacity(ide_drive_t *drive)
1da177e4 337{
4dde4492 338 u16 *id = drive->id;
d1d76714 339 int lba;
1da177e4 340
942dcd85 341 if (ata_id_lba48_enabled(id)) {
1da177e4 342 /* drive speaks 48-bit LBA */
d1d76714 343 lba = 1;
48fb2688 344 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
a02227c9 345 } else if (ata_id_has_lba(id) && ata_id_is_lba_capacity_ok(id)) {
1da177e4 346 /* drive speaks 28-bit LBA */
d1d76714 347 lba = 1;
48fb2688 348 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
1da177e4
LT
349 } else {
350 /* drive speaks boring old 28-bit CHS */
d1d76714 351 lba = 0;
1da177e4
LT
352 drive->capacity64 = drive->cyl * drive->head * drive->sect;
353 }
d1d76714
BZ
354
355 if (lba) {
356 drive->dev_flags |= IDE_DFLAG_LBA;
357
358 /*
359 * If this device supports the Host Protected Area feature set,
360 * then we may need to change our opinion about its capacity.
361 */
362 if (ata_id_hpa_enabled(id))
363 idedisk_check_hpa(drive);
364 }
0a70c7f6
BZ
365
366 /* limit drive capacity to 137GB if LBA48 cannot be used */
367 if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
368 drive->capacity64 > 1ULL << 28) {
369 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
370 "%llu sectors (%llu MB)\n",
371 drive->name, (unsigned long long)drive->capacity64,
372 sectors_to_MB(drive->capacity64));
373 drive->capacity64 = 1ULL << 28;
374 }
375
376 if ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
377 (drive->dev_flags & IDE_DFLAG_LBA48)) {
378 if (drive->capacity64 > 1ULL << 28) {
379 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
380 " will be used for accessing sectors "
381 "> %u\n", drive->name, 1 << 28);
382 } else
383 drive->dev_flags &= ~IDE_DFLAG_LBA48;
384 }
806f80a6
BZ
385
386 return 0;
1da177e4
LT
387}
388
165125e1 389static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
1da177e4
LT
390{
391 ide_drive_t *drive = q->queuedata;
395d8ef5 392 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
1da177e4 393
395d8ef5
BZ
394 /* FIXME: map struct ide_taskfile on rq->cmd[] */
395 BUG_ON(task == NULL);
396
397 memset(task, 0, sizeof(*task));
ff2779b5 398 if (ata_id_flush_ext_enabled(drive->id) &&
1da177e4 399 (drive->capacity64 >= (1UL << 28)))
aaaade3f 400 task->tf.command = ATA_CMD_FLUSH_EXT;
1da177e4 401 else
aaaade3f 402 task->tf.command = ATA_CMD_FLUSH;
395d8ef5
BZ
403 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
404 IDE_TFLAG_DYN;
405 task->data_phase = TASKFILE_NO_DATA;
1da177e4 406
813a0eb2 407 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
4aff5e23 408 rq->cmd_flags |= REQ_SOFTBARRIER;
395d8ef5 409 rq->special = task;
1da177e4
LT
410}
411
8185d5aa
BZ
412ide_devset_get(multcount, mult_count);
413
1da177e4
LT
414/*
415 * This is tightly woven into the driver->do_special can not touch.
416 * DON'T do it again until a total personality rewrite is committed.
417 */
418static int set_multcount(ide_drive_t *drive, int arg)
419{
dd47087b
FT
420 struct request *rq;
421 int error;
1da177e4 422
48fb2688 423 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
1497943e
BZ
424 return -EINVAL;
425
1da177e4
LT
426 if (drive->special.b.set_multmode)
427 return -EBUSY;
852738f3 428
dd47087b
FT
429 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
430 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
852738f3 431
1da177e4
LT
432 drive->mult_req = arg;
433 drive->special.b.set_multmode = 1;
dd47087b
FT
434 error = blk_execute_rq(drive->queue, NULL, rq, 0);
435 blk_put_request(rq);
98416549 436
1da177e4
LT
437 return (drive->mult_count == arg) ? 0 : -EIO;
438}
439
97100fc8 440ide_devset_get_flag(nowerr, IDE_DFLAG_NOWERR);
8185d5aa 441
1da177e4
LT
442static int set_nowerr(ide_drive_t *drive, int arg)
443{
1497943e
BZ
444 if (arg < 0 || arg > 1)
445 return -EINVAL;
446
97100fc8
BZ
447 if (arg)
448 drive->dev_flags |= IDE_DFLAG_NOWERR;
449 else
450 drive->dev_flags &= ~IDE_DFLAG_NOWERR;
451
1da177e4 452 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
97100fc8 453
1da177e4
LT
454 return 0;
455}
456
be3c096e
BZ
457static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)
458{
459 ide_task_t task;
460
461 memset(&task, 0, sizeof(task));
462 task.tf.feature = feature;
463 task.tf.nsect = nsect;
464 task.tf.command = ATA_CMD_SET_FEATURES;
465 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
466
467 return ide_no_data_taskfile(drive, &task);
468}
469
3e087b57
TH
470static void update_ordered(ide_drive_t *drive)
471{
4dde4492 472 u16 *id = drive->id;
3e087b57
TH
473 unsigned ordered = QUEUE_ORDERED_NONE;
474 prepare_flush_fn *prep_fn = NULL;
3e087b57 475
97100fc8 476 if (drive->dev_flags & IDE_DFLAG_WCACHE) {
3e087b57
TH
477 unsigned long long capacity;
478 int barrier;
479 /*
480 * We must avoid issuing commands a drive does not
481 * understand or we may crash it. We check flush cache
482 * is supported. We also check we have the LBA48 flush
483 * cache if the drive capacity is too large. By this
484 * time we have trimmed the drive capacity if LBA48 is
485 * not available so we don't need to recheck that.
486 */
5fef0e5c 487 capacity = ide_gd_capacity(drive);
97100fc8
BZ
488 barrier = ata_id_flush_enabled(id) &&
489 (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 &&
490 ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 ||
491 capacity <= (1ULL << 28) ||
ff2779b5 492 ata_id_flush_ext_enabled(id));
3e087b57
TH
493
494 printk(KERN_INFO "%s: cache flushes %ssupported\n",
f7ad836c 495 drive->name, barrier ? "" : "not ");
3e087b57
TH
496
497 if (barrier) {
498 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
499 prep_fn = idedisk_prepare_flush;
3e087b57
TH
500 }
501 } else
502 ordered = QUEUE_ORDERED_DRAIN;
503
504 blk_queue_ordered(drive->queue, ordered, prep_fn);
3e087b57
TH
505}
506
97100fc8 507ide_devset_get_flag(wcache, IDE_DFLAG_WCACHE);
8185d5aa
BZ
508
509static int set_wcache(ide_drive_t *drive, int arg)
1da177e4 510{
3e087b57 511 int err = 1;
1da177e4 512
1497943e
BZ
513 if (arg < 0 || arg > 1)
514 return -EINVAL;
515
4b58f17d 516 if (ata_id_flush_enabled(drive->id)) {
be3c096e
BZ
517 err = ide_do_setfeature(drive,
518 arg ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF, 0);
97100fc8
BZ
519 if (err == 0) {
520 if (arg)
521 drive->dev_flags |= IDE_DFLAG_WCACHE;
522 else
523 drive->dev_flags &= ~IDE_DFLAG_WCACHE;
524 }
3e087b57 525 }
1da177e4 526
3e087b57 527 update_ordered(drive);
1da177e4 528
3e087b57 529 return err;
1da177e4
LT
530}
531
98416549 532static int do_idedisk_flushcache(ide_drive_t *drive)
1da177e4
LT
533{
534 ide_task_t args;
535
536 memset(&args, 0, sizeof(ide_task_t));
ff2779b5 537 if (ata_id_flush_ext_enabled(drive->id))
aaaade3f 538 args.tf.command = ATA_CMD_FLUSH_EXT;
1da177e4 539 else
aaaade3f 540 args.tf.command = ATA_CMD_FLUSH;
657cc1a8 541 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
9a3c49be 542 return ide_no_data_taskfile(drive, &args);
1da177e4
LT
543}
544
8185d5aa
BZ
545ide_devset_get(acoustic, acoustic);
546
98416549 547static int set_acoustic(ide_drive_t *drive, int arg)
1da177e4 548{
1497943e
BZ
549 if (arg < 0 || arg > 254)
550 return -EINVAL;
551
be3c096e
BZ
552 ide_do_setfeature(drive,
553 arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF, arg);
554
1da177e4 555 drive->acoustic = arg;
be3c096e 556
1da177e4
LT
557 return 0;
558}
559
97100fc8 560ide_devset_get_flag(addressing, IDE_DFLAG_LBA48);
8185d5aa 561
1da177e4
LT
562/*
563 * drive->addressing:
564 * 0: 28-bit
565 * 1: 48-bit
566 * 2: 48-bit capable doing 28-bit
567 */
aa768773 568static int set_addressing(ide_drive_t *drive, int arg)
1da177e4 569{
1497943e
BZ
570 if (arg < 0 || arg > 2)
571 return -EINVAL;
572
35c13753
BZ
573 if (arg && ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
574 ata_id_lba48_enabled(drive->id) == 0))
98416549 575 return -EIO;
942dcd85 576
35c13753
BZ
577 if (arg == 2)
578 arg = 0;
579
97100fc8
BZ
580 if (arg)
581 drive->dev_flags |= IDE_DFLAG_LBA48;
582 else
583 drive->dev_flags &= ~IDE_DFLAG_LBA48;
942dcd85 584
1da177e4
LT
585 return 0;
586}
587
f8790489
BZ
588ide_ext_devset_rw(acoustic, acoustic);
589ide_ext_devset_rw(address, addressing);
590ide_ext_devset_rw(multcount, multcount);
591ide_ext_devset_rw(wcache, wcache);
92f1f8fd 592
f8790489 593ide_ext_devset_rw_sync(nowerr, nowerr);
92f1f8fd 594
806f80a6
BZ
595static int ide_disk_check(ide_drive_t *drive, const char *s)
596{
597 return 1;
598}
599
600static void ide_disk_setup(ide_drive_t *drive)
1da177e4 601{
1e874f44 602 struct ide_disk_obj *idkp = drive->driver_data;
c77380d4 603 struct request_queue *q = drive->queue;
238e4f14 604 ide_hwif_t *hwif = drive->hwif;
4dde4492
BZ
605 u16 *id = drive->id;
606 char *m = (char *)&id[ATA_ID_PROD];
1da177e4 607 unsigned long long capacity;
1da177e4 608
1e874f44 609 ide_proc_register_driver(drive, idkp->driver);
1da177e4 610
97100fc8 611 if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0)
1da177e4
LT
612 return;
613
97100fc8 614 if (drive->dev_flags & IDE_DFLAG_REMOVABLE) {
1da177e4 615 /*
98416549 616 * Removable disks (eg. SYQUEST); ignore 'WD' drives
1da177e4 617 */
4dde4492 618 if (m[0] != 'W' || m[1] != 'D')
97100fc8 619 drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
1da177e4
LT
620 }
621
aa768773 622 (void)set_addressing(drive, 1);
1da177e4 623
97100fc8 624 if (drive->dev_flags & IDE_DFLAG_LBA48) {
1da177e4
LT
625 int max_s = 2048;
626
627 if (max_s > hwif->rqsize)
628 max_s = hwif->rqsize;
629
c77380d4 630 blk_queue_max_sectors(q, max_s);
1da177e4
LT
631 }
632
98416549 633 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
c77380d4
BZ
634 q->max_sectors / 2);
635
636 if (ata_id_is_ssd(id) || ata_id_is_cfa(id))
637 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, q);
1da177e4
LT
638
639 /* calculate drive capacity, and select LBA if possible */
806f80a6 640 ide_disk_get_capacity(drive);
1da177e4 641
1da177e4
LT
642 /*
643 * if possible, give fdisk access to more of the drive,
644 * by correcting bios_cyls:
645 */
5fef0e5c 646 capacity = ide_gd_capacity(drive);
98416549 647
97100fc8 648 if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) {
942dcd85 649 if (ata_id_lba48_enabled(drive->id)) {
1da177e4
LT
650 /* compatibility */
651 drive->bios_sect = 63;
652 drive->bios_head = 255;
653 }
654
655 if (drive->bios_sect && drive->bios_head) {
656 unsigned int cap0 = capacity; /* truncate to 32 bits */
657 unsigned int cylsz, cyl;
658
659 if (cap0 != capacity)
660 drive->bios_cyl = 65535;
661 else {
662 cylsz = drive->bios_sect * drive->bios_head;
663 cyl = cap0 / cylsz;
664 if (cyl > 65535)
665 cyl = 65535;
666 if (cyl > drive->bios_cyl)
667 drive->bios_cyl = cyl;
668 }
669 }
670 }
671 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
672 drive->name, capacity, sectors_to_MB(capacity));
673
674 /* Only print cache size when it was specified */
4dde4492
BZ
675 if (id[ATA_ID_BUF_SIZE])
676 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
1da177e4 677
3ab7efe8
BZ
678 printk(KERN_CONT ", CHS=%d/%d/%d\n",
679 drive->bios_cyl, drive->bios_head, drive->bios_sect);
1da177e4 680
1da177e4 681 /* write cache enabled? */
8a089c66 682 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
97100fc8 683 drive->dev_flags |= IDE_DFLAG_WCACHE;
1da177e4 684
8185d5aa 685 set_wcache(drive, 1);
ae9f9f07
BZ
686
687 if ((drive->dev_flags & IDE_DFLAG_LBA) == 0 &&
688 (drive->head == 0 || drive->head > 16)) {
689 printk(KERN_ERR "%s: invalid geometry: %d physical heads?\n",
690 drive->name, drive->head);
691 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
692 } else
693 drive->dev_flags |= IDE_DFLAG_ATTACH;
1da177e4
LT
694}
695
806f80a6 696static void ide_disk_flush(ide_drive_t *drive)
1da177e4 697{
97100fc8
BZ
698 if (ata_id_flush_enabled(drive->id) == 0 ||
699 (drive->dev_flags & IDE_DFLAG_WCACHE) == 0)
1da177e4
LT
700 return;
701
702 if (do_idedisk_flushcache(drive))
703 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
704}
705
806f80a6
BZ
706static int ide_disk_init_media(ide_drive_t *drive, struct gendisk *disk)
707{
708 return 0;
709}
710
711static int ide_disk_set_doorlock(ide_drive_t *drive, struct gendisk *disk,
712 int on)
29ec683f
BZ
713{
714 ide_task_t task;
81ee1bb5
BZ
715 int ret;
716
717 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
718 return 0;
29ec683f
BZ
719
720 memset(&task, 0, sizeof(task));
aaaade3f 721 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
657cc1a8 722 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
29ec683f 723
81ee1bb5
BZ
724 ret = ide_no_data_taskfile(drive, &task);
725
726 if (ret)
727 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
728
729 return ret;
29ec683f 730}
806f80a6
BZ
731
732const struct ide_disk_ops ide_ata_disk_ops = {
733 .check = ide_disk_check,
734 .get_capacity = ide_disk_get_capacity,
735 .setup = ide_disk_setup,
736 .flush = ide_disk_flush,
737 .init_media = ide_disk_init_media,
738 .set_doorlock = ide_disk_set_doorlock,
739 .do_request = ide_do_rw_disk,
740 .end_request = ide_end_request,
741 .ioctl = ide_disk_ioctl,
742};