blob: 806760d24cefd263e4ab8202a3659053be40f3f9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Bartlomiej Zolnierkiewicz59bca8c2008-02-01 23:09:33 +01002 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below)
3 * Copyright (C) 1998-2002 Linux ATA Development
4 * Andre Hedrick <andre@linux-ide.org>
Alan Coxccd32e22008-11-02 21:40:08 +01005 * Copyright (C) 2003 Red Hat
Bartlomiej Zolnierkiewicz59bca8c2008-02-01 23:09:33 +01006 * Copyright (C) 2003-2005, 2007 Bartlomiej Zolnierkiewicz
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 */
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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 */
16
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#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>
Arjan van de Vencf8b8972006-03-23 03:00:45 -080028#include <linux/mutex.h>
Richard Purdie2bfb6462006-03-31 02:31:16 -080029#include <linux/leds.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/ide.h>
Bartlomiej Zolnierkiewicz3ceca722008-10-10 22:39:27 +020031#include <linux/hdreg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
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
Bartlomiej Zolnierkiewiczf8790482008-10-13 21:39:45 +020039#include "ide-disk.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +010041static const u8 ide_rw_cmds[] = {
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +020042 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,
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +010054};
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)
Bartlomiej Zolnierkiewiczba4b2e62008-07-23 19:55:55 +020073 index = 8;
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +010074 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070085/*
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 */
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +020089static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
90 sector_t block)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
Bartlomiej Zolnierkiewicz898ec222009-01-06 17:20:52 +010092 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewicz790d1232008-01-25 22:17:12 +010093 u16 nsectors = (u16)rq->nr_sectors;
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +020094 u8 lba48 = !!(drive->dev_flags & IDE_DFLAG_LBA48);
95 u8 dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
Bartlomiej Zolnierkiewicz9e422372008-01-25 22:17:07 +010096 ide_task_t task;
97 struct ide_taskfile *tf = &task.tf;
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +010098 ide_startstop_t rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
Bartlomiej Zolnierkiewicz238e4f12007-10-19 00:30:07 +0200100 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 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
Bartlomiej Zolnierkiewicz9e422372008-01-25 22:17:07 +0100112 memset(&task, 0, sizeof(task));
Bartlomiej Zolnierkiewicz9a410e72008-07-15 21:21:48 +0200113 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100114
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200115 if (drive->dev_flags & IDE_DFLAG_LBA) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 if (lba48) {
Michael Richardsonc2f83112006-02-07 12:58:33 -0800117 pr_debug("%s: LBA=0x%012llx\n", drive->name,
118 (unsigned long long)block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Bartlomiej Zolnierkiewicz790d1232008-01-25 22:17:12 +0100120 tf->hob_nsect = (nsectors >> 8) & 0xff;
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100121 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 }
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100126
Bartlomiej Zolnierkiewicz790d1232008-01-25 22:17:12 +0100127 tf->nsect = nsectors & 0xff;
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100128 tf->lbal = (u8) block;
129 tf->lbam = (u8)(block >> 8);
130 tf->lbah = (u8)(block >> 16);
Bartlomiej Zolnierkiewicz6dd9b832008-01-26 20:13:03 +0100131
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100132 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 } else {
Bartlomiej Zolnierkiewicz790d1232008-01-25 22:17:12 +0100134 tf->nsect = nsectors & 0xff;
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100135 tf->lbal = block;
136 tf->lbam = block >>= 8;
137 tf->lbah = block >>= 8;
138 tf->device = (block >> 8) & 0xf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 }
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200140
141 tf->device |= ATA_LBA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 } else {
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200143 unsigned int sect, head, cyl, track;
144
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 track = (int)block / drive->sect;
146 sect = (int)block % drive->sect + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 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
Bartlomiej Zolnierkiewicz790d1232008-01-25 22:17:12 +0100152 tf->nsect = nsectors & 0xff;
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100153 tf->lbal = sect;
154 tf->lbam = cyl;
155 tf->lbah = cyl >> 8;
156 tf->device = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 }
158
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +0100159 if (rq_data_dir(rq))
160 task.tf_flags |= IDE_TFLAG_WRITE;
161
162 ide_tf_set_cmd(drive, &task, dma);
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100163 if (!dma)
164 hwif->data_phase = task.data_phase;
165 task.rq = rq;
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +0100166
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100167 rc = do_rw_taskfile(drive, &task);
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100168
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100169 if (rc == ide_stopped && dma) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 /* fallback to PIO */
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100171 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +0100172 ide_tf_set_cmd(drive, &task, 0);
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100173 hwif->data_phase = task.data_phase;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 ide_init_sg_cmd(drive, rq);
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100175 rc = do_rw_taskfile(drive, &task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 }
177
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100178 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179}
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
Bartlomiej Zolnierkiewicz806f80a2008-10-17 18:09:14 +0200187static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
188 sector_t block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189{
Bartlomiej Zolnierkiewicz898ec222009-01-06 17:20:52 +0100190 ide_hwif_t *hwif = drive->hwif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200192 BUG_ON(drive->dev_flags & IDE_DFLAG_BLOCKED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193
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
Richard Purdie2bfb6462006-03-31 02:31:16 -0800200 ledtrig_ide_activity();
201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
203 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
Michael Richardsonc2f83112006-02-07 12:58:33 -0800204 (unsigned long long)block, rq->nr_sectors,
205 (unsigned long)rq->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
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 */
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100217static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
219 ide_task_t args;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100220 struct ide_taskfile *tf = &args.tf;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100221 u64 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
223 /* Create IDE/ATA command request structure */
224 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100225 if (lba48)
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200226 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100227 else
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200228 tf->command = ATA_CMD_READ_NATIVE_MAX;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100229 tf->device = ATA_LBA;
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100230 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
Bartlomiej Zolnierkiewicza3bbb9d2008-01-25 22:17:10 +0100231 if (lba48)
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100232 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 /* submit command request */
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100234 ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
236 /* if OK, compute maximum address value */
Bartlomiej Zolnierkiewicza5016332008-01-25 22:17:17 +0100237 if ((tf->status & 0x01) == 0)
238 addr = ide_get_lba_addr(tf, lba48) + 1;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100239
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 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 */
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100247static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248{
249 ide_task_t args;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100250 struct ide_taskfile *tf = &args.tf;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100251 u64 addr_set = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 addr_req--;
254 /* Create IDE/ATA command request structure */
255 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100256 tf->lbal = (addr_req >> 0) & 0xff;
257 tf->lbam = (addr_req >>= 8) & 0xff;
258 tf->lbah = (addr_req >>= 8) & 0xff;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100259 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;
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200263 tf->command = ATA_CMD_SET_MAX_EXT;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100264 } else {
265 tf->device = (addr_req >>= 8) & 0x0f;
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200266 tf->command = ATA_CMD_SET_MAX;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100267 }
268 tf->device |= ATA_LBA;
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100269 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
Bartlomiej Zolnierkiewicza3bbb9d2008-01-25 22:17:10 +0100270 if (lba48)
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100271 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 /* submit command request */
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100273 ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 /* if OK, compute maximum address value */
Bartlomiej Zolnierkiewicza5016332008-01-25 22:17:17 +0100275 if ((tf->status & 0x01) == 0)
276 addr_set = ide_get_lba_addr(tf, lba48) + 1;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 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
288/*
Bartlomiej Zolnierkiewiczb0244a02007-08-20 22:42:57 +0200289 * 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 },
Jorge Juan Chico7062cdc2007-09-17 12:35:30 +0200294 { "ST320413A", NULL },
Mikko Rapelib152fcd2008-02-19 01:41:25 +0100295 { "ST310211A", NULL },
Bartlomiej Zolnierkiewiczb0244a02007-08-20 22:42:57 +0200296 { NULL, NULL }
297};
298
Arjan van de Ven858119e2006-01-14 13:20:43 -0800299static void idedisk_check_hpa(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300{
301 unsigned long long capacity, set_max;
Bartlomiej Zolnierkiewicz942dcd82008-10-10 22:39:30 +0200302 int lba48 = ata_id_lba48_enabled(drive->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303
304 capacity = drive->capacity64;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100305
306 set_max = idedisk_read_native_max_address(drive, lba48);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Bartlomiej Zolnierkiewiczb0244a02007-08-20 22:42:57 +0200308 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 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
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100327 set_max = idedisk_set_max_address(drive, set_max, lba48);
328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 if (set_max) {
330 drive->capacity64 = set_max;
331 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
332 drive->name);
333 }
334}
335
Bartlomiej Zolnierkiewicz806f80a2008-10-17 18:09:14 +0200336static int ide_disk_get_capacity(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337{
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200338 u16 *id = drive->id;
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200339 int lba;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
Bartlomiej Zolnierkiewicz942dcd82008-10-10 22:39:30 +0200341 if (ata_id_lba48_enabled(id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 /* drive speaks 48-bit LBA */
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200343 lba = 1;
Bartlomiej Zolnierkiewicz48fb2682008-10-10 22:39:19 +0200344 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
Bartlomiej Zolnierkiewicza02227c2008-10-10 22:39:31 +0200345 } else if (ata_id_has_lba(id) && ata_id_is_lba_capacity_ok(id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 /* drive speaks 28-bit LBA */
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200347 lba = 1;
Bartlomiej Zolnierkiewicz48fb2682008-10-10 22:39:19 +0200348 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 } else {
350 /* drive speaks boring old 28-bit CHS */
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200351 lba = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 drive->capacity64 = drive->cyl * drive->head * drive->sect;
353 }
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200354
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 }
Bartlomiej Zolnierkiewicz0a70c7f2008-10-17 18:09:09 +0200365
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 }
Bartlomiej Zolnierkiewicz806f80a2008-10-17 18:09:14 +0200385
386 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387}
388
Jens Axboe165125e2007-07-24 09:28:11 +0200389static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390{
391 ide_drive_t *drive = q->queuedata;
Bartlomiej Zolnierkiewicz395d8ef2008-02-11 00:32:14 +0100392 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Bartlomiej Zolnierkiewicz395d8ef2008-02-11 00:32:14 +0100394 /* FIXME: map struct ide_taskfile on rq->cmd[] */
395 BUG_ON(task == NULL);
396
397 memset(task, 0, sizeof(*task));
Bartlomiej Zolnierkiewiczff2779b2008-10-10 22:39:31 +0200398 if (ata_id_flush_ext_enabled(drive->id) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 (drive->capacity64 >= (1UL << 28)))
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200400 task->tf.command = ATA_CMD_FLUSH_EXT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 else
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200402 task->tf.command = ATA_CMD_FLUSH;
Bartlomiej Zolnierkiewicz395d8ef2008-02-11 00:32:14 +0100403 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
404 IDE_TFLAG_DYN;
405 task->data_phase = TASKFILE_NO_DATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
Bartlomiej Zolnierkiewicz813a0eb2008-01-25 22:17:10 +0100407 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
Jens Axboe4aff5e22006-08-10 08:44:47 +0200408 rq->cmd_flags |= REQ_SOFTBARRIER;
Bartlomiej Zolnierkiewicz395d8ef2008-02-11 00:32:14 +0100409 rq->special = task;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410}
411
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200412ide_devset_get(multcount, mult_count);
413
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414/*
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{
FUJITA Tomonoridd470872008-07-15 21:21:43 +0200420 struct request *rq;
421 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
Bartlomiej Zolnierkiewicz48fb2682008-10-10 22:39:19 +0200423 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200424 return -EINVAL;
425
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 if (drive->special.b.set_multmode)
427 return -EBUSY;
Bartlomiej Zolnierkiewicz852738f2008-01-26 20:13:12 +0100428
FUJITA Tomonoridd470872008-07-15 21:21:43 +0200429 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
430 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
Bartlomiej Zolnierkiewicz852738f2008-01-26 20:13:12 +0100431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 drive->mult_req = arg;
433 drive->special.b.set_multmode = 1;
FUJITA Tomonoridd470872008-07-15 21:21:43 +0200434 error = blk_execute_rq(drive->queue, NULL, rq, 0);
435 blk_put_request(rq);
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200436
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 return (drive->mult_count == arg) ? 0 : -EIO;
438}
439
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200440ide_devset_get_flag(nowerr, IDE_DFLAG_NOWERR);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200441
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442static int set_nowerr(ide_drive_t *drive, int arg)
443{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200444 if (arg < 0 || arg > 1)
445 return -EINVAL;
446
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200447 if (arg)
448 drive->dev_flags |= IDE_DFLAG_NOWERR;
449 else
450 drive->dev_flags &= ~IDE_DFLAG_NOWERR;
451
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200453
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 return 0;
455}
456
Bartlomiej Zolnierkiewiczbe3c0962008-10-13 21:39:36 +0200457static 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
Tejun Heo3e087b52006-01-06 09:57:31 +0100470static void update_ordered(ide_drive_t *drive)
471{
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200472 u16 *id = drive->id;
Tejun Heo3e087b52006-01-06 09:57:31 +0100473 unsigned ordered = QUEUE_ORDERED_NONE;
474 prepare_flush_fn *prep_fn = NULL;
Tejun Heo3e087b52006-01-06 09:57:31 +0100475
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200476 if (drive->dev_flags & IDE_DFLAG_WCACHE) {
Tejun Heo3e087b52006-01-06 09:57:31 +0100477 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 */
Bartlomiej Zolnierkiewicz5fef0e52008-10-17 18:09:12 +0200487 capacity = ide_gd_capacity(drive);
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200488 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) ||
Bartlomiej Zolnierkiewiczff2779b2008-10-10 22:39:31 +0200492 ata_id_flush_ext_enabled(id));
Tejun Heo3e087b52006-01-06 09:57:31 +0100493
494 printk(KERN_INFO "%s: cache flushes %ssupported\n",
Jean Delvaref7ad8362006-02-03 03:04:57 -0800495 drive->name, barrier ? "" : "not ");
Tejun Heo3e087b52006-01-06 09:57:31 +0100496
497 if (barrier) {
498 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
499 prep_fn = idedisk_prepare_flush;
Tejun Heo3e087b52006-01-06 09:57:31 +0100500 }
501 } else
502 ordered = QUEUE_ORDERED_DRAIN;
503
504 blk_queue_ordered(drive->queue, ordered, prep_fn);
Tejun Heo3e087b52006-01-06 09:57:31 +0100505}
506
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200507ide_devset_get_flag(wcache, IDE_DFLAG_WCACHE);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200508
509static int set_wcache(ide_drive_t *drive, int arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510{
Tejun Heo3e087b52006-01-06 09:57:31 +0100511 int err = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200513 if (arg < 0 || arg > 1)
514 return -EINVAL;
515
Bartlomiej Zolnierkiewicz4b58f172008-10-10 22:39:30 +0200516 if (ata_id_flush_enabled(drive->id)) {
Bartlomiej Zolnierkiewiczbe3c0962008-10-13 21:39:36 +0200517 err = ide_do_setfeature(drive,
518 arg ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF, 0);
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200519 if (err == 0) {
520 if (arg)
521 drive->dev_flags |= IDE_DFLAG_WCACHE;
522 else
523 drive->dev_flags &= ~IDE_DFLAG_WCACHE;
524 }
Tejun Heo3e087b52006-01-06 09:57:31 +0100525 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
Tejun Heo3e087b52006-01-06 09:57:31 +0100527 update_ordered(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Tejun Heo3e087b52006-01-06 09:57:31 +0100529 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530}
531
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200532static int do_idedisk_flushcache(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533{
534 ide_task_t args;
535
536 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewiczff2779b2008-10-10 22:39:31 +0200537 if (ata_id_flush_ext_enabled(drive->id))
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200538 args.tf.command = ATA_CMD_FLUSH_EXT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 else
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200540 args.tf.command = ATA_CMD_FLUSH;
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100541 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100542 return ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543}
544
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200545ide_devset_get(acoustic, acoustic);
546
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200547static int set_acoustic(ide_drive_t *drive, int arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200549 if (arg < 0 || arg > 254)
550 return -EINVAL;
551
Bartlomiej Zolnierkiewiczbe3c0962008-10-13 21:39:36 +0200552 ide_do_setfeature(drive,
553 arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF, arg);
554
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 drive->acoustic = arg;
Bartlomiej Zolnierkiewiczbe3c0962008-10-13 21:39:36 +0200556
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 return 0;
558}
559
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200560ide_devset_get_flag(addressing, IDE_DFLAG_LBA48);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200561
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562/*
563 * drive->addressing:
564 * 0: 28-bit
565 * 1: 48-bit
566 * 2: 48-bit capable doing 28-bit
567 */
Bartlomiej Zolnierkiewiczaa7687732008-10-10 22:39:33 +0200568static int set_addressing(ide_drive_t *drive, int arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200570 if (arg < 0 || arg > 2)
571 return -EINVAL;
572
Bartlomiej Zolnierkiewicz35c13752008-10-13 21:39:36 +0200573 if (arg && ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
574 ata_id_lba48_enabled(drive->id) == 0))
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200575 return -EIO;
Bartlomiej Zolnierkiewicz942dcd82008-10-10 22:39:30 +0200576
Bartlomiej Zolnierkiewicz35c13752008-10-13 21:39:36 +0200577 if (arg == 2)
578 arg = 0;
579
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200580 if (arg)
581 drive->dev_flags |= IDE_DFLAG_LBA48;
582 else
583 drive->dev_flags &= ~IDE_DFLAG_LBA48;
Bartlomiej Zolnierkiewicz942dcd82008-10-10 22:39:30 +0200584
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 return 0;
586}
587
Bartlomiej Zolnierkiewiczf8790482008-10-13 21:39:45 +0200588ide_ext_devset_rw(acoustic, acoustic);
589ide_ext_devset_rw(address, addressing);
590ide_ext_devset_rw(multcount, multcount);
591ide_ext_devset_rw(wcache, wcache);
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200592
Bartlomiej Zolnierkiewiczf8790482008-10-13 21:39:45 +0200593ide_ext_devset_rw_sync(nowerr, nowerr);
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200594
Bartlomiej Zolnierkiewicz806f80a2008-10-17 18:09:14 +0200595static 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)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
Bartlomiej Zolnierkiewicz1e874f42008-10-10 22:39:27 +0200602 struct ide_disk_obj *idkp = drive->driver_data;
Bartlomiej Zolnierkiewiczc77380d2008-10-23 23:22:09 +0200603 struct request_queue *q = drive->queue;
Bartlomiej Zolnierkiewicz238e4f12007-10-19 00:30:07 +0200604 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200605 u16 *id = drive->id;
606 char *m = (char *)&id[ATA_ID_PROD];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 unsigned long long capacity;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
Bartlomiej Zolnierkiewicz1e874f42008-10-10 22:39:27 +0200609 ide_proc_register_driver(drive, idkp->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200611 if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 return;
613
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200614 if (drive->dev_flags & IDE_DFLAG_REMOVABLE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 /*
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200616 * Removable disks (eg. SYQUEST); ignore 'WD' drives
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 */
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200618 if (m[0] != 'W' || m[1] != 'D')
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200619 drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 }
621
Bartlomiej Zolnierkiewiczaa7687732008-10-10 22:39:33 +0200622 (void)set_addressing(drive, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200624 if (drive->dev_flags & IDE_DFLAG_LBA48) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 int max_s = 2048;
626
627 if (max_s > hwif->rqsize)
628 max_s = hwif->rqsize;
629
Bartlomiej Zolnierkiewiczc77380d2008-10-23 23:22:09 +0200630 blk_queue_max_sectors(q, max_s);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 }
632
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200633 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
Bartlomiej Zolnierkiewiczc77380d2008-10-23 23:22:09 +0200634 q->max_sectors / 2);
635
Bartlomiej Zolnierkiewicz655772c2009-01-14 19:19:03 +0100636 if (ata_id_is_ssd(id))
Bartlomiej Zolnierkiewiczc77380d2008-10-23 23:22:09 +0200637 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638
639 /* calculate drive capacity, and select LBA if possible */
Bartlomiej Zolnierkiewicz806f80a2008-10-17 18:09:14 +0200640 ide_disk_get_capacity(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 /*
643 * if possible, give fdisk access to more of the drive,
644 * by correcting bios_cyls:
645 */
Bartlomiej Zolnierkiewicz5fef0e52008-10-17 18:09:12 +0200646 capacity = ide_gd_capacity(drive);
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200647
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200648 if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) {
Bartlomiej Zolnierkiewicz942dcd82008-10-10 22:39:30 +0200649 if (ata_id_lba48_enabled(drive->id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 /* 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 */
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200675 if (id[ATA_ID_BUF_SIZE])
676 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100678 printk(KERN_CONT ", CHS=%d/%d/%d\n",
679 drive->bios_cyl, drive->bios_head, drive->bios_sect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 /* write cache enabled? */
Bartlomiej Zolnierkiewicz8a089c62008-10-10 22:39:20 +0200682 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200683 drive->dev_flags |= IDE_DFLAG_WCACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200685 set_wcache(drive, 1);
Bartlomiej Zolnierkiewiczae9f9f02008-10-17 18:09:10 +0200686
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694}
695
Bartlomiej Zolnierkiewicz806f80a2008-10-17 18:09:14 +0200696static void ide_disk_flush(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697{
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200698 if (ata_id_flush_enabled(drive->id) == 0 ||
699 (drive->dev_flags & IDE_DFLAG_WCACHE) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 return;
701
702 if (do_idedisk_flushcache(drive))
703 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
704}
705
Bartlomiej Zolnierkiewicz806f80a2008-10-17 18:09:14 +0200706static 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)
Bartlomiej Zolnierkiewicz29ec6832008-01-26 20:12:59 +0100713{
714 ide_task_t task;
Bartlomiej Zolnierkiewicz81ee1bb2008-10-17 18:09:10 +0200715 int ret;
716
717 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) == 0)
718 return 0;
Bartlomiej Zolnierkiewicz29ec6832008-01-26 20:12:59 +0100719
720 memset(&task, 0, sizeof(task));
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200721 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100722 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
Bartlomiej Zolnierkiewicz29ec6832008-01-26 20:12:59 +0100723
Bartlomiej Zolnierkiewicz81ee1bb2008-10-17 18:09:10 +0200724 ret = ide_no_data_taskfile(drive, &task);
725
726 if (ret)
727 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
728
729 return ret;
Bartlomiej Zolnierkiewicz29ec6832008-01-26 20:12:59 +0100730}
Bartlomiej Zolnierkiewicz806f80a2008-10-17 18:09:14 +0200731
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};