blob: b534fe97d47658649c34f49795dcd3f6973c6327 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/drivers/ide/ide-disk.c Version 1.18 Mar 05, 2003
3 *
4 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below)
5 * Copyright (C) 1998-2002 Linux ATA Development
6 * Andre Hedrick <andre@linux-ide.org>
7 * Copyright (C) 2003 Red Hat <alan@redhat.com>
8 */
9
10/*
11 * Mostly written by Mark Lord <mlord@pobox.com>
12 * and Gadi Oxman <gadio@netvision.net.il>
13 * and Andre Hedrick <andre@linux-ide.org>
14 *
15 * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 */
17
18#define IDEDISK_VERSION "1.18"
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020//#define DEBUG
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/module.h>
23#include <linux/types.h>
24#include <linux/string.h>
25#include <linux/kernel.h>
26#include <linux/timer.h>
27#include <linux/mm.h>
28#include <linux/interrupt.h>
29#include <linux/major.h>
30#include <linux/errno.h>
31#include <linux/genhd.h>
32#include <linux/slab.h>
33#include <linux/delay.h>
Arjan van de Vencf8b8972006-03-23 03:00:45 -080034#include <linux/mutex.h>
Richard Purdie2bfb6462006-03-31 02:31:16 -080035#include <linux/leds.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37#define _IDE_DISK
38
39#include <linux/ide.h>
40
41#include <asm/byteorder.h>
42#include <asm/irq.h>
43#include <asm/uaccess.h>
44#include <asm/io.h>
45#include <asm/div64.h>
46
47struct ide_disk_obj {
48 ide_drive_t *drive;
49 ide_driver_t *driver;
50 struct gendisk *disk;
51 struct kref kref;
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +010052 unsigned int openers; /* protected by BKL for now */
Linus Torvalds1da177e2005-04-16 15:20:36 -070053};
54
Arjan van de Vencf8b8972006-03-23 03:00:45 -080055static DEFINE_MUTEX(idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57#define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
58
59#define ide_disk_g(disk) \
60 container_of((disk)->private_data, struct ide_disk_obj, driver)
61
62static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
63{
64 struct ide_disk_obj *idkp = NULL;
65
Arjan van de Vencf8b8972006-03-23 03:00:45 -080066 mutex_lock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 idkp = ide_disk_g(disk);
68 if (idkp)
69 kref_get(&idkp->kref);
Arjan van de Vencf8b8972006-03-23 03:00:45 -080070 mutex_unlock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 return idkp;
72}
73
74static void ide_disk_release(struct kref *);
75
76static void ide_disk_put(struct ide_disk_obj *idkp)
77{
Arjan van de Vencf8b8972006-03-23 03:00:45 -080078 mutex_lock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 kref_put(&idkp->kref, ide_disk_release);
Arjan van de Vencf8b8972006-03-23 03:00:45 -080080 mutex_unlock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081}
82
83/*
84 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
85 * value for this drive (from its reported identification information).
86 *
87 * Returns: 1 if lba_capacity looks sensible
88 * 0 otherwise
89 *
90 * It is called only once for each drive.
91 */
92static int lba_capacity_is_ok (struct hd_driveid *id)
93{
94 unsigned long lba_sects, chs_sects, head, tail;
95
Alan Cox6efd9362005-06-27 15:24:22 -070096 /* No non-LBA info .. so valid! */
97 if (id->cyls == 0)
98 return 1;
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 /*
101 * The ATA spec tells large drives to return
102 * C/H/S = 16383/16/63 independent of their size.
103 * Some drives can be jumpered to use 15 heads instead of 16.
104 * Some drives can be jumpered to use 4092 cyls instead of 16383.
105 */
106 if ((id->cyls == 16383
107 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
108 id->sectors == 63 &&
109 (id->heads == 15 || id->heads == 16) &&
110 (id->lba_capacity >= 16383*63*id->heads))
111 return 1;
112
113 lba_sects = id->lba_capacity;
114 chs_sects = id->cyls * id->heads * id->sectors;
115
116 /* perform a rough sanity check on lba_sects: within 10% is OK */
117 if ((lba_sects - chs_sects) < chs_sects/10)
118 return 1;
119
120 /* some drives have the word order reversed */
121 head = ((lba_sects >> 16) & 0xffff);
122 tail = (lba_sects & 0xffff);
123 lba_sects = (head | (tail << 16));
124 if ((lba_sects - chs_sects) < chs_sects/10) {
125 id->lba_capacity = lba_sects;
126 return 1; /* lba_capacity is (now) good */
127 }
128
129 return 0; /* lba_capacity value may be bad */
130}
131
132/*
133 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
134 * using LBA if supported, or CHS otherwise, to address sectors.
135 */
136static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
137{
138 ide_hwif_t *hwif = HWIF(drive);
139 unsigned int dma = drive->using_dma;
140 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
Bartlomiej Zolnierkiewiczcd2a2d92008-01-25 22:17:06 +0100141 u8 command = WIN_NOP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 ata_nsector_t nsectors;
Bartlomiej Zolnierkiewicz9e422372008-01-25 22:17:07 +0100143 ide_task_t task;
144 struct ide_taskfile *tf = &task.tf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145
146 nsectors.all = (u16) rq->nr_sectors;
147
Bartlomiej Zolnierkiewicz238e4f12007-10-19 00:30:07 +0200148 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 if (block + rq->nr_sectors > 1ULL << 28)
150 dma = 0;
151 else
152 lba48 = 0;
153 }
154
155 if (!dma) {
156 ide_init_sg_cmd(drive, rq);
157 ide_map_sg(drive, rq);
158 }
159
Bartlomiej Zolnierkiewicz9e422372008-01-25 22:17:07 +0100160 memset(&task, 0, sizeof(task));
161 task.tf_flags = IDE_TFLAG_NO_SELECT_MASK; /* FIXME? */
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 if (drive->select.b.lba) {
164 if (lba48) {
Michael Richardsonc2f83112006-02-07 12:58:33 -0800165 pr_debug("%s: LBA=0x%012llx\n", drive->name,
166 (unsigned long long)block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100168 tf->hob_nsect = nsectors.b.high;
169 tf->hob_lbal = (u8)(block >> 24);
170 if (sizeof(block) != 4) {
171 tf->hob_lbam = (u8)((u64)block >> 32);
172 tf->hob_lbah = (u8)((u64)block >> 40);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 }
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100174
175 tf->nsect = nsectors.b.low;
176 tf->lbal = (u8) block;
177 tf->lbam = (u8)(block >> 8);
178 tf->lbah = (u8)(block >> 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179#ifdef DEBUG
180 printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100181 drive->name, tf->hob_nsect, tf->nsect,
182 tf->hob_lbah, tf->hob_lbam, tf->hob_lbal,
183 tf->lbah, tf->lbam, tf->lbal);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184#endif
Bartlomiej Zolnierkiewicz9e422372008-01-25 22:17:07 +0100185 task.tf_flags |= IDE_TFLAG_LBA48;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 } else {
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100187 tf->nsect = nsectors.b.low;
188 tf->lbal = block;
189 tf->lbam = block >>= 8;
190 tf->lbah = block >>= 8;
191 tf->device = (block >> 8) & 0xf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 }
193 } else {
194 unsigned int sect,head,cyl,track;
195 track = (int)block / drive->sect;
196 sect = (int)block % drive->sect + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 head = track % drive->head;
198 cyl = track / drive->head;
199
200 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
201
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100202 tf->nsect = nsectors.b.low;
203 tf->lbal = sect;
204 tf->lbam = cyl;
205 tf->lbah = cyl >> 8;
206 tf->device = head;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 }
208
Bartlomiej Zolnierkiewicz9e422372008-01-25 22:17:07 +0100209 ide_tf_load(drive, &task);
Bartlomiej Zolnierkiewicz2bd06b22008-01-25 22:17:06 +0100210
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 if (dma) {
212 if (!hwif->dma_setup(drive)) {
213 if (rq_data_dir(rq)) {
214 command = lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
215 if (drive->vdma)
216 command = lba48 ? WIN_WRITE_EXT: WIN_WRITE;
217 } else {
218 command = lba48 ? WIN_READDMA_EXT : WIN_READDMA;
219 if (drive->vdma)
220 command = lba48 ? WIN_READ_EXT: WIN_READ;
221 }
222 hwif->dma_exec_cmd(drive, command);
223 hwif->dma_start(drive);
224 return ide_started;
225 }
226 /* fallback to PIO */
227 ide_init_sg_cmd(drive, rq);
228 }
229
230 if (rq_data_dir(rq) == READ) {
231
232 if (drive->mult_count) {
233 hwif->data_phase = TASKFILE_MULTI_IN;
234 command = lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
235 } else {
236 hwif->data_phase = TASKFILE_IN;
237 command = lba48 ? WIN_READ_EXT : WIN_READ;
238 }
239
240 ide_execute_command(drive, command, &task_in_intr, WAIT_CMD, NULL);
241 return ide_started;
242 } else {
243 if (drive->mult_count) {
244 hwif->data_phase = TASKFILE_MULTI_OUT;
245 command = lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
246 } else {
247 hwif->data_phase = TASKFILE_OUT;
248 command = lba48 ? WIN_WRITE_EXT : WIN_WRITE;
249 }
250
251 /* FIXME: ->OUTBSYNC ? */
252 hwif->OUTB(command, IDE_COMMAND_REG);
253
254 return pre_task_out_intr(drive, rq);
255 }
256}
257
258/*
259 * 268435455 == 137439 MB or 28bit limit
260 * 320173056 == 163929 MB or 48bit addressing
261 * 1073741822 == 549756 MB or 48bit addressing fake drive
262 */
263
264static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
265{
266 ide_hwif_t *hwif = HWIF(drive);
267
268 BUG_ON(drive->blocked);
269
270 if (!blk_fs_request(rq)) {
271 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
272 ide_end_request(drive, 0, 0);
273 return ide_stopped;
274 }
275
Richard Purdie2bfb6462006-03-31 02:31:16 -0800276 ledtrig_ide_activity();
277
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
279 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
Michael Richardsonc2f83112006-02-07 12:58:33 -0800280 (unsigned long long)block, rq->nr_sectors,
281 (unsigned long)rq->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
283 if (hwif->rw_disk)
284 hwif->rw_disk(drive, rq);
285
286 return __ide_do_rw_disk(drive, rq, block);
287}
288
289/*
290 * Queries for true maximum capacity of the drive.
291 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
292 */
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100293static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294{
295 ide_task_t args;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100296 struct ide_taskfile *tf = &args.tf;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100297 u64 addr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
299 /* Create IDE/ATA command request structure */
300 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100301 if (lba48)
302 tf->command = WIN_READ_NATIVE_MAX_EXT;
303 else
304 tf->command = WIN_READ_NATIVE_MAX;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100305 tf->device = ATA_LBA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 /* submit command request */
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100307 ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308
309 /* if OK, compute maximum address value */
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100310 if ((tf->status & 0x01) == 0) {
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100311 u32 high, low;
312
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100313 if (lba48)
314 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
315 tf->hob_lbal;
316 else
317 high = tf->device & 0xf;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100318 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 addr = ((__u64)high << 24) | low;
320 addr++; /* since the return value is (maxlba - 1), we add 1 */
321 }
322 return addr;
323}
324
325/*
326 * Sets maximum virtual LBA address of the drive.
327 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
328 */
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100329static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
331 ide_task_t args;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100332 struct ide_taskfile *tf = &args.tf;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100333 u64 addr_set = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334
335 addr_req--;
336 /* Create IDE/ATA command request structure */
337 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100338 tf->lbal = (addr_req >> 0) & 0xff;
339 tf->lbam = (addr_req >>= 8) & 0xff;
340 tf->lbah = (addr_req >>= 8) & 0xff;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100341 if (lba48) {
342 tf->hob_lbal = (addr_req >>= 8) & 0xff;
343 tf->hob_lbam = (addr_req >>= 8) & 0xff;
344 tf->hob_lbah = (addr_req >>= 8) & 0xff;
345 tf->command = WIN_SET_MAX_EXT;
346 } else {
347 tf->device = (addr_req >>= 8) & 0x0f;
348 tf->command = WIN_SET_MAX;
349 }
350 tf->device |= ATA_LBA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 /* submit command request */
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100352 ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 /* if OK, compute maximum address value */
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100354 if ((tf->status & 0x01) == 0) {
355 u32 high, low;
356
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100357 if (lba48)
358 high = (tf->hob_lbah << 16) | (tf->hob_lbam << 8) |
359 tf->hob_lbal;
360 else
361 high = tf->device & 0xf;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100362 low = (tf->lbah << 16) | (tf->lbam << 8) | tf->lbal;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 addr_set = ((__u64)high << 24) | low;
364 addr_set++;
365 }
366 return addr_set;
367}
368
369static unsigned long long sectors_to_MB(unsigned long long n)
370{
371 n <<= 9; /* make it bytes */
372 do_div(n, 1000000); /* make it MB */
373 return n;
374}
375
376/*
377 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
378 * so on non-buggy drives we need test only one.
379 * However, we should also check whether these fields are valid.
380 */
381static inline int idedisk_supports_hpa(const struct hd_driveid *id)
382{
383 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
384}
385
386/*
387 * The same here.
388 */
389static inline int idedisk_supports_lba48(const struct hd_driveid *id)
390{
391 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
392 && id->lba_capacity_2;
393}
394
Bartlomiej Zolnierkiewiczb0244a00452007-08-20 22:42:57 +0200395/*
396 * Some disks report total number of sectors instead of
397 * maximum sector address. We list them here.
398 */
399static const struct drive_list_entry hpa_list[] = {
400 { "ST340823A", NULL },
Jorge Juan Chico7062cdc2007-09-17 12:35:30 +0200401 { "ST320413A", NULL },
Bartlomiej Zolnierkiewiczb0244a00452007-08-20 22:42:57 +0200402 { NULL, NULL }
403};
404
Arjan van de Ven858119e2006-01-14 13:20:43 -0800405static void idedisk_check_hpa(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406{
407 unsigned long long capacity, set_max;
408 int lba48 = idedisk_supports_lba48(drive->id);
409
410 capacity = drive->capacity64;
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100411
412 set_max = idedisk_read_native_max_address(drive, lba48);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
Bartlomiej Zolnierkiewiczb0244a00452007-08-20 22:42:57 +0200414 if (ide_in_drive_list(drive->id, hpa_list)) {
415 /*
416 * Since we are inclusive wrt to firmware revisions do this
417 * extra check and apply the workaround only when needed.
418 */
419 if (set_max == capacity + 1)
420 set_max--;
421 }
422
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 if (set_max <= capacity)
424 return;
425
426 printk(KERN_INFO "%s: Host Protected Area detected.\n"
427 "\tcurrent capacity is %llu sectors (%llu MB)\n"
428 "\tnative capacity is %llu sectors (%llu MB)\n",
429 drive->name,
430 capacity, sectors_to_MB(capacity),
431 set_max, sectors_to_MB(set_max));
432
Bartlomiej Zolnierkiewicz7a3b7512008-01-25 22:17:06 +0100433 set_max = idedisk_set_max_address(drive, set_max, lba48);
434
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 if (set_max) {
436 drive->capacity64 = set_max;
437 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
438 drive->name);
439 }
440}
441
442/*
443 * Compute drive->capacity, the full capacity of the drive
444 * Called with drive->id != NULL.
445 *
446 * To compute capacity, this uses either of
447 *
448 * 1. CHS value set by user (whatever user sets will be trusted)
449 * 2. LBA value from target drive (require new ATA feature)
450 * 3. LBA value from system BIOS (new one is OK, old one may break)
451 * 4. CHS value from system BIOS (traditional style)
452 *
453 * in above order (i.e., if value of higher priority is available,
454 * reset will be ignored).
455 */
456static void init_idedisk_capacity (ide_drive_t *drive)
457{
458 struct hd_driveid *id = drive->id;
459 /*
460 * If this drive supports the Host Protected Area feature set,
461 * then we may need to change our opinion about the drive's capacity.
462 */
463 int hpa = idedisk_supports_hpa(id);
464
465 if (idedisk_supports_lba48(id)) {
466 /* drive speaks 48-bit LBA */
467 drive->select.b.lba = 1;
468 drive->capacity64 = id->lba_capacity_2;
469 if (hpa)
470 idedisk_check_hpa(drive);
471 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
472 /* drive speaks 28-bit LBA */
473 drive->select.b.lba = 1;
474 drive->capacity64 = id->lba_capacity;
475 if (hpa)
476 idedisk_check_hpa(drive);
477 } else {
478 /* drive speaks boring old 28-bit CHS */
479 drive->capacity64 = drive->cyl * drive->head * drive->sect;
480 }
481}
482
483static sector_t idedisk_capacity (ide_drive_t *drive)
484{
485 return drive->capacity64 - drive->sect0;
486}
487
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +0200488#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489static int smart_enable(ide_drive_t *drive)
490{
491 ide_task_t args;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100492 struct ide_taskfile *tf = &args.tf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
494 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100495 tf->feature = SMART_ENABLE;
496 tf->lbam = SMART_LCYL_PASS;
497 tf->lbah = SMART_HCYL_PASS;
498 tf->command = WIN_SMART;
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100499 return ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500}
501
Bartlomiej Zolnierkiewicz43e7c0c2007-10-20 00:32:37 +0200502static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503{
504 ide_task_t args;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100505 struct ide_taskfile *tf = &args.tf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100508 tf->feature = sub_cmd;
509 tf->nsect = 0x01;
510 tf->lbam = SMART_LCYL_PASS;
511 tf->lbah = SMART_HCYL_PASS;
512 tf->command = WIN_SMART;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 args.command_type = IDE_DRIVE_TASK_IN;
514 args.data_phase = TASKFILE_IN;
515 args.handler = &task_in_intr;
516 (void) smart_enable(drive);
517 return ide_raw_taskfile(drive, &args, buf);
518}
519
520static int proc_idedisk_read_cache
521 (char *page, char **start, off_t off, int count, int *eof, void *data)
522{
523 ide_drive_t *drive = (ide_drive_t *) data;
524 char *out = page;
525 int len;
526
527 if (drive->id_read)
528 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
529 else
530 len = sprintf(out,"(none)\n");
531 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
532}
533
534static int proc_idedisk_read_capacity
535 (char *page, char **start, off_t off, int count, int *eof, void *data)
536{
537 ide_drive_t*drive = (ide_drive_t *)data;
538 int len;
539
540 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
541 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
542}
543
544static int proc_idedisk_read_smart_thresholds
545 (char *page, char **start, off_t off, int count, int *eof, void *data)
546{
547 ide_drive_t *drive = (ide_drive_t *)data;
548 int len = 0, i = 0;
549
Bartlomiej Zolnierkiewicz43e7c0c2007-10-20 00:32:37 +0200550 if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 unsigned short *val = (unsigned short *) page;
552 char *out = ((char *)val) + (SECTOR_WORDS * 4);
553 page = out;
554 do {
555 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
556 val += 1;
557 } while (i < (SECTOR_WORDS * 2));
558 len = out - page;
559 }
560 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
561}
562
563static int proc_idedisk_read_smart_values
564 (char *page, char **start, off_t off, int count, int *eof, void *data)
565{
566 ide_drive_t *drive = (ide_drive_t *)data;
567 int len = 0, i = 0;
568
Bartlomiej Zolnierkiewicz43e7c0c2007-10-20 00:32:37 +0200569 if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 unsigned short *val = (unsigned short *) page;
571 char *out = ((char *)val) + (SECTOR_WORDS * 4);
572 page = out;
573 do {
574 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
575 val += 1;
576 } while (i < (SECTOR_WORDS * 2));
577 len = out - page;
578 }
579 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
580}
581
582static ide_proc_entry_t idedisk_proc[] = {
583 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
584 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
585 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
586 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
587 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
588 { NULL, 0, NULL, NULL }
589};
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +0200590#endif /* CONFIG_IDE_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591
Jens Axboe165125e2007-07-24 09:28:11 +0200592static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593{
594 ide_drive_t *drive = q->queuedata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
596 memset(rq->cmd, 0, sizeof(rq->cmd));
597
598 if (ide_id_has_flush_cache_ext(drive->id) &&
599 (drive->capacity64 >= (1UL << 28)))
600 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
601 else
602 rq->cmd[0] = WIN_FLUSH_CACHE;
603
604
Jens Axboe4aff5e22006-08-10 08:44:47 +0200605 rq->cmd_type = REQ_TYPE_ATA_TASK;
606 rq->cmd_flags |= REQ_SOFTBARRIER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 rq->buffer = rq->cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608}
609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610/*
611 * This is tightly woven into the driver->do_special can not touch.
612 * DON'T do it again until a total personality rewrite is committed.
613 */
614static int set_multcount(ide_drive_t *drive, int arg)
615{
616 struct request rq;
617
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200618 if (arg < 0 || arg > drive->id->max_multsect)
619 return -EINVAL;
620
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 if (drive->special.b.set_multmode)
622 return -EBUSY;
623 ide_init_drive_cmd (&rq);
Jens Axboe4aff5e22006-08-10 08:44:47 +0200624 rq.cmd_type = REQ_TYPE_ATA_CMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 drive->mult_req = arg;
626 drive->special.b.set_multmode = 1;
627 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
628 return (drive->mult_count == arg) ? 0 : -EIO;
629}
630
631static int set_nowerr(ide_drive_t *drive, int arg)
632{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200633 if (arg < 0 || arg > 1)
634 return -EINVAL;
635
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 if (ide_spin_wait_hwgroup(drive))
637 return -EBUSY;
638 drive->nowerr = arg;
639 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
640 spin_unlock_irq(&ide_lock);
641 return 0;
642}
643
Tejun Heo3e087b52006-01-06 09:57:31 +0100644static void update_ordered(ide_drive_t *drive)
645{
646 struct hd_driveid *id = drive->id;
647 unsigned ordered = QUEUE_ORDERED_NONE;
648 prepare_flush_fn *prep_fn = NULL;
Tejun Heo3e087b52006-01-06 09:57:31 +0100649
650 if (drive->wcache) {
651 unsigned long long capacity;
652 int barrier;
653 /*
654 * We must avoid issuing commands a drive does not
655 * understand or we may crash it. We check flush cache
656 * is supported. We also check we have the LBA48 flush
657 * cache if the drive capacity is too large. By this
658 * time we have trimmed the drive capacity if LBA48 is
659 * not available so we don't need to recheck that.
660 */
661 capacity = idedisk_capacity(drive);
Jens Axboe36193482006-07-28 08:54:59 +0200662 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
Tejun Heo3e087b52006-01-06 09:57:31 +0100663 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
664 ide_id_has_flush_cache_ext(id));
665
666 printk(KERN_INFO "%s: cache flushes %ssupported\n",
Jean Delvaref7ad8362006-02-03 03:04:57 -0800667 drive->name, barrier ? "" : "not ");
Tejun Heo3e087b52006-01-06 09:57:31 +0100668
669 if (barrier) {
670 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
671 prep_fn = idedisk_prepare_flush;
Tejun Heo3e087b52006-01-06 09:57:31 +0100672 }
673 } else
674 ordered = QUEUE_ORDERED_DRAIN;
675
676 blk_queue_ordered(drive->queue, ordered, prep_fn);
Tejun Heo3e087b52006-01-06 09:57:31 +0100677}
678
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679static int write_cache(ide_drive_t *drive, int arg)
680{
681 ide_task_t args;
Tejun Heo3e087b52006-01-06 09:57:31 +0100682 int err = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200684 if (arg < 0 || arg > 1)
685 return -EINVAL;
686
Tejun Heo3e087b52006-01-06 09:57:31 +0100687 if (ide_id_has_flush_cache(drive->id)) {
688 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100689 args.tf.feature = arg ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100691 args.tf.command = WIN_SETFEATURES;
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100692 err = ide_no_data_taskfile(drive, &args);
Tejun Heo3e087b52006-01-06 09:57:31 +0100693 if (err == 0)
694 drive->wcache = arg;
695 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
Tejun Heo3e087b52006-01-06 09:57:31 +0100697 update_ordered(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698
Tejun Heo3e087b52006-01-06 09:57:31 +0100699 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700}
701
702static int do_idedisk_flushcache (ide_drive_t *drive)
703{
704 ide_task_t args;
705
706 memset(&args, 0, sizeof(ide_task_t));
707 if (ide_id_has_flush_cache_ext(drive->id))
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100708 args.tf.command = WIN_FLUSH_CACHE_EXT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 else
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100710 args.tf.command = WIN_FLUSH_CACHE;
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100711 return ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712}
713
714static int set_acoustic (ide_drive_t *drive, int arg)
715{
716 ide_task_t args;
717
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200718 if (arg < 0 || arg > 254)
719 return -EINVAL;
720
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100722 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
723 args.tf.nsect = arg;
724 args.tf.command = WIN_SETFEATURES;
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100725 ide_no_data_taskfile(drive, &args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 drive->acoustic = arg;
727 return 0;
728}
729
730/*
731 * drive->addressing:
732 * 0: 28-bit
733 * 1: 48-bit
734 * 2: 48-bit capable doing 28-bit
735 */
736static int set_lba_addressing(ide_drive_t *drive, int arg)
737{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200738 if (arg < 0 || arg > 2)
739 return -EINVAL;
740
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 drive->addressing = 0;
742
Bartlomiej Zolnierkiewicz238e4f12007-10-19 00:30:07 +0200743 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 return 0;
745
746 if (!idedisk_supports_lba48(drive->id))
747 return -EIO;
748 drive->addressing = arg;
749 return 0;
750}
751
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200752#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753static void idedisk_add_settings(ide_drive_t *drive)
754{
755 struct hd_driveid *id = drive->id;
756
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200757 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
758 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
759 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
760 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
761 ide_add_setting(drive, "bswap", SETTING_READ, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
762 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount);
763 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
764 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
765 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
766 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
767 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
768 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769}
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200770#else
771static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
772#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
774static void idedisk_setup (ide_drive_t *drive)
775{
Bartlomiej Zolnierkiewicz238e4f12007-10-19 00:30:07 +0200776 ide_hwif_t *hwif = drive->hwif;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 struct hd_driveid *id = drive->id;
778 unsigned long long capacity;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
780 idedisk_add_settings(drive);
781
782 if (drive->id_read == 0)
783 return;
784
Richard Purdie98109332006-02-03 03:04:55 -0800785 if (drive->removable) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 /*
787 * Removable disks (eg. SYQUEST); ignore 'WD' drives
788 */
789 if (id->model[0] != 'W' || id->model[1] != 'D') {
790 drive->doorlocking = 1;
791 }
792 }
793
794 (void)set_lba_addressing(drive, 1);
795
796 if (drive->addressing == 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 int max_s = 2048;
798
799 if (max_s > hwif->rqsize)
800 max_s = hwif->rqsize;
801
802 blk_queue_max_sectors(drive->queue, max_s);
803 }
804
805 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
806
807 /* calculate drive capacity, and select LBA if possible */
808 init_idedisk_capacity (drive);
809
810 /* limit drive capacity to 137GB if LBA48 cannot be used */
811 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
812 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
813 "%llu sectors (%llu MB)\n",
814 drive->name, (unsigned long long)drive->capacity64,
815 sectors_to_MB(drive->capacity64));
816 drive->capacity64 = 1ULL << 28;
817 }
818
Bartlomiej Zolnierkiewicz238e4f12007-10-19 00:30:07 +0200819 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 if (drive->capacity64 > 1ULL << 28) {
821 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
822 " be used for accessing sectors > %u\n",
823 drive->name, 1 << 28);
824 } else
825 drive->addressing = 0;
826 }
827
828 /*
829 * if possible, give fdisk access to more of the drive,
830 * by correcting bios_cyls:
831 */
832 capacity = idedisk_capacity (drive);
833 if (!drive->forced_geom) {
834
835 if (idedisk_supports_lba48(drive->id)) {
836 /* compatibility */
837 drive->bios_sect = 63;
838 drive->bios_head = 255;
839 }
840
841 if (drive->bios_sect && drive->bios_head) {
842 unsigned int cap0 = capacity; /* truncate to 32 bits */
843 unsigned int cylsz, cyl;
844
845 if (cap0 != capacity)
846 drive->bios_cyl = 65535;
847 else {
848 cylsz = drive->bios_sect * drive->bios_head;
849 cyl = cap0 / cylsz;
850 if (cyl > 65535)
851 cyl = 65535;
852 if (cyl > drive->bios_cyl)
853 drive->bios_cyl = cyl;
854 }
855 }
856 }
857 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
858 drive->name, capacity, sectors_to_MB(capacity));
859
860 /* Only print cache size when it was specified */
861 if (id->buf_size)
862 printk (" w/%dKiB Cache", id->buf_size/2);
863
Bartlomiej Zolnierkiewicz3ab7efe2007-12-12 23:31:58 +0100864 printk(KERN_CONT ", CHS=%d/%d/%d\n",
865 drive->bios_cyl, drive->bios_head, drive->bios_sect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 /* write cache enabled? */
868 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
869 drive->wcache = 1;
870
871 write_cache(drive, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872}
873
874static void ide_cacheflush_p(ide_drive_t *drive)
875{
876 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
877 return;
878
879 if (do_idedisk_flushcache(drive))
880 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
881}
882
Russell King4031bbe2006-01-06 11:41:00 +0000883static void ide_disk_remove(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884{
885 struct ide_disk_obj *idkp = drive->driver_data;
886 struct gendisk *g = idkp->disk;
887
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200888 ide_proc_unregister_driver(drive, idkp->driver);
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200889
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 del_gendisk(g);
891
Bartlomiej Zolnierkiewiczd36fef62005-12-15 02:19:20 +0100892 ide_cacheflush_p(drive);
893
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 ide_disk_put(idkp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895}
896
897static void ide_disk_release(struct kref *kref)
898{
899 struct ide_disk_obj *idkp = to_ide_disk(kref);
900 ide_drive_t *drive = idkp->drive;
901 struct gendisk *g = idkp->disk;
902
903 drive->driver_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 g->private_data = NULL;
905 put_disk(g);
906 kfree(idkp);
907}
908
Russell King4031bbe2006-01-06 11:41:00 +0000909static int ide_disk_probe(ide_drive_t *drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
Lee Trager0d2157f2007-06-08 15:14:30 +0200911/*
912 * On HPA drives the capacity needs to be
913 * reinitilized on resume otherwise the disk
914 * can not be used and a hard reset is required
915 */
916static void ide_disk_resume(ide_drive_t *drive)
917{
918 if (idedisk_supports_hpa(drive->id))
919 init_idedisk_capacity(drive);
920}
921
Russell King4031bbe2006-01-06 11:41:00 +0000922static void ide_device_shutdown(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924#ifdef CONFIG_ALPHA
925 /* On Alpha, halt(8) doesn't actually turn the machine off,
926 it puts you into the sort of firmware monitor. Typically,
927 it's used to boot another kernel image, so it's not much
928 different from reboot(8). Therefore, we don't need to
929 spin down the disk in this case, especially since Alpha
930 firmware doesn't handle disks in standby mode properly.
931 On the other hand, it's reasonably safe to turn the power
932 off when the shutdown process reaches the firmware prompt,
933 as the firmware initialization takes rather long time -
934 at least 10 seconds, which should be sufficient for
935 the disk to expire its write cache. */
936 if (system_state != SYSTEM_POWER_OFF) {
937#else
938 if (system_state == SYSTEM_RESTART) {
939#endif
940 ide_cacheflush_p(drive);
941 return;
942 }
943
944 printk("Shutdown: %s\n", drive->name);
Russell King4031bbe2006-01-06 11:41:00 +0000945 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946}
947
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948static ide_driver_t idedisk_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 .gen_driver = {
Laurent Riffard4ef3b8f2005-11-18 22:15:40 +0100950 .owner = THIS_MODULE,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +0200951 .name = "ide-disk",
952 .bus = &ide_bus_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 },
Russell King4031bbe2006-01-06 11:41:00 +0000954 .probe = ide_disk_probe,
955 .remove = ide_disk_remove,
Lee Trager0d2157f2007-06-08 15:14:30 +0200956 .resume = ide_disk_resume,
Russell King4031bbe2006-01-06 11:41:00 +0000957 .shutdown = ide_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 .version = IDEDISK_VERSION,
959 .media = ide_disk,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 .supports_dsc_overlap = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 .do_request = ide_do_rw_disk,
962 .end_request = ide_end_request,
963 .error = __ide_error,
964 .abort = __ide_abort,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200965#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 .proc = idedisk_proc,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200967#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968};
969
970static int idedisk_open(struct inode *inode, struct file *filp)
971{
972 struct gendisk *disk = inode->i_bdev->bd_disk;
973 struct ide_disk_obj *idkp;
974 ide_drive_t *drive;
975
976 if (!(idkp = ide_disk_get(disk)))
977 return -ENXIO;
978
979 drive = idkp->drive;
980
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +0100981 idkp->openers++;
982
983 if (drive->removable && idkp->openers == 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 ide_task_t args;
985 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +0100986 args.tf.command = WIN_DOORLOCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 check_disk_change(inode->i_bdev);
988 /*
989 * Ignore the return code from door_lock,
990 * since the open() has already succeeded,
991 * and the door_lock is irrelevant at this point.
992 */
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +0100993 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 drive->doorlocking = 0;
995 }
996 return 0;
997}
998
999static int idedisk_release(struct inode *inode, struct file *filp)
1000{
1001 struct gendisk *disk = inode->i_bdev->bd_disk;
1002 struct ide_disk_obj *idkp = ide_disk_g(disk);
1003 ide_drive_t *drive = idkp->drive;
1004
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +01001005 if (idkp->openers == 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 ide_cacheflush_p(drive);
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +01001007
1008 if (drive->removable && idkp->openers == 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 ide_task_t args;
1010 memset(&args, 0, sizeof(ide_task_t));
Bartlomiej Zolnierkiewicz650d8412008-01-25 22:17:06 +01001011 args.tf.command = WIN_DOORUNLOCK;
Bartlomiej Zolnierkiewicz9a3c49b2008-01-25 22:17:07 +01001012 if (drive->doorlocking && ide_no_data_taskfile(drive, &args))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 drive->doorlocking = 0;
1014 }
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +01001015
1016 idkp->openers--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017
1018 ide_disk_put(idkp);
1019
1020 return 0;
1021}
1022
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08001023static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1024{
1025 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1026 ide_drive_t *drive = idkp->drive;
1027
1028 geo->heads = drive->bios_head;
1029 geo->sectors = drive->bios_sect;
1030 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1031 return 0;
1032}
1033
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034static int idedisk_ioctl(struct inode *inode, struct file *file,
1035 unsigned int cmd, unsigned long arg)
1036{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001037 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 struct block_device *bdev = inode->i_bdev;
1039 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001040 ide_drive_t *drive = idkp->drive;
1041 int err, (*setfunc)(ide_drive_t *, int);
1042 u8 *val;
1043
1044 switch (cmd) {
1045 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1046 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1047 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1048 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1049 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1050 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1051 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1052 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1053 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1054 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1055 }
1056
1057 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1058
1059read_val:
Matthias Kaehlckef9383c42007-07-09 23:17:56 +02001060 mutex_lock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001061 spin_lock_irqsave(&ide_lock, flags);
1062 err = *val;
1063 spin_unlock_irqrestore(&ide_lock, flags);
Matthias Kaehlckef9383c42007-07-09 23:17:56 +02001064 mutex_unlock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001065 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1066
1067set_val:
1068 if (bdev != bdev->bd_contains)
1069 err = -EINVAL;
1070 else {
1071 if (!capable(CAP_SYS_ADMIN))
1072 err = -EACCES;
1073 else {
Matthias Kaehlckef9383c42007-07-09 23:17:56 +02001074 mutex_lock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001075 err = setfunc(drive, arg);
Matthias Kaehlckef9383c42007-07-09 23:17:56 +02001076 mutex_unlock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001077 }
1078 }
1079 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080}
1081
1082static int idedisk_media_changed(struct gendisk *disk)
1083{
1084 struct ide_disk_obj *idkp = ide_disk_g(disk);
1085 ide_drive_t *drive = idkp->drive;
1086
1087 /* do not scan partitions twice if this is a removable device */
1088 if (drive->attach) {
1089 drive->attach = 0;
1090 return 0;
1091 }
1092 /* if removable, always assume it was changed */
1093 return drive->removable;
1094}
1095
1096static int idedisk_revalidate_disk(struct gendisk *disk)
1097{
1098 struct ide_disk_obj *idkp = ide_disk_g(disk);
1099 set_capacity(disk, idedisk_capacity(idkp->drive));
1100 return 0;
1101}
1102
1103static struct block_device_operations idedisk_ops = {
1104 .owner = THIS_MODULE,
1105 .open = idedisk_open,
1106 .release = idedisk_release,
1107 .ioctl = idedisk_ioctl,
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08001108 .getgeo = idedisk_getgeo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 .media_changed = idedisk_media_changed,
1110 .revalidate_disk= idedisk_revalidate_disk
1111};
1112
1113MODULE_DESCRIPTION("ATA DISK Driver");
1114
Russell King4031bbe2006-01-06 11:41:00 +00001115static int ide_disk_probe(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116{
1117 struct ide_disk_obj *idkp;
1118 struct gendisk *g;
1119
1120 /* strstr("foo", "") is non-NULL */
1121 if (!strstr("ide-disk", drive->driver_req))
1122 goto failed;
1123 if (!drive->present)
1124 goto failed;
1125 if (drive->media != ide_disk)
1126 goto failed;
1127
Deepak Saxenaf5e3c2f2005-11-07 01:01:25 -08001128 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 if (!idkp)
1130 goto failed;
1131
Christoph Lameter19460892005-06-23 00:08:19 -07001132 g = alloc_disk_node(1 << PARTN_BITS,
Christoph Lameter86b37862005-08-09 19:59:21 -07001133 hwif_to_node(drive->hwif));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 if (!g)
1135 goto out_free_idkp;
1136
1137 ide_init_disk(g, drive);
1138
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02001139 ide_proc_register_driver(drive, &idedisk_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 kref_init(&idkp->kref);
1142
1143 idkp->drive = drive;
1144 idkp->driver = &idedisk_driver;
1145 idkp->disk = g;
1146
1147 g->private_data = &idkp->driver;
1148
1149 drive->driver_data = idkp;
1150
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 idedisk_setup(drive);
1152 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1153 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1154 drive->name, drive->head);
1155 drive->attach = 0;
1156 } else
1157 drive->attach = 1;
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001158
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 g->minors = 1 << PARTN_BITS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 g->driverfs_dev = &drive->gendev;
1161 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1162 set_capacity(g, idedisk_capacity(drive));
1163 g->fops = &idedisk_ops;
1164 add_disk(g);
1165 return 0;
1166
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167out_free_idkp:
1168 kfree(idkp);
1169failed:
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001170 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171}
1172
1173static void __exit idedisk_exit (void)
1174{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001175 driver_unregister(&idedisk_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176}
1177
Bartlomiej Zolnierkiewicz17514e82005-11-19 22:24:35 +01001178static int __init idedisk_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001180 return driver_register(&idedisk_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181}
1182
Kay Sievers263756e2005-12-12 18:03:44 +01001183MODULE_ALIAS("ide:*m-disk*");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184module_init(idedisk_init);
1185module_exit(idedisk_exit);
1186MODULE_LICENSE("GPL");