blob: 3853bde8eedc3c291b8b676529563afccdcc2f0d [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>
5 * Copyright (C) 2003 Red Hat <alan@redhat.com>
6 * 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
17#define IDEDISK_VERSION "1.18"
18
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/module.h>
20#include <linux/types.h>
21#include <linux/string.h>
22#include <linux/kernel.h>
23#include <linux/timer.h>
24#include <linux/mm.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>
Arjan van de Vencf8b8972006-03-23 03:00:45 -080031#include <linux/mutex.h>
Richard Purdie2bfb6462006-03-31 02:31:16 -080032#include <linux/leds.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/ide.h>
Bartlomiej Zolnierkiewicz3ceca722008-10-10 22:39:27 +020034#include <linux/hdreg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035
36#include <asm/byteorder.h>
37#include <asm/irq.h>
38#include <asm/uaccess.h>
39#include <asm/io.h>
40#include <asm/div64.h>
41
Tejun Heo870d6652008-08-25 19:47:25 +090042#if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
Tejun Heo689d6fa2008-08-25 19:56:16 +090043#define IDE_DISK_MINORS (1 << PARTN_BITS)
Tejun Heo870d6652008-08-25 19:47:25 +090044#else
Tejun Heo3e1a7ff2008-08-25 19:56:17 +090045#define IDE_DISK_MINORS 0
Tejun Heo870d6652008-08-25 19:47:25 +090046#endif
47
Bartlomiej Zolnierkiewiczf8790482008-10-13 21:39:45 +020048#include "ide-disk.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
Arjan van de Vencf8b8972006-03-23 03:00:45 -080050static DEFINE_MUTEX(idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52#define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
53
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +020054static void ide_disk_release(struct kref *);
55
Linus Torvalds1da177e2005-04-16 15:20:36 -070056static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
57{
58 struct ide_disk_obj *idkp = NULL;
59
Arjan van de Vencf8b8972006-03-23 03:00:45 -080060 mutex_lock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 idkp = ide_disk_g(disk);
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +020062 if (idkp) {
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +020063 if (ide_device_get(idkp->drive))
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +020064 idkp = NULL;
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +020065 else
66 kref_get(&idkp->kref);
Bartlomiej Zolnierkiewicz08da5912008-07-24 22:53:15 +020067 }
Arjan van de Vencf8b8972006-03-23 03:00:45 -080068 mutex_unlock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 return idkp;
70}
71
Linus Torvalds1da177e2005-04-16 15:20:36 -070072static void ide_disk_put(struct ide_disk_obj *idkp)
73{
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +020074 ide_drive_t *drive = idkp->drive;
75
Arjan van de Vencf8b8972006-03-23 03:00:45 -080076 mutex_lock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077 kref_put(&idkp->kref, ide_disk_release);
Bartlomiej Zolnierkiewiczd3e33ff2008-08-05 18:16:59 +020078 ide_device_put(drive);
Arjan van de Vencf8b8972006-03-23 03:00:45 -080079 mutex_unlock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070080}
81
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +010082static const u8 ide_rw_cmds[] = {
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +020083 ATA_CMD_READ_MULTI,
84 ATA_CMD_WRITE_MULTI,
85 ATA_CMD_READ_MULTI_EXT,
86 ATA_CMD_WRITE_MULTI_EXT,
87 ATA_CMD_PIO_READ,
88 ATA_CMD_PIO_WRITE,
89 ATA_CMD_PIO_READ_EXT,
90 ATA_CMD_PIO_WRITE_EXT,
91 ATA_CMD_READ,
92 ATA_CMD_WRITE,
93 ATA_CMD_READ_EXT,
94 ATA_CMD_WRITE_EXT,
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +010095};
96
97static const u8 ide_data_phases[] = {
98 TASKFILE_MULTI_IN,
99 TASKFILE_MULTI_OUT,
100 TASKFILE_IN,
101 TASKFILE_OUT,
102 TASKFILE_IN_DMA,
103 TASKFILE_OUT_DMA,
104};
105
106static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
107{
108 u8 index, lba48, write;
109
110 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
111 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
112
113 if (dma)
Bartlomiej Zolnierkiewiczba4b2e62008-07-23 19:55:55 +0200114 index = 8;
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +0100115 else
116 index = drive->mult_count ? 0 : 4;
117
118 task->tf.command = ide_rw_cmds[index + lba48 + write];
119
120 if (dma)
121 index = 8; /* fixup index */
122
123 task->data_phase = ide_data_phases[index / 2 + write];
124}
125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126/*
127 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
128 * using LBA if supported, or CHS otherwise, to address sectors.
129 */
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200130static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
131 sector_t block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{
133 ide_hwif_t *hwif = HWIF(drive);
Bartlomiej Zolnierkiewicz790d1232008-01-25 22:17:12 +0100134 u16 nsectors = (u16)rq->nr_sectors;
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200135 u8 lba48 = !!(drive->dev_flags & IDE_DFLAG_LBA48);
136 u8 dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
Bartlomiej Zolnierkiewicz9e422372008-01-25 22:17:07 +0100137 ide_task_t task;
138 struct ide_taskfile *tf = &task.tf;
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100139 ide_startstop_t rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140
Bartlomiej Zolnierkiewicz238e4f12007-10-19 00:30:07 +0200141 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 if (block + rq->nr_sectors > 1ULL << 28)
143 dma = 0;
144 else
145 lba48 = 0;
146 }
147
148 if (!dma) {
149 ide_init_sg_cmd(drive, rq);
150 ide_map_sg(drive, rq);
151 }
152
Bartlomiej Zolnierkiewicz9e422372008-01-25 22:17:07 +0100153 memset(&task, 0, sizeof(task));
Bartlomiej Zolnierkiewicz9a410e72008-07-15 21:21:48 +0200154 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100155
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200156 if (drive->dev_flags & IDE_DFLAG_LBA) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 if (lba48) {
Michael Richardsonc2f83112006-02-07 12:58:33 -0800158 pr_debug("%s: LBA=0x%012llx\n", drive->name,
159 (unsigned long long)block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Bartlomiej Zolnierkiewicz790d1232008-01-25 22:17:12 +0100161 tf->hob_nsect = (nsectors >> 8) & 0xff;
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100162 tf->hob_lbal = (u8)(block >> 24);
163 if (sizeof(block) != 4) {
164 tf->hob_lbam = (u8)((u64)block >> 32);
165 tf->hob_lbah = (u8)((u64)block >> 40);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 }
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100167
Bartlomiej Zolnierkiewicz790d1232008-01-25 22:17:12 +0100168 tf->nsect = nsectors & 0xff;
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100169 tf->lbal = (u8) block;
170 tf->lbam = (u8)(block >> 8);
171 tf->lbah = (u8)(block >> 16);
Bartlomiej Zolnierkiewicz6dd9b832008-01-26 20:13:03 +0100172
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100173 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 } else {
Bartlomiej Zolnierkiewicz790d1232008-01-25 22:17:12 +0100175 tf->nsect = nsectors & 0xff;
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100176 tf->lbal = block;
177 tf->lbam = block >>= 8;
178 tf->lbah = block >>= 8;
179 tf->device = (block >> 8) & 0xf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 }
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200181
182 tf->device |= ATA_LBA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 } else {
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200184 unsigned int sect, head, cyl, track;
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 track = (int)block / drive->sect;
187 sect = (int)block % drive->sect + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 head = track % drive->head;
189 cyl = track / drive->head;
190
191 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
192
Bartlomiej Zolnierkiewicz790d1232008-01-25 22:17:12 +0100193 tf->nsect = nsectors & 0xff;
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100194 tf->lbal = sect;
195 tf->lbam = cyl;
196 tf->lbah = cyl >> 8;
197 tf->device = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 }
199
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +0100200 if (rq_data_dir(rq))
201 task.tf_flags |= IDE_TFLAG_WRITE;
202
203 ide_tf_set_cmd(drive, &task, dma);
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100204 if (!dma)
205 hwif->data_phase = task.data_phase;
206 task.rq = rq;
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +0100207
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100208 rc = do_rw_taskfile(drive, &task);
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100209
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100210 if (rc == ide_stopped && dma) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 /* fallback to PIO */
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100212 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
Bartlomiej Zolnierkiewiczba76ae32008-01-25 22:17:16 +0100213 ide_tf_set_cmd(drive, &task, 0);
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100214 hwif->data_phase = task.data_phase;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 ide_init_sg_cmd(drive, rq);
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100216 rc = do_rw_taskfile(drive, &task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 }
218
Bartlomiej Zolnierkiewiczf6e29e32008-01-25 22:17:16 +0100219 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220}
221
222/*
223 * 268435455 == 137439 MB or 28bit limit
224 * 320173056 == 163929 MB or 48bit addressing
225 * 1073741822 == 549756 MB or 48bit addressing fake drive
226 */
227
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200228static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
229 sector_t block)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230{
231 ide_hwif_t *hwif = HWIF(drive);
232
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200233 BUG_ON(drive->dev_flags & IDE_DFLAG_BLOCKED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
235 if (!blk_fs_request(rq)) {
236 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
237 ide_end_request(drive, 0, 0);
238 return ide_stopped;
239 }
240
Richard Purdie2bfb6462006-03-31 02:31:16 -0800241 ledtrig_ide_activity();
242
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
244 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
Michael Richardsonc2f83112006-02-07 12:58:33 -0800245 (unsigned long long)block, rq->nr_sectors,
246 (unsigned long)rq->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
248 if (hwif->rw_disk)
249 hwif->rw_disk(drive, rq);
250
251 return __ide_do_rw_disk(drive, rq, block);
252}
253
254/*
255 * Queries for true maximum capacity of the drive.
256 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
257 */
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100258static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259{
260 ide_task_t args;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100261 struct ide_taskfile *tf = &args.tf;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100262 u64 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 /* Create IDE/ATA command request structure */
265 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100266 if (lba48)
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200267 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100268 else
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200269 tf->command = ATA_CMD_READ_NATIVE_MAX;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100270 tf->device = ATA_LBA;
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100271 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
Bartlomiej Zolnierkiewicza3bbb9d2008-01-25 22:17:10 +0100272 if (lba48)
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100273 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 /* submit command request */
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100275 ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276
277 /* if OK, compute maximum address value */
Bartlomiej Zolnierkiewicza5016332008-01-25 22:17:17 +0100278 if ((tf->status & 0x01) == 0)
279 addr = ide_get_lba_addr(tf, lba48) + 1;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 return addr;
282}
283
284/*
285 * Sets maximum virtual LBA address of the drive.
286 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
287 */
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100288static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
290 ide_task_t args;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100291 struct ide_taskfile *tf = &args.tf;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100292 u64 addr_set = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
294 addr_req--;
295 /* Create IDE/ATA command request structure */
296 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100297 tf->lbal = (addr_req >> 0) & 0xff;
298 tf->lbam = (addr_req >>= 8) & 0xff;
299 tf->lbah = (addr_req >>= 8) & 0xff;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100300 if (lba48) {
301 tf->hob_lbal = (addr_req >>= 8) & 0xff;
302 tf->hob_lbam = (addr_req >>= 8) & 0xff;
303 tf->hob_lbah = (addr_req >>= 8) & 0xff;
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200304 tf->command = ATA_CMD_SET_MAX_EXT;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100305 } else {
306 tf->device = (addr_req >>= 8) & 0x0f;
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200307 tf->command = ATA_CMD_SET_MAX;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100308 }
309 tf->device |= ATA_LBA;
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100310 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
Bartlomiej Zolnierkiewicza3bbb9d2008-01-25 22:17:10 +0100311 if (lba48)
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100312 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 /* submit command request */
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100314 ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 /* if OK, compute maximum address value */
Bartlomiej Zolnierkiewicza5016332008-01-25 22:17:17 +0100316 if ((tf->status & 0x01) == 0)
317 addr_set = ide_get_lba_addr(tf, lba48) + 1;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 return addr_set;
320}
321
322static unsigned long long sectors_to_MB(unsigned long long n)
323{
324 n <<= 9; /* make it bytes */
325 do_div(n, 1000000); /* make it MB */
326 return n;
327}
328
329/*
Bartlomiej Zolnierkiewiczb0244a02007-08-20 22:42:57 +0200330 * Some disks report total number of sectors instead of
331 * maximum sector address. We list them here.
332 */
333static const struct drive_list_entry hpa_list[] = {
334 { "ST340823A", NULL },
Jorge Juan Chico7062cdc2007-09-17 12:35:30 +0200335 { "ST320413A", NULL },
Mikko Rapelib152fcd2008-02-19 01:41:25 +0100336 { "ST310211A", NULL },
Bartlomiej Zolnierkiewiczb0244a02007-08-20 22:42:57 +0200337 { NULL, NULL }
338};
339
Arjan van de Ven858119e2006-01-14 13:20:43 -0800340static void idedisk_check_hpa(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341{
342 unsigned long long capacity, set_max;
Bartlomiej Zolnierkiewicz942dcd82008-10-10 22:39:30 +0200343 int lba48 = ata_id_lba48_enabled(drive->id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345 capacity = drive->capacity64;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100346
347 set_max = idedisk_read_native_max_address(drive, lba48);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Bartlomiej Zolnierkiewiczb0244a02007-08-20 22:42:57 +0200349 if (ide_in_drive_list(drive->id, hpa_list)) {
350 /*
351 * Since we are inclusive wrt to firmware revisions do this
352 * extra check and apply the workaround only when needed.
353 */
354 if (set_max == capacity + 1)
355 set_max--;
356 }
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 if (set_max <= capacity)
359 return;
360
361 printk(KERN_INFO "%s: Host Protected Area detected.\n"
362 "\tcurrent capacity is %llu sectors (%llu MB)\n"
363 "\tnative capacity is %llu sectors (%llu MB)\n",
364 drive->name,
365 capacity, sectors_to_MB(capacity),
366 set_max, sectors_to_MB(set_max));
367
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100368 set_max = idedisk_set_max_address(drive, set_max, lba48);
369
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 if (set_max) {
371 drive->capacity64 = set_max;
372 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
373 drive->name);
374 }
375}
376
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200377static void init_idedisk_capacity(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378{
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200379 u16 *id = drive->id;
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200380 int lba;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Bartlomiej Zolnierkiewicz942dcd82008-10-10 22:39:30 +0200382 if (ata_id_lba48_enabled(id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 /* drive speaks 48-bit LBA */
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200384 lba = 1;
Bartlomiej Zolnierkiewicz48fb2682008-10-10 22:39:19 +0200385 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
Bartlomiej Zolnierkiewicza02227c2008-10-10 22:39:31 +0200386 } else if (ata_id_has_lba(id) && ata_id_is_lba_capacity_ok(id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 /* drive speaks 28-bit LBA */
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200388 lba = 1;
Bartlomiej Zolnierkiewicz48fb2682008-10-10 22:39:19 +0200389 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 } else {
391 /* drive speaks boring old 28-bit CHS */
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200392 lba = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 drive->capacity64 = drive->cyl * drive->head * drive->sect;
394 }
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200395
396 if (lba) {
397 drive->dev_flags |= IDE_DFLAG_LBA;
398
399 /*
400 * If this device supports the Host Protected Area feature set,
401 * then we may need to change our opinion about its capacity.
402 */
403 if (ata_id_hpa_enabled(id))
404 idedisk_check_hpa(drive);
405 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406}
407
Bartlomiej Zolnierkiewicz06b89512008-10-13 21:39:45 +0200408sector_t ide_disk_capacity(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409{
Bartlomiej Zolnierkiewicz3c619ff2008-10-10 22:39:22 +0200410 return drive->capacity64;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411}
412
Jens Axboe165125e2007-07-24 09:28:11 +0200413static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414{
415 ide_drive_t *drive = q->queuedata;
Bartlomiej Zolnierkiewicz395d8ef2008-02-11 00:32:14 +0100416 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Bartlomiej Zolnierkiewicz395d8ef2008-02-11 00:32:14 +0100418 /* FIXME: map struct ide_taskfile on rq->cmd[] */
419 BUG_ON(task == NULL);
420
421 memset(task, 0, sizeof(*task));
Bartlomiej Zolnierkiewiczff2779b2008-10-10 22:39:31 +0200422 if (ata_id_flush_ext_enabled(drive->id) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 (drive->capacity64 >= (1UL << 28)))
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200424 task->tf.command = ATA_CMD_FLUSH_EXT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 else
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200426 task->tf.command = ATA_CMD_FLUSH;
Bartlomiej Zolnierkiewicz395d8ef2008-02-11 00:32:14 +0100427 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
428 IDE_TFLAG_DYN;
429 task->data_phase = TASKFILE_NO_DATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
Bartlomiej Zolnierkiewicz813a0eb2008-01-25 22:17:10 +0100431 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
Jens Axboe4aff5e22006-08-10 08:44:47 +0200432 rq->cmd_flags |= REQ_SOFTBARRIER;
Bartlomiej Zolnierkiewicz395d8ef2008-02-11 00:32:14 +0100433 rq->special = task;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434}
435
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200436ide_devset_get(multcount, mult_count);
437
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438/*
439 * This is tightly woven into the driver->do_special can not touch.
440 * DON'T do it again until a total personality rewrite is committed.
441 */
442static int set_multcount(ide_drive_t *drive, int arg)
443{
FUJITA Tomonoridd470872008-07-15 21:21:43 +0200444 struct request *rq;
445 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
Bartlomiej Zolnierkiewicz48fb2682008-10-10 22:39:19 +0200447 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200448 return -EINVAL;
449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 if (drive->special.b.set_multmode)
451 return -EBUSY;
Bartlomiej Zolnierkiewicz852738f2008-01-26 20:13:12 +0100452
FUJITA Tomonoridd470872008-07-15 21:21:43 +0200453 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
454 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
Bartlomiej Zolnierkiewicz852738f2008-01-26 20:13:12 +0100455
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 drive->mult_req = arg;
457 drive->special.b.set_multmode = 1;
FUJITA Tomonoridd470872008-07-15 21:21:43 +0200458 error = blk_execute_rq(drive->queue, NULL, rq, 0);
459 blk_put_request(rq);
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 return (drive->mult_count == arg) ? 0 : -EIO;
462}
463
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200464ide_devset_get_flag(nowerr, IDE_DFLAG_NOWERR);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200465
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466static int set_nowerr(ide_drive_t *drive, int arg)
467{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200468 if (arg < 0 || arg > 1)
469 return -EINVAL;
470
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200471 if (arg)
472 drive->dev_flags |= IDE_DFLAG_NOWERR;
473 else
474 drive->dev_flags &= ~IDE_DFLAG_NOWERR;
475
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 return 0;
479}
480
Bartlomiej Zolnierkiewiczbe3c0962008-10-13 21:39:36 +0200481static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)
482{
483 ide_task_t task;
484
485 memset(&task, 0, sizeof(task));
486 task.tf.feature = feature;
487 task.tf.nsect = nsect;
488 task.tf.command = ATA_CMD_SET_FEATURES;
489 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
490
491 return ide_no_data_taskfile(drive, &task);
492}
493
Tejun Heo3e087b52006-01-06 09:57:31 +0100494static void update_ordered(ide_drive_t *drive)
495{
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200496 u16 *id = drive->id;
Tejun Heo3e087b52006-01-06 09:57:31 +0100497 unsigned ordered = QUEUE_ORDERED_NONE;
498 prepare_flush_fn *prep_fn = NULL;
Tejun Heo3e087b52006-01-06 09:57:31 +0100499
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200500 if (drive->dev_flags & IDE_DFLAG_WCACHE) {
Tejun Heo3e087b52006-01-06 09:57:31 +0100501 unsigned long long capacity;
502 int barrier;
503 /*
504 * We must avoid issuing commands a drive does not
505 * understand or we may crash it. We check flush cache
506 * is supported. We also check we have the LBA48 flush
507 * cache if the drive capacity is too large. By this
508 * time we have trimmed the drive capacity if LBA48 is
509 * not available so we don't need to recheck that.
510 */
Bartlomiej Zolnierkiewicz06b89512008-10-13 21:39:45 +0200511 capacity = ide_disk_capacity(drive);
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200512 barrier = ata_id_flush_enabled(id) &&
513 (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 &&
514 ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 ||
515 capacity <= (1ULL << 28) ||
Bartlomiej Zolnierkiewiczff2779b2008-10-10 22:39:31 +0200516 ata_id_flush_ext_enabled(id));
Tejun Heo3e087b52006-01-06 09:57:31 +0100517
518 printk(KERN_INFO "%s: cache flushes %ssupported\n",
Jean Delvaref7ad8362006-02-03 03:04:57 -0800519 drive->name, barrier ? "" : "not ");
Tejun Heo3e087b52006-01-06 09:57:31 +0100520
521 if (barrier) {
522 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
523 prep_fn = idedisk_prepare_flush;
Tejun Heo3e087b52006-01-06 09:57:31 +0100524 }
525 } else
526 ordered = QUEUE_ORDERED_DRAIN;
527
528 blk_queue_ordered(drive->queue, ordered, prep_fn);
Tejun Heo3e087b52006-01-06 09:57:31 +0100529}
530
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200531ide_devset_get_flag(wcache, IDE_DFLAG_WCACHE);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200532
533static int set_wcache(ide_drive_t *drive, int arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534{
Tejun Heo3e087b52006-01-06 09:57:31 +0100535 int err = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200537 if (arg < 0 || arg > 1)
538 return -EINVAL;
539
Bartlomiej Zolnierkiewicz4b58f172008-10-10 22:39:30 +0200540 if (ata_id_flush_enabled(drive->id)) {
Bartlomiej Zolnierkiewiczbe3c0962008-10-13 21:39:36 +0200541 err = ide_do_setfeature(drive,
542 arg ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF, 0);
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200543 if (err == 0) {
544 if (arg)
545 drive->dev_flags |= IDE_DFLAG_WCACHE;
546 else
547 drive->dev_flags &= ~IDE_DFLAG_WCACHE;
548 }
Tejun Heo3e087b52006-01-06 09:57:31 +0100549 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
Tejun Heo3e087b52006-01-06 09:57:31 +0100551 update_ordered(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552
Tejun Heo3e087b52006-01-06 09:57:31 +0100553 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554}
555
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200556static int do_idedisk_flushcache(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
558 ide_task_t args;
559
560 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewiczff2779b2008-10-10 22:39:31 +0200561 if (ata_id_flush_ext_enabled(drive->id))
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200562 args.tf.command = ATA_CMD_FLUSH_EXT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 else
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200564 args.tf.command = ATA_CMD_FLUSH;
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100565 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100566 return ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567}
568
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200569ide_devset_get(acoustic, acoustic);
570
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200571static int set_acoustic(ide_drive_t *drive, int arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200573 if (arg < 0 || arg > 254)
574 return -EINVAL;
575
Bartlomiej Zolnierkiewiczbe3c0962008-10-13 21:39:36 +0200576 ide_do_setfeature(drive,
577 arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF, arg);
578
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 drive->acoustic = arg;
Bartlomiej Zolnierkiewiczbe3c0962008-10-13 21:39:36 +0200580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 return 0;
582}
583
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200584ide_devset_get_flag(addressing, IDE_DFLAG_LBA48);
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200585
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586/*
587 * drive->addressing:
588 * 0: 28-bit
589 * 1: 48-bit
590 * 2: 48-bit capable doing 28-bit
591 */
Bartlomiej Zolnierkiewiczaa7687732008-10-10 22:39:33 +0200592static int set_addressing(ide_drive_t *drive, int arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200594 if (arg < 0 || arg > 2)
595 return -EINVAL;
596
Bartlomiej Zolnierkiewicz35c13752008-10-13 21:39:36 +0200597 if (arg && ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
598 ata_id_lba48_enabled(drive->id) == 0))
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200599 return -EIO;
Bartlomiej Zolnierkiewicz942dcd82008-10-10 22:39:30 +0200600
Bartlomiej Zolnierkiewicz35c13752008-10-13 21:39:36 +0200601 if (arg == 2)
602 arg = 0;
603
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200604 if (arg)
605 drive->dev_flags |= IDE_DFLAG_LBA48;
606 else
607 drive->dev_flags &= ~IDE_DFLAG_LBA48;
Bartlomiej Zolnierkiewicz942dcd82008-10-10 22:39:30 +0200608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 return 0;
610}
611
Bartlomiej Zolnierkiewiczf8790482008-10-13 21:39:45 +0200612ide_ext_devset_rw(acoustic, acoustic);
613ide_ext_devset_rw(address, addressing);
614ide_ext_devset_rw(multcount, multcount);
615ide_ext_devset_rw(wcache, wcache);
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200616
Bartlomiej Zolnierkiewiczf8790482008-10-13 21:39:45 +0200617ide_ext_devset_rw_sync(nowerr, nowerr);
Elias Oltmanns92f1f8f2008-10-10 22:39:40 +0200618
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200619static void idedisk_setup(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620{
Bartlomiej Zolnierkiewicz1e874f42008-10-10 22:39:27 +0200621 struct ide_disk_obj *idkp = drive->driver_data;
Bartlomiej Zolnierkiewicz238e4f12007-10-19 00:30:07 +0200622 ide_hwif_t *hwif = drive->hwif;
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200623 u16 *id = drive->id;
624 char *m = (char *)&id[ATA_ID_PROD];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 unsigned long long capacity;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626
Bartlomiej Zolnierkiewicz1e874f42008-10-10 22:39:27 +0200627 ide_proc_register_driver(drive, idkp->driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200629 if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 return;
631
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200632 if (drive->dev_flags & IDE_DFLAG_REMOVABLE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 /*
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200634 * Removable disks (eg. SYQUEST); ignore 'WD' drives
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 */
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200636 if (m[0] != 'W' || m[1] != 'D')
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200637 drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 }
639
Bartlomiej Zolnierkiewiczaa7687732008-10-10 22:39:33 +0200640 (void)set_addressing(drive, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200642 if (drive->dev_flags & IDE_DFLAG_LBA48) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 int max_s = 2048;
644
645 if (max_s > hwif->rqsize)
646 max_s = hwif->rqsize;
647
648 blk_queue_max_sectors(drive->queue, max_s);
649 }
650
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200651 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
652 drive->queue->max_sectors / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
654 /* calculate drive capacity, and select LBA if possible */
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200655 init_idedisk_capacity(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
657 /* limit drive capacity to 137GB if LBA48 cannot be used */
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200658 if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
659 drive->capacity64 > 1ULL << 28) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
661 "%llu sectors (%llu MB)\n",
662 drive->name, (unsigned long long)drive->capacity64,
663 sectors_to_MB(drive->capacity64));
664 drive->capacity64 = 1ULL << 28;
665 }
666
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200667 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
668 (drive->dev_flags & IDE_DFLAG_LBA48)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 if (drive->capacity64 > 1ULL << 28) {
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200670 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
671 " will be used for accessing sectors "
672 "> %u\n", drive->name, 1 << 28);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 } else
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200674 drive->dev_flags &= ~IDE_DFLAG_LBA48;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
676
677 /*
678 * if possible, give fdisk access to more of the drive,
679 * by correcting bios_cyls:
680 */
Bartlomiej Zolnierkiewicz06b89512008-10-13 21:39:45 +0200681 capacity = ide_disk_capacity(drive);
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200682
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200683 if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) {
Bartlomiej Zolnierkiewicz942dcd82008-10-10 22:39:30 +0200684 if (ata_id_lba48_enabled(drive->id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 /* compatibility */
686 drive->bios_sect = 63;
687 drive->bios_head = 255;
688 }
689
690 if (drive->bios_sect && drive->bios_head) {
691 unsigned int cap0 = capacity; /* truncate to 32 bits */
692 unsigned int cylsz, cyl;
693
694 if (cap0 != capacity)
695 drive->bios_cyl = 65535;
696 else {
697 cylsz = drive->bios_sect * drive->bios_head;
698 cyl = cap0 / cylsz;
699 if (cyl > 65535)
700 cyl = 65535;
701 if (cyl > drive->bios_cyl)
702 drive->bios_cyl = cyl;
703 }
704 }
705 }
706 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
707 drive->name, capacity, sectors_to_MB(capacity));
708
709 /* Only print cache size when it was specified */
Bartlomiej Zolnierkiewicz4dde4492008-10-10 22:39:19 +0200710 if (id[ATA_ID_BUF_SIZE])
711 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100713 printk(KERN_CONT ", CHS=%d/%d/%d\n",
714 drive->bios_cyl, drive->bios_head, drive->bios_sect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 /* write cache enabled? */
Bartlomiej Zolnierkiewicz8a089c62008-10-10 22:39:20 +0200717 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200718 drive->dev_flags |= IDE_DFLAG_WCACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719
Bartlomiej Zolnierkiewicz8185d5a2008-10-10 22:39:28 +0200720 set_wcache(drive, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721}
722
723static void ide_cacheflush_p(ide_drive_t *drive)
724{
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200725 if (ata_id_flush_enabled(drive->id) == 0 ||
726 (drive->dev_flags & IDE_DFLAG_WCACHE) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 return;
728
729 if (do_idedisk_flushcache(drive))
730 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
731}
732
Russell King4031bbe2006-01-06 11:41:00 +0000733static void ide_disk_remove(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734{
735 struct ide_disk_obj *idkp = drive->driver_data;
736 struct gendisk *g = idkp->disk;
737
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200738 ide_proc_unregister_driver(drive, idkp->driver);
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 del_gendisk(g);
741
Bartlomiej Zolnierkiewiczd36fef62005-12-15 02:19:20 +0100742 ide_cacheflush_p(drive);
743
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 ide_disk_put(idkp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745}
746
747static void ide_disk_release(struct kref *kref)
748{
749 struct ide_disk_obj *idkp = to_ide_disk(kref);
750 ide_drive_t *drive = idkp->drive;
751 struct gendisk *g = idkp->disk;
752
753 drive->driver_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 g->private_data = NULL;
755 put_disk(g);
756 kfree(idkp);
757}
758
Russell King4031bbe2006-01-06 11:41:00 +0000759static int ide_disk_probe(ide_drive_t *drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Lee Trager0d2157f2007-06-08 15:14:30 +0200761/*
762 * On HPA drives the capacity needs to be
763 * reinitilized on resume otherwise the disk
764 * can not be used and a hard reset is required
765 */
766static void ide_disk_resume(ide_drive_t *drive)
767{
Bartlomiej Zolnierkiewiczf41891c2008-10-10 22:39:20 +0200768 if (ata_id_hpa_enabled(drive->id))
Lee Trager0d2157f2007-06-08 15:14:30 +0200769 init_idedisk_capacity(drive);
770}
771
Russell King4031bbe2006-01-06 11:41:00 +0000772static void ide_device_shutdown(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774#ifdef CONFIG_ALPHA
775 /* On Alpha, halt(8) doesn't actually turn the machine off,
776 it puts you into the sort of firmware monitor. Typically,
777 it's used to boot another kernel image, so it's not much
778 different from reboot(8). Therefore, we don't need to
779 spin down the disk in this case, especially since Alpha
780 firmware doesn't handle disks in standby mode properly.
781 On the other hand, it's reasonably safe to turn the power
782 off when the shutdown process reaches the firmware prompt,
783 as the firmware initialization takes rather long time -
784 at least 10 seconds, which should be sufficient for
785 the disk to expire its write cache. */
786 if (system_state != SYSTEM_POWER_OFF) {
787#else
788 if (system_state == SYSTEM_RESTART) {
789#endif
790 ide_cacheflush_p(drive);
791 return;
792 }
793
Bartlomiej Zolnierkiewiczd12faa22008-02-26 21:50:36 +0100794 printk(KERN_INFO "Shutdown: %s\n", drive->name);
795
Russell King4031bbe2006-01-06 11:41:00 +0000796 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797}
798
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799static ide_driver_t idedisk_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 .gen_driver = {
Laurent Riffard4ef3b8f2005-11-18 22:15:40 +0100801 .owner = THIS_MODULE,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200802 .name = "ide-disk",
803 .bus = &ide_bus_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 },
Russell King4031bbe2006-01-06 11:41:00 +0000805 .probe = ide_disk_probe,
806 .remove = ide_disk_remove,
Lee Trager0d2157f2007-06-08 15:14:30 +0200807 .resume = ide_disk_resume,
Russell King4031bbe2006-01-06 11:41:00 +0000808 .shutdown = ide_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 .version = IDEDISK_VERSION,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 .do_request = ide_do_rw_disk,
811 .end_request = ide_end_request,
812 .error = __ide_error,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200813#ifdef CONFIG_IDE_PROC_FS
Bartlomiej Zolnierkiewicz06b89512008-10-13 21:39:45 +0200814 .proc = ide_disk_proc,
815 .settings = ide_disk_settings,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200816#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817};
818
Bartlomiej Zolnierkiewicz29ec6832008-01-26 20:12:59 +0100819static int idedisk_set_doorlock(ide_drive_t *drive, int on)
820{
821 ide_task_t task;
822
823 memset(&task, 0, sizeof(task));
Bartlomiej Zolnierkiewiczaaaade32008-10-10 22:39:21 +0200824 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
Bartlomiej Zolnierkiewicz657cc1a2008-01-26 20:13:10 +0100825 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
Bartlomiej Zolnierkiewicz29ec6832008-01-26 20:12:59 +0100826
827 return ide_no_data_taskfile(drive, &task);
828}
829
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830static int idedisk_open(struct inode *inode, struct file *filp)
831{
832 struct gendisk *disk = inode->i_bdev->bd_disk;
833 struct ide_disk_obj *idkp;
834 ide_drive_t *drive;
835
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200836 idkp = ide_disk_get(disk);
837 if (idkp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 return -ENXIO;
839
840 drive = idkp->drive;
841
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100842 idkp->openers++;
843
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200844 if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 check_disk_change(inode->i_bdev);
846 /*
847 * Ignore the return code from door_lock,
848 * since the open() has already succeeded,
849 * and the door_lock is irrelevant at this point.
850 */
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200851 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
852 idedisk_set_doorlock(drive, 1))
853 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 }
855 return 0;
856}
857
858static int idedisk_release(struct inode *inode, struct file *filp)
859{
860 struct gendisk *disk = inode->i_bdev->bd_disk;
861 struct ide_disk_obj *idkp = ide_disk_g(disk);
862 ide_drive_t *drive = idkp->drive;
863
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100864 if (idkp->openers == 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 ide_cacheflush_p(drive);
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100866
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200867 if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
868 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
869 idedisk_set_doorlock(drive, 0))
870 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 }
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100872
873 idkp->openers--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874
875 ide_disk_put(idkp);
876
877 return 0;
878}
879
Christoph Hellwiga885c8c2006-01-08 01:02:50 -0800880static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
881{
882 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
883 ide_drive_t *drive = idkp->drive;
884
885 geo->heads = drive->bios_head;
886 geo->sectors = drive->bios_sect;
887 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
888 return 0;
889}
890
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891static int idedisk_media_changed(struct gendisk *disk)
892{
893 struct ide_disk_obj *idkp = ide_disk_g(disk);
894 ide_drive_t *drive = idkp->drive;
895
896 /* do not scan partitions twice if this is a removable device */
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200897 if (drive->dev_flags & IDE_DFLAG_ATTACH) {
898 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 return 0;
900 }
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200901
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 /* if removable, always assume it was changed */
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200903 return !!(drive->dev_flags & IDE_DFLAG_REMOVABLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904}
905
906static int idedisk_revalidate_disk(struct gendisk *disk)
907{
908 struct ide_disk_obj *idkp = ide_disk_g(disk);
Bartlomiej Zolnierkiewicz06b89512008-10-13 21:39:45 +0200909 set_capacity(disk, ide_disk_capacity(idkp->drive));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 return 0;
911}
912
913static struct block_device_operations idedisk_ops = {
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200914 .owner = THIS_MODULE,
915 .open = idedisk_open,
916 .release = idedisk_release,
Bartlomiej Zolnierkiewiczf8790482008-10-13 21:39:45 +0200917 .ioctl = ide_disk_ioctl,
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200918 .getgeo = idedisk_getgeo,
919 .media_changed = idedisk_media_changed,
920 .revalidate_disk = idedisk_revalidate_disk
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921};
922
923MODULE_DESCRIPTION("ATA DISK Driver");
924
Russell King4031bbe2006-01-06 11:41:00 +0000925static int ide_disk_probe(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926{
927 struct ide_disk_obj *idkp;
928 struct gendisk *g;
929
930 /* strstr("foo", "") is non-NULL */
931 if (!strstr("ide-disk", drive->driver_req))
932 goto failed;
Bartlomiej Zolnierkiewicz2a924662008-10-10 22:39:24 +0200933
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 if (drive->media != ide_disk)
935 goto failed;
936
Deepak Saxenaf5e3c2f2005-11-07 01:01:25 -0800937 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 if (!idkp)
939 goto failed;
940
Tejun Heo689d6fa2008-08-25 19:56:16 +0900941 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 if (!g)
943 goto out_free_idkp;
944
945 ide_init_disk(g, drive);
946
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 kref_init(&idkp->kref);
948
949 idkp->drive = drive;
950 idkp->driver = &idedisk_driver;
951 idkp->disk = g;
952
953 g->private_data = &idkp->driver;
954
955 drive->driver_data = idkp;
956
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 idedisk_setup(drive);
Bartlomiej Zolnierkiewiczd1d76712008-10-13 21:39:38 +0200958 if ((drive->dev_flags & IDE_DFLAG_LBA) == 0 &&
959 (drive->head == 0 || drive->head > 16)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
961 drive->name, drive->head);
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200962 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 } else
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200964 drive->dev_flags |= IDE_DFLAG_ATTACH;
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200965
Tejun Heof615b482008-08-25 19:47:24 +0900966 g->minors = IDE_DISK_MINORS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 g->driverfs_dev = &drive->gendev;
Tejun Heo689d6fa2008-08-25 19:56:16 +0900968 g->flags |= GENHD_FL_EXT_DEVT;
Bartlomiej Zolnierkiewicz97100fc2008-10-13 21:39:36 +0200969 if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
970 g->flags = GENHD_FL_REMOVABLE;
Bartlomiej Zolnierkiewicz06b89512008-10-13 21:39:45 +0200971 set_capacity(g, ide_disk_capacity(drive));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 g->fops = &idedisk_ops;
973 add_disk(g);
974 return 0;
975
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976out_free_idkp:
977 kfree(idkp);
978failed:
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200979 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980}
981
Bartlomiej Zolnierkiewicz98416542008-04-26 17:36:37 +0200982static void __exit idedisk_exit(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200984 driver_unregister(&idedisk_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985}
986
Bartlomiej Zolnierkiewicz17514e82005-11-19 22:24:35 +0100987static int __init idedisk_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200989 return driver_register(&idedisk_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990}
991
Kay Sievers263756e2005-12-12 18:03:44 +0100992MODULE_ALIAS("ide:*m-disk*");
Bartlomiej Zolnierkiewiczf8790482008-10-13 21:39:45 +0200993MODULE_ALIAS("ide-disk");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994module_init(idedisk_init);
995module_exit(idedisk_exit);
996MODULE_LICENSE("GPL");