blob: 4754769eda9781ee2531b46f8bcbf42167e41685 [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.
16 *
17 * Version 1.00 move disk only code from ide.c to ide-disk.c
18 * support optional byte-swapping of all data
19 * Version 1.01 fix previous byte-swapping code
20 * Version 1.02 remove ", LBA" from drive identification msgs
21 * Version 1.03 fix display of id->buf_size for big-endian
22 * Version 1.04 add /proc configurable settings and S.M.A.R.T support
23 * Version 1.05 add capacity support for ATA3 >= 8GB
24 * Version 1.06 get boot-up messages to show full cyl count
25 * Version 1.07 disable door-locking if it fails
26 * Version 1.08 fixed CHS/LBA translations for ATA4 > 8GB,
27 * process of adding new ATA4 compliance.
28 * fixed problems in allowing fdisk to see
29 * the entire disk.
30 * Version 1.09 added increment of rq->sector in ide_multwrite
31 * added UDMA 3/4 reporting
32 * Version 1.10 request queue changes, Ultra DMA 100
33 * Version 1.11 added 48-bit lba
34 * Version 1.12 adding taskfile io access method
35 * Version 1.13 added standby and flush-cache for notifier
36 * Version 1.14 added acoustic-wcache
37 * Version 1.15 convert all calls to ide_raw_taskfile
38 * since args will return register content.
39 * Version 1.16 added suspend-resume-checkpower
Andreas Mohrd6e05ed2006-06-26 18:35:02 +020040 * Version 1.17 do flush on standby, do flush on ATA < ATA6
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 * fix wcache setup.
42 */
43
44#define IDEDISK_VERSION "1.18"
45
Linus Torvalds1da177e2005-04-16 15:20:36 -070046//#define DEBUG
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include <linux/module.h>
49#include <linux/types.h>
50#include <linux/string.h>
51#include <linux/kernel.h>
52#include <linux/timer.h>
53#include <linux/mm.h>
54#include <linux/interrupt.h>
55#include <linux/major.h>
56#include <linux/errno.h>
57#include <linux/genhd.h>
58#include <linux/slab.h>
59#include <linux/delay.h>
Arjan van de Vencf8b8972006-03-23 03:00:45 -080060#include <linux/mutex.h>
Richard Purdie2bfb6462006-03-31 02:31:16 -080061#include <linux/leds.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63#define _IDE_DISK
64
65#include <linux/ide.h>
66
67#include <asm/byteorder.h>
68#include <asm/irq.h>
69#include <asm/uaccess.h>
70#include <asm/io.h>
71#include <asm/div64.h>
72
73struct ide_disk_obj {
74 ide_drive_t *drive;
75 ide_driver_t *driver;
76 struct gendisk *disk;
77 struct kref kref;
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +010078 unsigned int openers; /* protected by BKL for now */
Linus Torvalds1da177e2005-04-16 15:20:36 -070079};
80
Arjan van de Vencf8b8972006-03-23 03:00:45 -080081static DEFINE_MUTEX(idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83#define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
84
85#define ide_disk_g(disk) \
86 container_of((disk)->private_data, struct ide_disk_obj, driver)
87
88static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
89{
90 struct ide_disk_obj *idkp = NULL;
91
Arjan van de Vencf8b8972006-03-23 03:00:45 -080092 mutex_lock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 idkp = ide_disk_g(disk);
94 if (idkp)
95 kref_get(&idkp->kref);
Arjan van de Vencf8b8972006-03-23 03:00:45 -080096 mutex_unlock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 return idkp;
98}
99
100static void ide_disk_release(struct kref *);
101
102static void ide_disk_put(struct ide_disk_obj *idkp)
103{
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800104 mutex_lock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 kref_put(&idkp->kref, ide_disk_release);
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800106 mutex_unlock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107}
108
109/*
110 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
111 * value for this drive (from its reported identification information).
112 *
113 * Returns: 1 if lba_capacity looks sensible
114 * 0 otherwise
115 *
116 * It is called only once for each drive.
117 */
118static int lba_capacity_is_ok (struct hd_driveid *id)
119{
120 unsigned long lba_sects, chs_sects, head, tail;
121
Alan Cox6efd9362005-06-27 15:24:22 -0700122 /* No non-LBA info .. so valid! */
123 if (id->cyls == 0)
124 return 1;
125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 /*
127 * The ATA spec tells large drives to return
128 * C/H/S = 16383/16/63 independent of their size.
129 * Some drives can be jumpered to use 15 heads instead of 16.
130 * Some drives can be jumpered to use 4092 cyls instead of 16383.
131 */
132 if ((id->cyls == 16383
133 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
134 id->sectors == 63 &&
135 (id->heads == 15 || id->heads == 16) &&
136 (id->lba_capacity >= 16383*63*id->heads))
137 return 1;
138
139 lba_sects = id->lba_capacity;
140 chs_sects = id->cyls * id->heads * id->sectors;
141
142 /* perform a rough sanity check on lba_sects: within 10% is OK */
143 if ((lba_sects - chs_sects) < chs_sects/10)
144 return 1;
145
146 /* some drives have the word order reversed */
147 head = ((lba_sects >> 16) & 0xffff);
148 tail = (lba_sects & 0xffff);
149 lba_sects = (head | (tail << 16));
150 if ((lba_sects - chs_sects) < chs_sects/10) {
151 id->lba_capacity = lba_sects;
152 return 1; /* lba_capacity is (now) good */
153 }
154
155 return 0; /* lba_capacity value may be bad */
156}
157
158/*
159 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
160 * using LBA if supported, or CHS otherwise, to address sectors.
161 */
162static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
163{
164 ide_hwif_t *hwif = HWIF(drive);
165 unsigned int dma = drive->using_dma;
166 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
167 task_ioreg_t command = WIN_NOP;
168 ata_nsector_t nsectors;
169
170 nsectors.all = (u16) rq->nr_sectors;
171
172 if (hwif->no_lba48_dma && lba48 && dma) {
173 if (block + rq->nr_sectors > 1ULL << 28)
174 dma = 0;
175 else
176 lba48 = 0;
177 }
178
179 if (!dma) {
180 ide_init_sg_cmd(drive, rq);
181 ide_map_sg(drive, rq);
182 }
183
184 if (IDE_CONTROL_REG)
185 hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
186
187 /* FIXME: SELECT_MASK(drive, 0) ? */
188
189 if (drive->select.b.lba) {
190 if (lba48) {
191 task_ioreg_t tasklets[10];
192
Michael Richardsonc2f83112006-02-07 12:58:33 -0800193 pr_debug("%s: LBA=0x%012llx\n", drive->name,
194 (unsigned long long)block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
196 tasklets[0] = 0;
197 tasklets[1] = 0;
198 tasklets[2] = nsectors.b.low;
199 tasklets[3] = nsectors.b.high;
200 tasklets[4] = (task_ioreg_t) block;
201 tasklets[5] = (task_ioreg_t) (block>>8);
202 tasklets[6] = (task_ioreg_t) (block>>16);
203 tasklets[7] = (task_ioreg_t) (block>>24);
204 if (sizeof(block) == 4) {
205 tasklets[8] = (task_ioreg_t) 0;
206 tasklets[9] = (task_ioreg_t) 0;
207 } else {
208 tasklets[8] = (task_ioreg_t)((u64)block >> 32);
209 tasklets[9] = (task_ioreg_t)((u64)block >> 40);
210 }
211#ifdef DEBUG
212 printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
213 drive->name, tasklets[3], tasklets[2],
214 tasklets[9], tasklets[8], tasklets[7],
215 tasklets[6], tasklets[5], tasklets[4]);
216#endif
217 hwif->OUTB(tasklets[1], IDE_FEATURE_REG);
218 hwif->OUTB(tasklets[3], IDE_NSECTOR_REG);
219 hwif->OUTB(tasklets[7], IDE_SECTOR_REG);
220 hwif->OUTB(tasklets[8], IDE_LCYL_REG);
221 hwif->OUTB(tasklets[9], IDE_HCYL_REG);
222
223 hwif->OUTB(tasklets[0], IDE_FEATURE_REG);
224 hwif->OUTB(tasklets[2], IDE_NSECTOR_REG);
225 hwif->OUTB(tasklets[4], IDE_SECTOR_REG);
226 hwif->OUTB(tasklets[5], IDE_LCYL_REG);
227 hwif->OUTB(tasklets[6], IDE_HCYL_REG);
228 hwif->OUTB(0x00|drive->select.all,IDE_SELECT_REG);
229 } else {
230 hwif->OUTB(0x00, IDE_FEATURE_REG);
231 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
232 hwif->OUTB(block, IDE_SECTOR_REG);
233 hwif->OUTB(block>>=8, IDE_LCYL_REG);
234 hwif->OUTB(block>>=8, IDE_HCYL_REG);
235 hwif->OUTB(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
236 }
237 } else {
238 unsigned int sect,head,cyl,track;
239 track = (int)block / drive->sect;
240 sect = (int)block % drive->sect + 1;
241 hwif->OUTB(sect, IDE_SECTOR_REG);
242 head = track % drive->head;
243 cyl = track / drive->head;
244
245 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
246
247 hwif->OUTB(0x00, IDE_FEATURE_REG);
248 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
249 hwif->OUTB(cyl, IDE_LCYL_REG);
250 hwif->OUTB(cyl>>8, IDE_HCYL_REG);
251 hwif->OUTB(head|drive->select.all,IDE_SELECT_REG);
252 }
253
254 if (dma) {
255 if (!hwif->dma_setup(drive)) {
256 if (rq_data_dir(rq)) {
257 command = lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
258 if (drive->vdma)
259 command = lba48 ? WIN_WRITE_EXT: WIN_WRITE;
260 } else {
261 command = lba48 ? WIN_READDMA_EXT : WIN_READDMA;
262 if (drive->vdma)
263 command = lba48 ? WIN_READ_EXT: WIN_READ;
264 }
265 hwif->dma_exec_cmd(drive, command);
266 hwif->dma_start(drive);
267 return ide_started;
268 }
269 /* fallback to PIO */
270 ide_init_sg_cmd(drive, rq);
271 }
272
273 if (rq_data_dir(rq) == READ) {
274
275 if (drive->mult_count) {
276 hwif->data_phase = TASKFILE_MULTI_IN;
277 command = lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
278 } else {
279 hwif->data_phase = TASKFILE_IN;
280 command = lba48 ? WIN_READ_EXT : WIN_READ;
281 }
282
283 ide_execute_command(drive, command, &task_in_intr, WAIT_CMD, NULL);
284 return ide_started;
285 } else {
286 if (drive->mult_count) {
287 hwif->data_phase = TASKFILE_MULTI_OUT;
288 command = lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
289 } else {
290 hwif->data_phase = TASKFILE_OUT;
291 command = lba48 ? WIN_WRITE_EXT : WIN_WRITE;
292 }
293
294 /* FIXME: ->OUTBSYNC ? */
295 hwif->OUTB(command, IDE_COMMAND_REG);
296
297 return pre_task_out_intr(drive, rq);
298 }
299}
300
301/*
302 * 268435455 == 137439 MB or 28bit limit
303 * 320173056 == 163929 MB or 48bit addressing
304 * 1073741822 == 549756 MB or 48bit addressing fake drive
305 */
306
307static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
308{
309 ide_hwif_t *hwif = HWIF(drive);
310
311 BUG_ON(drive->blocked);
312
313 if (!blk_fs_request(rq)) {
314 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
315 ide_end_request(drive, 0, 0);
316 return ide_stopped;
317 }
318
Richard Purdie2bfb6462006-03-31 02:31:16 -0800319 ledtrig_ide_activity();
320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
322 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
Michael Richardsonc2f83112006-02-07 12:58:33 -0800323 (unsigned long long)block, rq->nr_sectors,
324 (unsigned long)rq->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325
326 if (hwif->rw_disk)
327 hwif->rw_disk(drive, rq);
328
329 return __ide_do_rw_disk(drive, rq, block);
330}
331
332/*
333 * Queries for true maximum capacity of the drive.
334 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
335 */
336static unsigned long idedisk_read_native_max_address(ide_drive_t *drive)
337{
338 ide_task_t args;
339 unsigned long addr = 0;
340
341 /* Create IDE/ATA command request structure */
342 memset(&args, 0, sizeof(ide_task_t));
343 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
344 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX;
345 args.command_type = IDE_DRIVE_TASK_NO_DATA;
346 args.handler = &task_no_data_intr;
347 /* submit command request */
348 ide_raw_taskfile(drive, &args, NULL);
349
350 /* if OK, compute maximum address value */
351 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
352 addr = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
353 | ((args.tfRegister[ IDE_HCYL_OFFSET] ) << 16)
354 | ((args.tfRegister[ IDE_LCYL_OFFSET] ) << 8)
355 | ((args.tfRegister[IDE_SECTOR_OFFSET] ));
356 addr++; /* since the return value is (maxlba - 1), we add 1 */
357 }
358 return addr;
359}
360
361static unsigned long long idedisk_read_native_max_address_ext(ide_drive_t *drive)
362{
363 ide_task_t args;
364 unsigned long long addr = 0;
365
366 /* Create IDE/ATA command request structure */
367 memset(&args, 0, sizeof(ide_task_t));
368
369 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
370 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX_EXT;
371 args.command_type = IDE_DRIVE_TASK_NO_DATA;
372 args.handler = &task_no_data_intr;
373 /* submit command request */
374 ide_raw_taskfile(drive, &args, NULL);
375
376 /* if OK, compute maximum address value */
377 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
378 u32 high = (args.hobRegister[IDE_HCYL_OFFSET] << 16) |
379 (args.hobRegister[IDE_LCYL_OFFSET] << 8) |
380 args.hobRegister[IDE_SECTOR_OFFSET];
381 u32 low = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
382 ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
383 (args.tfRegister[IDE_SECTOR_OFFSET]);
384 addr = ((__u64)high << 24) | low;
385 addr++; /* since the return value is (maxlba - 1), we add 1 */
386 }
387 return addr;
388}
389
390/*
391 * Sets maximum virtual LBA address of the drive.
392 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
393 */
394static unsigned long idedisk_set_max_address(ide_drive_t *drive, unsigned long addr_req)
395{
396 ide_task_t args;
397 unsigned long addr_set = 0;
398
399 addr_req--;
400 /* Create IDE/ATA command request structure */
401 memset(&args, 0, sizeof(ide_task_t));
402 args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >> 0) & 0xff);
403 args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >> 8) & 0xff);
404 args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >> 16) & 0xff);
405 args.tfRegister[IDE_SELECT_OFFSET] = ((addr_req >> 24) & 0x0f) | 0x40;
406 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX;
407 args.command_type = IDE_DRIVE_TASK_NO_DATA;
408 args.handler = &task_no_data_intr;
409 /* submit command request */
410 ide_raw_taskfile(drive, &args, NULL);
411 /* if OK, read new maximum address value */
412 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
413 addr_set = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
414 | ((args.tfRegister[ IDE_HCYL_OFFSET] ) << 16)
415 | ((args.tfRegister[ IDE_LCYL_OFFSET] ) << 8)
416 | ((args.tfRegister[IDE_SECTOR_OFFSET] ));
417 addr_set++;
418 }
419 return addr_set;
420}
421
422static unsigned long long idedisk_set_max_address_ext(ide_drive_t *drive, unsigned long long addr_req)
423{
424 ide_task_t args;
425 unsigned long long addr_set = 0;
426
427 addr_req--;
428 /* Create IDE/ATA command request structure */
429 memset(&args, 0, sizeof(ide_task_t));
430 args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >> 0) & 0xff);
431 args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
432 args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
433 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
434 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX_EXT;
435 args.hobRegister[IDE_SECTOR_OFFSET] = (addr_req >>= 8) & 0xff;
436 args.hobRegister[IDE_LCYL_OFFSET] = (addr_req >>= 8) & 0xff;
437 args.hobRegister[IDE_HCYL_OFFSET] = (addr_req >>= 8) & 0xff;
438 args.hobRegister[IDE_SELECT_OFFSET] = 0x40;
439 args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
440 args.command_type = IDE_DRIVE_TASK_NO_DATA;
441 args.handler = &task_no_data_intr;
442 /* submit command request */
443 ide_raw_taskfile(drive, &args, NULL);
444 /* if OK, compute maximum address value */
445 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
446 u32 high = (args.hobRegister[IDE_HCYL_OFFSET] << 16) |
447 (args.hobRegister[IDE_LCYL_OFFSET] << 8) |
448 args.hobRegister[IDE_SECTOR_OFFSET];
449 u32 low = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
450 ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
451 (args.tfRegister[IDE_SECTOR_OFFSET]);
452 addr_set = ((__u64)high << 24) | low;
453 addr_set++;
454 }
455 return addr_set;
456}
457
458static unsigned long long sectors_to_MB(unsigned long long n)
459{
460 n <<= 9; /* make it bytes */
461 do_div(n, 1000000); /* make it MB */
462 return n;
463}
464
465/*
466 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
467 * so on non-buggy drives we need test only one.
468 * However, we should also check whether these fields are valid.
469 */
470static inline int idedisk_supports_hpa(const struct hd_driveid *id)
471{
472 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
473}
474
475/*
476 * The same here.
477 */
478static inline int idedisk_supports_lba48(const struct hd_driveid *id)
479{
480 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
481 && id->lba_capacity_2;
482}
483
Bartlomiej Zolnierkiewiczb0244a02007-08-20 22:42:57 +0200484/*
485 * Some disks report total number of sectors instead of
486 * maximum sector address. We list them here.
487 */
488static const struct drive_list_entry hpa_list[] = {
489 { "ST340823A", NULL },
Jorge Juan Chico7062cdc2007-09-17 12:35:30 +0200490 { "ST320413A", NULL },
Bartlomiej Zolnierkiewiczb0244a02007-08-20 22:42:57 +0200491 { NULL, NULL }
492};
493
Arjan van de Ven858119e2006-01-14 13:20:43 -0800494static void idedisk_check_hpa(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495{
496 unsigned long long capacity, set_max;
497 int lba48 = idedisk_supports_lba48(drive->id);
498
499 capacity = drive->capacity64;
500 if (lba48)
501 set_max = idedisk_read_native_max_address_ext(drive);
502 else
503 set_max = idedisk_read_native_max_address(drive);
504
Bartlomiej Zolnierkiewiczb0244a02007-08-20 22:42:57 +0200505 if (ide_in_drive_list(drive->id, hpa_list)) {
506 /*
507 * Since we are inclusive wrt to firmware revisions do this
508 * extra check and apply the workaround only when needed.
509 */
510 if (set_max == capacity + 1)
511 set_max--;
512 }
513
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 if (set_max <= capacity)
515 return;
516
517 printk(KERN_INFO "%s: Host Protected Area detected.\n"
518 "\tcurrent capacity is %llu sectors (%llu MB)\n"
519 "\tnative capacity is %llu sectors (%llu MB)\n",
520 drive->name,
521 capacity, sectors_to_MB(capacity),
522 set_max, sectors_to_MB(set_max));
523
524 if (lba48)
525 set_max = idedisk_set_max_address_ext(drive, set_max);
526 else
527 set_max = idedisk_set_max_address(drive, set_max);
528 if (set_max) {
529 drive->capacity64 = set_max;
530 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
531 drive->name);
532 }
533}
534
535/*
536 * Compute drive->capacity, the full capacity of the drive
537 * Called with drive->id != NULL.
538 *
539 * To compute capacity, this uses either of
540 *
541 * 1. CHS value set by user (whatever user sets will be trusted)
542 * 2. LBA value from target drive (require new ATA feature)
543 * 3. LBA value from system BIOS (new one is OK, old one may break)
544 * 4. CHS value from system BIOS (traditional style)
545 *
546 * in above order (i.e., if value of higher priority is available,
547 * reset will be ignored).
548 */
549static void init_idedisk_capacity (ide_drive_t *drive)
550{
551 struct hd_driveid *id = drive->id;
552 /*
553 * If this drive supports the Host Protected Area feature set,
554 * then we may need to change our opinion about the drive's capacity.
555 */
556 int hpa = idedisk_supports_hpa(id);
557
558 if (idedisk_supports_lba48(id)) {
559 /* drive speaks 48-bit LBA */
560 drive->select.b.lba = 1;
561 drive->capacity64 = id->lba_capacity_2;
562 if (hpa)
563 idedisk_check_hpa(drive);
564 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
565 /* drive speaks 28-bit LBA */
566 drive->select.b.lba = 1;
567 drive->capacity64 = id->lba_capacity;
568 if (hpa)
569 idedisk_check_hpa(drive);
570 } else {
571 /* drive speaks boring old 28-bit CHS */
572 drive->capacity64 = drive->cyl * drive->head * drive->sect;
573 }
574}
575
576static sector_t idedisk_capacity (ide_drive_t *drive)
577{
578 return drive->capacity64 - drive->sect0;
579}
580
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +0200581#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582static int smart_enable(ide_drive_t *drive)
583{
584 ide_task_t args;
585
586 memset(&args, 0, sizeof(ide_task_t));
587 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_ENABLE;
588 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
589 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
590 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
591 args.command_type = IDE_DRIVE_TASK_NO_DATA;
592 args.handler = &task_no_data_intr;
593 return ide_raw_taskfile(drive, &args, NULL);
594}
595
596static int get_smart_values(ide_drive_t *drive, u8 *buf)
597{
598 ide_task_t args;
599
600 memset(&args, 0, sizeof(ide_task_t));
601 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_VALUES;
602 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
603 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
604 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
605 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
606 args.command_type = IDE_DRIVE_TASK_IN;
607 args.data_phase = TASKFILE_IN;
608 args.handler = &task_in_intr;
609 (void) smart_enable(drive);
610 return ide_raw_taskfile(drive, &args, buf);
611}
612
613static int get_smart_thresholds(ide_drive_t *drive, u8 *buf)
614{
615 ide_task_t args;
616 memset(&args, 0, sizeof(ide_task_t));
617 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_THRESHOLDS;
618 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
619 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
620 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
621 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
622 args.command_type = IDE_DRIVE_TASK_IN;
623 args.data_phase = TASKFILE_IN;
624 args.handler = &task_in_intr;
625 (void) smart_enable(drive);
626 return ide_raw_taskfile(drive, &args, buf);
627}
628
629static int proc_idedisk_read_cache
630 (char *page, char **start, off_t off, int count, int *eof, void *data)
631{
632 ide_drive_t *drive = (ide_drive_t *) data;
633 char *out = page;
634 int len;
635
636 if (drive->id_read)
637 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
638 else
639 len = sprintf(out,"(none)\n");
640 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
641}
642
643static int proc_idedisk_read_capacity
644 (char *page, char **start, off_t off, int count, int *eof, void *data)
645{
646 ide_drive_t*drive = (ide_drive_t *)data;
647 int len;
648
649 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
650 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
651}
652
653static int proc_idedisk_read_smart_thresholds
654 (char *page, char **start, off_t off, int count, int *eof, void *data)
655{
656 ide_drive_t *drive = (ide_drive_t *)data;
657 int len = 0, i = 0;
658
659 if (!get_smart_thresholds(drive, page)) {
660 unsigned short *val = (unsigned short *) page;
661 char *out = ((char *)val) + (SECTOR_WORDS * 4);
662 page = out;
663 do {
664 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
665 val += 1;
666 } while (i < (SECTOR_WORDS * 2));
667 len = out - page;
668 }
669 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
670}
671
672static int proc_idedisk_read_smart_values
673 (char *page, char **start, off_t off, int count, int *eof, void *data)
674{
675 ide_drive_t *drive = (ide_drive_t *)data;
676 int len = 0, i = 0;
677
678 if (!get_smart_values(drive, page)) {
679 unsigned short *val = (unsigned short *) page;
680 char *out = ((char *)val) + (SECTOR_WORDS * 4);
681 page = out;
682 do {
683 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
684 val += 1;
685 } while (i < (SECTOR_WORDS * 2));
686 len = out - page;
687 }
688 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
689}
690
691static ide_proc_entry_t idedisk_proc[] = {
692 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
693 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
694 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
695 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
696 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
697 { NULL, 0, NULL, NULL }
698};
Bartlomiej Zolnierkiewiczecfd80e2007-05-10 00:01:09 +0200699#endif /* CONFIG_IDE_PROC_FS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
Jens Axboe165125e2007-07-24 09:28:11 +0200701static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702{
703 ide_drive_t *drive = q->queuedata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
705 memset(rq->cmd, 0, sizeof(rq->cmd));
706
707 if (ide_id_has_flush_cache_ext(drive->id) &&
708 (drive->capacity64 >= (1UL << 28)))
709 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
710 else
711 rq->cmd[0] = WIN_FLUSH_CACHE;
712
713
Jens Axboe4aff5e22006-08-10 08:44:47 +0200714 rq->cmd_type = REQ_TYPE_ATA_TASK;
715 rq->cmd_flags |= REQ_SOFTBARRIER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 rq->buffer = rq->cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717}
718
Jens Axboe165125e2007-07-24 09:28:11 +0200719static int idedisk_issue_flush(struct request_queue *q, struct gendisk *disk,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 sector_t *error_sector)
721{
722 ide_drive_t *drive = q->queuedata;
723 struct request *rq;
724 int ret;
725
726 if (!drive->wcache)
727 return 0;
728
729 rq = blk_get_request(q, WRITE, __GFP_WAIT);
730
731 idedisk_prepare_flush(q, rq);
732
James Bottomley 994ca9a2005-06-20 14:11:09 +0200733 ret = blk_execute_rq(q, disk, rq, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735 /*
736 * if we failed and caller wants error offset, get it
737 */
738 if (ret && error_sector)
739 *error_sector = ide_get_error_location(drive, rq->cmd);
740
741 blk_put_request(rq);
742 return ret;
743}
744
745/*
746 * This is tightly woven into the driver->do_special can not touch.
747 * DON'T do it again until a total personality rewrite is committed.
748 */
749static int set_multcount(ide_drive_t *drive, int arg)
750{
751 struct request rq;
752
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200753 if (arg < 0 || arg > drive->id->max_multsect)
754 return -EINVAL;
755
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 if (drive->special.b.set_multmode)
757 return -EBUSY;
758 ide_init_drive_cmd (&rq);
Jens Axboe4aff5e22006-08-10 08:44:47 +0200759 rq.cmd_type = REQ_TYPE_ATA_CMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 drive->mult_req = arg;
761 drive->special.b.set_multmode = 1;
762 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
763 return (drive->mult_count == arg) ? 0 : -EIO;
764}
765
766static int set_nowerr(ide_drive_t *drive, int arg)
767{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200768 if (arg < 0 || arg > 1)
769 return -EINVAL;
770
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 if (ide_spin_wait_hwgroup(drive))
772 return -EBUSY;
773 drive->nowerr = arg;
774 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
775 spin_unlock_irq(&ide_lock);
776 return 0;
777}
778
Tejun Heo3e087b52006-01-06 09:57:31 +0100779static void update_ordered(ide_drive_t *drive)
780{
781 struct hd_driveid *id = drive->id;
782 unsigned ordered = QUEUE_ORDERED_NONE;
783 prepare_flush_fn *prep_fn = NULL;
784 issue_flush_fn *issue_fn = NULL;
785
786 if (drive->wcache) {
787 unsigned long long capacity;
788 int barrier;
789 /*
790 * We must avoid issuing commands a drive does not
791 * understand or we may crash it. We check flush cache
792 * is supported. We also check we have the LBA48 flush
793 * cache if the drive capacity is too large. By this
794 * time we have trimmed the drive capacity if LBA48 is
795 * not available so we don't need to recheck that.
796 */
797 capacity = idedisk_capacity(drive);
Jens Axboe36193482006-07-28 08:54:59 +0200798 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
Tejun Heo3e087b52006-01-06 09:57:31 +0100799 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
800 ide_id_has_flush_cache_ext(id));
801
802 printk(KERN_INFO "%s: cache flushes %ssupported\n",
Jean Delvaref7ad8362006-02-03 03:04:57 -0800803 drive->name, barrier ? "" : "not ");
Tejun Heo3e087b52006-01-06 09:57:31 +0100804
805 if (barrier) {
806 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
807 prep_fn = idedisk_prepare_flush;
808 issue_fn = idedisk_issue_flush;
809 }
810 } else
811 ordered = QUEUE_ORDERED_DRAIN;
812
813 blk_queue_ordered(drive->queue, ordered, prep_fn);
814 blk_queue_issue_flush_fn(drive->queue, issue_fn);
815}
816
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817static int write_cache(ide_drive_t *drive, int arg)
818{
819 ide_task_t args;
Tejun Heo3e087b52006-01-06 09:57:31 +0100820 int err = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200822 if (arg < 0 || arg > 1)
823 return -EINVAL;
824
Tejun Heo3e087b52006-01-06 09:57:31 +0100825 if (ide_id_has_flush_cache(drive->id)) {
826 memset(&args, 0, sizeof(ide_task_t));
827 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
Tejun Heo3e087b52006-01-06 09:57:31 +0100829 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
830 args.command_type = IDE_DRIVE_TASK_NO_DATA;
831 args.handler = &task_no_data_intr;
832 err = ide_raw_taskfile(drive, &args, NULL);
833 if (err == 0)
834 drive->wcache = arg;
835 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
Tejun Heo3e087b52006-01-06 09:57:31 +0100837 update_ordered(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
Tejun Heo3e087b52006-01-06 09:57:31 +0100839 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840}
841
842static int do_idedisk_flushcache (ide_drive_t *drive)
843{
844 ide_task_t args;
845
846 memset(&args, 0, sizeof(ide_task_t));
847 if (ide_id_has_flush_cache_ext(drive->id))
848 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE_EXT;
849 else
850 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE;
851 args.command_type = IDE_DRIVE_TASK_NO_DATA;
852 args.handler = &task_no_data_intr;
853 return ide_raw_taskfile(drive, &args, NULL);
854}
855
856static int set_acoustic (ide_drive_t *drive, int arg)
857{
858 ide_task_t args;
859
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200860 if (arg < 0 || arg > 254)
861 return -EINVAL;
862
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863 memset(&args, 0, sizeof(ide_task_t));
864 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ? SETFEATURES_EN_AAM :
865 SETFEATURES_DIS_AAM;
866 args.tfRegister[IDE_NSECTOR_OFFSET] = arg;
867 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
868 args.command_type = IDE_DRIVE_TASK_NO_DATA;
869 args.handler = &task_no_data_intr;
870 ide_raw_taskfile(drive, &args, NULL);
871 drive->acoustic = arg;
872 return 0;
873}
874
875/*
876 * drive->addressing:
877 * 0: 28-bit
878 * 1: 48-bit
879 * 2: 48-bit capable doing 28-bit
880 */
881static int set_lba_addressing(ide_drive_t *drive, int arg)
882{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200883 if (arg < 0 || arg > 2)
884 return -EINVAL;
885
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 drive->addressing = 0;
887
888 if (HWIF(drive)->no_lba48)
889 return 0;
890
891 if (!idedisk_supports_lba48(drive->id))
892 return -EIO;
893 drive->addressing = arg;
894 return 0;
895}
896
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200897#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898static void idedisk_add_settings(ide_drive_t *drive)
899{
900 struct hd_driveid *id = drive->id;
901
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +0200902 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
903 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
904 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
905 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
906 ide_add_setting(drive, "bswap", SETTING_READ, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
907 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount);
908 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
909 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
910 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
911 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
912 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
913 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 -0700914}
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +0200915#else
916static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
917#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
919static void idedisk_setup (ide_drive_t *drive)
920{
921 struct hd_driveid *id = drive->id;
922 unsigned long long capacity;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923
924 idedisk_add_settings(drive);
925
926 if (drive->id_read == 0)
927 return;
928
Richard Purdie98109332006-02-03 03:04:55 -0800929 if (drive->removable) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 /*
931 * Removable disks (eg. SYQUEST); ignore 'WD' drives
932 */
933 if (id->model[0] != 'W' || id->model[1] != 'D') {
934 drive->doorlocking = 1;
935 }
936 }
937
938 (void)set_lba_addressing(drive, 1);
939
940 if (drive->addressing == 1) {
941 ide_hwif_t *hwif = HWIF(drive);
942 int max_s = 2048;
943
944 if (max_s > hwif->rqsize)
945 max_s = hwif->rqsize;
946
947 blk_queue_max_sectors(drive->queue, max_s);
948 }
949
950 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
951
952 /* calculate drive capacity, and select LBA if possible */
953 init_idedisk_capacity (drive);
954
955 /* limit drive capacity to 137GB if LBA48 cannot be used */
956 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
957 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
958 "%llu sectors (%llu MB)\n",
959 drive->name, (unsigned long long)drive->capacity64,
960 sectors_to_MB(drive->capacity64));
961 drive->capacity64 = 1ULL << 28;
962 }
963
964 if (drive->hwif->no_lba48_dma && drive->addressing) {
965 if (drive->capacity64 > 1ULL << 28) {
966 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
967 " be used for accessing sectors > %u\n",
968 drive->name, 1 << 28);
969 } else
970 drive->addressing = 0;
971 }
972
973 /*
974 * if possible, give fdisk access to more of the drive,
975 * by correcting bios_cyls:
976 */
977 capacity = idedisk_capacity (drive);
978 if (!drive->forced_geom) {
979
980 if (idedisk_supports_lba48(drive->id)) {
981 /* compatibility */
982 drive->bios_sect = 63;
983 drive->bios_head = 255;
984 }
985
986 if (drive->bios_sect && drive->bios_head) {
987 unsigned int cap0 = capacity; /* truncate to 32 bits */
988 unsigned int cylsz, cyl;
989
990 if (cap0 != capacity)
991 drive->bios_cyl = 65535;
992 else {
993 cylsz = drive->bios_sect * drive->bios_head;
994 cyl = cap0 / cylsz;
995 if (cyl > 65535)
996 cyl = 65535;
997 if (cyl > drive->bios_cyl)
998 drive->bios_cyl = cyl;
999 }
1000 }
1001 }
1002 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
1003 drive->name, capacity, sectors_to_MB(capacity));
1004
1005 /* Only print cache size when it was specified */
1006 if (id->buf_size)
1007 printk (" w/%dKiB Cache", id->buf_size/2);
1008
1009 printk(", CHS=%d/%d/%d",
1010 drive->bios_cyl, drive->bios_head, drive->bios_sect);
1011 if (drive->using_dma)
1012 ide_dma_verbose(drive);
1013 printk("\n");
1014
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 /* write cache enabled? */
1016 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
1017 drive->wcache = 1;
1018
1019 write_cache(drive, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020}
1021
1022static void ide_cacheflush_p(ide_drive_t *drive)
1023{
1024 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
1025 return;
1026
1027 if (do_idedisk_flushcache(drive))
1028 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
1029}
1030
Russell King4031bbe2006-01-06 11:41:00 +00001031static void ide_disk_remove(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032{
1033 struct ide_disk_obj *idkp = drive->driver_data;
1034 struct gendisk *g = idkp->disk;
1035
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02001036 ide_proc_unregister_driver(drive, idkp->driver);
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001037
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 del_gendisk(g);
1039
Bartlomiej Zolnierkiewiczd36fef62005-12-15 02:19:20 +01001040 ide_cacheflush_p(drive);
1041
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 ide_disk_put(idkp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043}
1044
1045static void ide_disk_release(struct kref *kref)
1046{
1047 struct ide_disk_obj *idkp = to_ide_disk(kref);
1048 ide_drive_t *drive = idkp->drive;
1049 struct gendisk *g = idkp->disk;
1050
1051 drive->driver_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 g->private_data = NULL;
1053 put_disk(g);
1054 kfree(idkp);
1055}
1056
Russell King4031bbe2006-01-06 11:41:00 +00001057static int ide_disk_probe(ide_drive_t *drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058
Lee Trager0d2157f2007-06-08 15:14:30 +02001059/*
1060 * On HPA drives the capacity needs to be
1061 * reinitilized on resume otherwise the disk
1062 * can not be used and a hard reset is required
1063 */
1064static void ide_disk_resume(ide_drive_t *drive)
1065{
1066 if (idedisk_supports_hpa(drive->id))
1067 init_idedisk_capacity(drive);
1068}
1069
Russell King4031bbe2006-01-06 11:41:00 +00001070static void ide_device_shutdown(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072#ifdef CONFIG_ALPHA
1073 /* On Alpha, halt(8) doesn't actually turn the machine off,
1074 it puts you into the sort of firmware monitor. Typically,
1075 it's used to boot another kernel image, so it's not much
1076 different from reboot(8). Therefore, we don't need to
1077 spin down the disk in this case, especially since Alpha
1078 firmware doesn't handle disks in standby mode properly.
1079 On the other hand, it's reasonably safe to turn the power
1080 off when the shutdown process reaches the firmware prompt,
1081 as the firmware initialization takes rather long time -
1082 at least 10 seconds, which should be sufficient for
1083 the disk to expire its write cache. */
1084 if (system_state != SYSTEM_POWER_OFF) {
1085#else
1086 if (system_state == SYSTEM_RESTART) {
1087#endif
1088 ide_cacheflush_p(drive);
1089 return;
1090 }
1091
1092 printk("Shutdown: %s\n", drive->name);
Russell King4031bbe2006-01-06 11:41:00 +00001093 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094}
1095
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096static ide_driver_t idedisk_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 .gen_driver = {
Laurent Riffard4ef3b8f2005-11-18 22:15:40 +01001098 .owner = THIS_MODULE,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001099 .name = "ide-disk",
1100 .bus = &ide_bus_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101 },
Russell King4031bbe2006-01-06 11:41:00 +00001102 .probe = ide_disk_probe,
1103 .remove = ide_disk_remove,
Lee Trager0d2157f2007-06-08 15:14:30 +02001104 .resume = ide_disk_resume,
Russell King4031bbe2006-01-06 11:41:00 +00001105 .shutdown = ide_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 .version = IDEDISK_VERSION,
1107 .media = ide_disk,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 .supports_dsc_overlap = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 .do_request = ide_do_rw_disk,
1110 .end_request = ide_end_request,
1111 .error = __ide_error,
1112 .abort = __ide_abort,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02001113#ifdef CONFIG_IDE_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 .proc = idedisk_proc,
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02001115#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116};
1117
1118static int idedisk_open(struct inode *inode, struct file *filp)
1119{
1120 struct gendisk *disk = inode->i_bdev->bd_disk;
1121 struct ide_disk_obj *idkp;
1122 ide_drive_t *drive;
1123
1124 if (!(idkp = ide_disk_get(disk)))
1125 return -ENXIO;
1126
1127 drive = idkp->drive;
1128
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +01001129 idkp->openers++;
1130
1131 if (drive->removable && idkp->openers == 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 ide_task_t args;
1133 memset(&args, 0, sizeof(ide_task_t));
1134 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORLOCK;
1135 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1136 args.handler = &task_no_data_intr;
1137 check_disk_change(inode->i_bdev);
1138 /*
1139 * Ignore the return code from door_lock,
1140 * since the open() has already succeeded,
1141 * and the door_lock is irrelevant at this point.
1142 */
1143 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1144 drive->doorlocking = 0;
1145 }
1146 return 0;
1147}
1148
1149static int idedisk_release(struct inode *inode, struct file *filp)
1150{
1151 struct gendisk *disk = inode->i_bdev->bd_disk;
1152 struct ide_disk_obj *idkp = ide_disk_g(disk);
1153 ide_drive_t *drive = idkp->drive;
1154
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +01001155 if (idkp->openers == 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 ide_cacheflush_p(drive);
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +01001157
1158 if (drive->removable && idkp->openers == 1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 ide_task_t args;
1160 memset(&args, 0, sizeof(ide_task_t));
1161 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORUNLOCK;
1162 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1163 args.handler = &task_no_data_intr;
1164 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1165 drive->doorlocking = 0;
1166 }
Bartlomiej Zolnierkiewiczc94964a2007-02-17 02:40:24 +01001167
1168 idkp->openers--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
1170 ide_disk_put(idkp);
1171
1172 return 0;
1173}
1174
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08001175static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1176{
1177 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1178 ide_drive_t *drive = idkp->drive;
1179
1180 geo->heads = drive->bios_head;
1181 geo->sectors = drive->bios_sect;
1182 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1183 return 0;
1184}
1185
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186static int idedisk_ioctl(struct inode *inode, struct file *file,
1187 unsigned int cmd, unsigned long arg)
1188{
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001189 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 struct block_device *bdev = inode->i_bdev;
1191 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001192 ide_drive_t *drive = idkp->drive;
1193 int err, (*setfunc)(ide_drive_t *, int);
1194 u8 *val;
1195
1196 switch (cmd) {
1197 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1198 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1199 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1200 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1201 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1202 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1203 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1204 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1205 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1206 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1207 }
1208
1209 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1210
1211read_val:
Matthias Kaehlckef9383c42007-07-09 23:17:56 +02001212 mutex_lock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001213 spin_lock_irqsave(&ide_lock, flags);
1214 err = *val;
1215 spin_unlock_irqrestore(&ide_lock, flags);
Matthias Kaehlckef9383c42007-07-09 23:17:56 +02001216 mutex_unlock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001217 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1218
1219set_val:
1220 if (bdev != bdev->bd_contains)
1221 err = -EINVAL;
1222 else {
1223 if (!capable(CAP_SYS_ADMIN))
1224 err = -EACCES;
1225 else {
Matthias Kaehlckef9383c42007-07-09 23:17:56 +02001226 mutex_lock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001227 err = setfunc(drive, arg);
Matthias Kaehlckef9383c42007-07-09 23:17:56 +02001228 mutex_unlock(&ide_setting_mtx);
Bartlomiej Zolnierkiewicz14979432007-05-10 00:01:10 +02001229 }
1230 }
1231 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232}
1233
1234static int idedisk_media_changed(struct gendisk *disk)
1235{
1236 struct ide_disk_obj *idkp = ide_disk_g(disk);
1237 ide_drive_t *drive = idkp->drive;
1238
1239 /* do not scan partitions twice if this is a removable device */
1240 if (drive->attach) {
1241 drive->attach = 0;
1242 return 0;
1243 }
1244 /* if removable, always assume it was changed */
1245 return drive->removable;
1246}
1247
1248static int idedisk_revalidate_disk(struct gendisk *disk)
1249{
1250 struct ide_disk_obj *idkp = ide_disk_g(disk);
1251 set_capacity(disk, idedisk_capacity(idkp->drive));
1252 return 0;
1253}
1254
1255static struct block_device_operations idedisk_ops = {
1256 .owner = THIS_MODULE,
1257 .open = idedisk_open,
1258 .release = idedisk_release,
1259 .ioctl = idedisk_ioctl,
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08001260 .getgeo = idedisk_getgeo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261 .media_changed = idedisk_media_changed,
1262 .revalidate_disk= idedisk_revalidate_disk
1263};
1264
1265MODULE_DESCRIPTION("ATA DISK Driver");
1266
Russell King4031bbe2006-01-06 11:41:00 +00001267static int ide_disk_probe(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268{
1269 struct ide_disk_obj *idkp;
1270 struct gendisk *g;
1271
1272 /* strstr("foo", "") is non-NULL */
1273 if (!strstr("ide-disk", drive->driver_req))
1274 goto failed;
1275 if (!drive->present)
1276 goto failed;
1277 if (drive->media != ide_disk)
1278 goto failed;
1279
Deepak Saxenaf5e3c2f2005-11-07 01:01:25 -08001280 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 if (!idkp)
1282 goto failed;
1283
Christoph Lameter19460892005-06-23 00:08:19 -07001284 g = alloc_disk_node(1 << PARTN_BITS,
Christoph Lameter86b37862005-08-09 19:59:21 -07001285 hwif_to_node(drive->hwif));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 if (!g)
1287 goto out_free_idkp;
1288
1289 ide_init_disk(g, drive);
1290
Bartlomiej Zolnierkiewicz7662d042007-05-10 00:01:10 +02001291 ide_proc_register_driver(drive, &idedisk_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 kref_init(&idkp->kref);
1294
1295 idkp->drive = drive;
1296 idkp->driver = &idedisk_driver;
1297 idkp->disk = g;
1298
1299 g->private_data = &idkp->driver;
1300
1301 drive->driver_data = idkp;
1302
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 idedisk_setup(drive);
1304 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1305 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1306 drive->name, drive->head);
1307 drive->attach = 0;
1308 } else
1309 drive->attach = 1;
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001310
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 g->minors = 1 << PARTN_BITS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 g->driverfs_dev = &drive->gendev;
1313 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1314 set_capacity(g, idedisk_capacity(drive));
1315 g->fops = &idedisk_ops;
1316 add_disk(g);
1317 return 0;
1318
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319out_free_idkp:
1320 kfree(idkp);
1321failed:
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001322 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323}
1324
1325static void __exit idedisk_exit (void)
1326{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001327 driver_unregister(&idedisk_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328}
1329
Bartlomiej Zolnierkiewicz17514e82005-11-19 22:24:35 +01001330static int __init idedisk_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001332 return driver_register(&idedisk_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333}
1334
Kay Sievers263756e2005-12-12 18:03:44 +01001335MODULE_ALIAS("ide:*m-disk*");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336module_init(idedisk_init);
1337module_exit(idedisk_exit);
1338MODULE_LICENSE("GPL");