blob: 0a05a377d66ac54a77056fd67cf484cf5bdf8fec [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
46#undef REALLY_SLOW_IO /* most systems can safely undef this */
47
48//#define DEBUG
49
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <linux/module.h>
51#include <linux/types.h>
52#include <linux/string.h>
53#include <linux/kernel.h>
54#include <linux/timer.h>
55#include <linux/mm.h>
56#include <linux/interrupt.h>
57#include <linux/major.h>
58#include <linux/errno.h>
59#include <linux/genhd.h>
60#include <linux/slab.h>
61#include <linux/delay.h>
Arjan van de Vencf8b8972006-03-23 03:00:45 -080062#include <linux/mutex.h>
Richard Purdie2bfb6462006-03-31 02:31:16 -080063#include <linux/leds.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
65#define _IDE_DISK
66
67#include <linux/ide.h>
68
69#include <asm/byteorder.h>
70#include <asm/irq.h>
71#include <asm/uaccess.h>
72#include <asm/io.h>
73#include <asm/div64.h>
74
75struct ide_disk_obj {
76 ide_drive_t *drive;
77 ide_driver_t *driver;
78 struct gendisk *disk;
79 struct kref kref;
80};
81
Arjan van de Vencf8b8972006-03-23 03:00:45 -080082static DEFINE_MUTEX(idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083
84#define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
85
86#define ide_disk_g(disk) \
87 container_of((disk)->private_data, struct ide_disk_obj, driver)
88
89static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
90{
91 struct ide_disk_obj *idkp = NULL;
92
Arjan van de Vencf8b8972006-03-23 03:00:45 -080093 mutex_lock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 idkp = ide_disk_g(disk);
95 if (idkp)
96 kref_get(&idkp->kref);
Arjan van de Vencf8b8972006-03-23 03:00:45 -080097 mutex_unlock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 return idkp;
99}
100
101static void ide_disk_release(struct kref *);
102
103static void ide_disk_put(struct ide_disk_obj *idkp)
104{
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800105 mutex_lock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 kref_put(&idkp->kref, ide_disk_release);
Arjan van de Vencf8b8972006-03-23 03:00:45 -0800107 mutex_unlock(&idedisk_ref_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108}
109
110/*
111 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
112 * value for this drive (from its reported identification information).
113 *
114 * Returns: 1 if lba_capacity looks sensible
115 * 0 otherwise
116 *
117 * It is called only once for each drive.
118 */
119static int lba_capacity_is_ok (struct hd_driveid *id)
120{
121 unsigned long lba_sects, chs_sects, head, tail;
122
Alan Cox6efd9362005-06-27 15:24:22 -0700123 /* No non-LBA info .. so valid! */
124 if (id->cyls == 0)
125 return 1;
126
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 /*
128 * The ATA spec tells large drives to return
129 * C/H/S = 16383/16/63 independent of their size.
130 * Some drives can be jumpered to use 15 heads instead of 16.
131 * Some drives can be jumpered to use 4092 cyls instead of 16383.
132 */
133 if ((id->cyls == 16383
134 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
135 id->sectors == 63 &&
136 (id->heads == 15 || id->heads == 16) &&
137 (id->lba_capacity >= 16383*63*id->heads))
138 return 1;
139
140 lba_sects = id->lba_capacity;
141 chs_sects = id->cyls * id->heads * id->sectors;
142
143 /* perform a rough sanity check on lba_sects: within 10% is OK */
144 if ((lba_sects - chs_sects) < chs_sects/10)
145 return 1;
146
147 /* some drives have the word order reversed */
148 head = ((lba_sects >> 16) & 0xffff);
149 tail = (lba_sects & 0xffff);
150 lba_sects = (head | (tail << 16));
151 if ((lba_sects - chs_sects) < chs_sects/10) {
152 id->lba_capacity = lba_sects;
153 return 1; /* lba_capacity is (now) good */
154 }
155
156 return 0; /* lba_capacity value may be bad */
157}
158
159/*
160 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
161 * using LBA if supported, or CHS otherwise, to address sectors.
162 */
163static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
164{
165 ide_hwif_t *hwif = HWIF(drive);
166 unsigned int dma = drive->using_dma;
167 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
168 task_ioreg_t command = WIN_NOP;
169 ata_nsector_t nsectors;
170
171 nsectors.all = (u16) rq->nr_sectors;
172
173 if (hwif->no_lba48_dma && lba48 && dma) {
174 if (block + rq->nr_sectors > 1ULL << 28)
175 dma = 0;
176 else
177 lba48 = 0;
178 }
179
180 if (!dma) {
181 ide_init_sg_cmd(drive, rq);
182 ide_map_sg(drive, rq);
183 }
184
185 if (IDE_CONTROL_REG)
186 hwif->OUTB(drive->ctl, IDE_CONTROL_REG);
187
188 /* FIXME: SELECT_MASK(drive, 0) ? */
189
190 if (drive->select.b.lba) {
191 if (lba48) {
192 task_ioreg_t tasklets[10];
193
Michael Richardsonc2f83112006-02-07 12:58:33 -0800194 pr_debug("%s: LBA=0x%012llx\n", drive->name,
195 (unsigned long long)block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
197 tasklets[0] = 0;
198 tasklets[1] = 0;
199 tasklets[2] = nsectors.b.low;
200 tasklets[3] = nsectors.b.high;
201 tasklets[4] = (task_ioreg_t) block;
202 tasklets[5] = (task_ioreg_t) (block>>8);
203 tasklets[6] = (task_ioreg_t) (block>>16);
204 tasklets[7] = (task_ioreg_t) (block>>24);
205 if (sizeof(block) == 4) {
206 tasklets[8] = (task_ioreg_t) 0;
207 tasklets[9] = (task_ioreg_t) 0;
208 } else {
209 tasklets[8] = (task_ioreg_t)((u64)block >> 32);
210 tasklets[9] = (task_ioreg_t)((u64)block >> 40);
211 }
212#ifdef DEBUG
213 printk("%s: 0x%02x%02x 0x%02x%02x%02x%02x%02x%02x\n",
214 drive->name, tasklets[3], tasklets[2],
215 tasklets[9], tasklets[8], tasklets[7],
216 tasklets[6], tasklets[5], tasklets[4]);
217#endif
218 hwif->OUTB(tasklets[1], IDE_FEATURE_REG);
219 hwif->OUTB(tasklets[3], IDE_NSECTOR_REG);
220 hwif->OUTB(tasklets[7], IDE_SECTOR_REG);
221 hwif->OUTB(tasklets[8], IDE_LCYL_REG);
222 hwif->OUTB(tasklets[9], IDE_HCYL_REG);
223
224 hwif->OUTB(tasklets[0], IDE_FEATURE_REG);
225 hwif->OUTB(tasklets[2], IDE_NSECTOR_REG);
226 hwif->OUTB(tasklets[4], IDE_SECTOR_REG);
227 hwif->OUTB(tasklets[5], IDE_LCYL_REG);
228 hwif->OUTB(tasklets[6], IDE_HCYL_REG);
229 hwif->OUTB(0x00|drive->select.all,IDE_SELECT_REG);
230 } else {
231 hwif->OUTB(0x00, IDE_FEATURE_REG);
232 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
233 hwif->OUTB(block, IDE_SECTOR_REG);
234 hwif->OUTB(block>>=8, IDE_LCYL_REG);
235 hwif->OUTB(block>>=8, IDE_HCYL_REG);
236 hwif->OUTB(((block>>8)&0x0f)|drive->select.all,IDE_SELECT_REG);
237 }
238 } else {
239 unsigned int sect,head,cyl,track;
240 track = (int)block / drive->sect;
241 sect = (int)block % drive->sect + 1;
242 hwif->OUTB(sect, IDE_SECTOR_REG);
243 head = track % drive->head;
244 cyl = track / drive->head;
245
246 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
247
248 hwif->OUTB(0x00, IDE_FEATURE_REG);
249 hwif->OUTB(nsectors.b.low, IDE_NSECTOR_REG);
250 hwif->OUTB(cyl, IDE_LCYL_REG);
251 hwif->OUTB(cyl>>8, IDE_HCYL_REG);
252 hwif->OUTB(head|drive->select.all,IDE_SELECT_REG);
253 }
254
255 if (dma) {
256 if (!hwif->dma_setup(drive)) {
257 if (rq_data_dir(rq)) {
258 command = lba48 ? WIN_WRITEDMA_EXT : WIN_WRITEDMA;
259 if (drive->vdma)
260 command = lba48 ? WIN_WRITE_EXT: WIN_WRITE;
261 } else {
262 command = lba48 ? WIN_READDMA_EXT : WIN_READDMA;
263 if (drive->vdma)
264 command = lba48 ? WIN_READ_EXT: WIN_READ;
265 }
266 hwif->dma_exec_cmd(drive, command);
267 hwif->dma_start(drive);
268 return ide_started;
269 }
270 /* fallback to PIO */
271 ide_init_sg_cmd(drive, rq);
272 }
273
274 if (rq_data_dir(rq) == READ) {
275
276 if (drive->mult_count) {
277 hwif->data_phase = TASKFILE_MULTI_IN;
278 command = lba48 ? WIN_MULTREAD_EXT : WIN_MULTREAD;
279 } else {
280 hwif->data_phase = TASKFILE_IN;
281 command = lba48 ? WIN_READ_EXT : WIN_READ;
282 }
283
284 ide_execute_command(drive, command, &task_in_intr, WAIT_CMD, NULL);
285 return ide_started;
286 } else {
287 if (drive->mult_count) {
288 hwif->data_phase = TASKFILE_MULTI_OUT;
289 command = lba48 ? WIN_MULTWRITE_EXT : WIN_MULTWRITE;
290 } else {
291 hwif->data_phase = TASKFILE_OUT;
292 command = lba48 ? WIN_WRITE_EXT : WIN_WRITE;
293 }
294
295 /* FIXME: ->OUTBSYNC ? */
296 hwif->OUTB(command, IDE_COMMAND_REG);
297
298 return pre_task_out_intr(drive, rq);
299 }
300}
301
302/*
303 * 268435455 == 137439 MB or 28bit limit
304 * 320173056 == 163929 MB or 48bit addressing
305 * 1073741822 == 549756 MB or 48bit addressing fake drive
306 */
307
308static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
309{
310 ide_hwif_t *hwif = HWIF(drive);
311
312 BUG_ON(drive->blocked);
313
314 if (!blk_fs_request(rq)) {
315 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
316 ide_end_request(drive, 0, 0);
317 return ide_stopped;
318 }
319
Richard Purdie2bfb6462006-03-31 02:31:16 -0800320 ledtrig_ide_activity();
321
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
323 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
Michael Richardsonc2f83112006-02-07 12:58:33 -0800324 (unsigned long long)block, rq->nr_sectors,
325 (unsigned long)rq->buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
327 if (hwif->rw_disk)
328 hwif->rw_disk(drive, rq);
329
330 return __ide_do_rw_disk(drive, rq, block);
331}
332
333/*
334 * Queries for true maximum capacity of the drive.
335 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
336 */
337static unsigned long idedisk_read_native_max_address(ide_drive_t *drive)
338{
339 ide_task_t args;
340 unsigned long addr = 0;
341
342 /* Create IDE/ATA command request structure */
343 memset(&args, 0, sizeof(ide_task_t));
344 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
345 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX;
346 args.command_type = IDE_DRIVE_TASK_NO_DATA;
347 args.handler = &task_no_data_intr;
348 /* submit command request */
349 ide_raw_taskfile(drive, &args, NULL);
350
351 /* if OK, compute maximum address value */
352 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
353 addr = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
354 | ((args.tfRegister[ IDE_HCYL_OFFSET] ) << 16)
355 | ((args.tfRegister[ IDE_LCYL_OFFSET] ) << 8)
356 | ((args.tfRegister[IDE_SECTOR_OFFSET] ));
357 addr++; /* since the return value is (maxlba - 1), we add 1 */
358 }
359 return addr;
360}
361
362static unsigned long long idedisk_read_native_max_address_ext(ide_drive_t *drive)
363{
364 ide_task_t args;
365 unsigned long long addr = 0;
366
367 /* Create IDE/ATA command request structure */
368 memset(&args, 0, sizeof(ide_task_t));
369
370 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
371 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_READ_NATIVE_MAX_EXT;
372 args.command_type = IDE_DRIVE_TASK_NO_DATA;
373 args.handler = &task_no_data_intr;
374 /* submit command request */
375 ide_raw_taskfile(drive, &args, NULL);
376
377 /* if OK, compute maximum address value */
378 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
379 u32 high = (args.hobRegister[IDE_HCYL_OFFSET] << 16) |
380 (args.hobRegister[IDE_LCYL_OFFSET] << 8) |
381 args.hobRegister[IDE_SECTOR_OFFSET];
382 u32 low = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
383 ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
384 (args.tfRegister[IDE_SECTOR_OFFSET]);
385 addr = ((__u64)high << 24) | low;
386 addr++; /* since the return value is (maxlba - 1), we add 1 */
387 }
388 return addr;
389}
390
391/*
392 * Sets maximum virtual LBA address of the drive.
393 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
394 */
395static unsigned long idedisk_set_max_address(ide_drive_t *drive, unsigned long addr_req)
396{
397 ide_task_t args;
398 unsigned long addr_set = 0;
399
400 addr_req--;
401 /* Create IDE/ATA command request structure */
402 memset(&args, 0, sizeof(ide_task_t));
403 args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >> 0) & 0xff);
404 args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >> 8) & 0xff);
405 args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >> 16) & 0xff);
406 args.tfRegister[IDE_SELECT_OFFSET] = ((addr_req >> 24) & 0x0f) | 0x40;
407 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX;
408 args.command_type = IDE_DRIVE_TASK_NO_DATA;
409 args.handler = &task_no_data_intr;
410 /* submit command request */
411 ide_raw_taskfile(drive, &args, NULL);
412 /* if OK, read new maximum address value */
413 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
414 addr_set = ((args.tfRegister[IDE_SELECT_OFFSET] & 0x0f) << 24)
415 | ((args.tfRegister[ IDE_HCYL_OFFSET] ) << 16)
416 | ((args.tfRegister[ IDE_LCYL_OFFSET] ) << 8)
417 | ((args.tfRegister[IDE_SECTOR_OFFSET] ));
418 addr_set++;
419 }
420 return addr_set;
421}
422
423static unsigned long long idedisk_set_max_address_ext(ide_drive_t *drive, unsigned long long addr_req)
424{
425 ide_task_t args;
426 unsigned long long addr_set = 0;
427
428 addr_req--;
429 /* Create IDE/ATA command request structure */
430 memset(&args, 0, sizeof(ide_task_t));
431 args.tfRegister[IDE_SECTOR_OFFSET] = ((addr_req >> 0) & 0xff);
432 args.tfRegister[IDE_LCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
433 args.tfRegister[IDE_HCYL_OFFSET] = ((addr_req >>= 8) & 0xff);
434 args.tfRegister[IDE_SELECT_OFFSET] = 0x40;
435 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SET_MAX_EXT;
436 args.hobRegister[IDE_SECTOR_OFFSET] = (addr_req >>= 8) & 0xff;
437 args.hobRegister[IDE_LCYL_OFFSET] = (addr_req >>= 8) & 0xff;
438 args.hobRegister[IDE_HCYL_OFFSET] = (addr_req >>= 8) & 0xff;
439 args.hobRegister[IDE_SELECT_OFFSET] = 0x40;
440 args.hobRegister[IDE_CONTROL_OFFSET_HOB]= (drive->ctl|0x80);
441 args.command_type = IDE_DRIVE_TASK_NO_DATA;
442 args.handler = &task_no_data_intr;
443 /* submit command request */
444 ide_raw_taskfile(drive, &args, NULL);
445 /* if OK, compute maximum address value */
446 if ((args.tfRegister[IDE_STATUS_OFFSET] & 0x01) == 0) {
447 u32 high = (args.hobRegister[IDE_HCYL_OFFSET] << 16) |
448 (args.hobRegister[IDE_LCYL_OFFSET] << 8) |
449 args.hobRegister[IDE_SECTOR_OFFSET];
450 u32 low = ((args.tfRegister[IDE_HCYL_OFFSET])<<16) |
451 ((args.tfRegister[IDE_LCYL_OFFSET])<<8) |
452 (args.tfRegister[IDE_SECTOR_OFFSET]);
453 addr_set = ((__u64)high << 24) | low;
454 addr_set++;
455 }
456 return addr_set;
457}
458
459static unsigned long long sectors_to_MB(unsigned long long n)
460{
461 n <<= 9; /* make it bytes */
462 do_div(n, 1000000); /* make it MB */
463 return n;
464}
465
466/*
467 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
468 * so on non-buggy drives we need test only one.
469 * However, we should also check whether these fields are valid.
470 */
471static inline int idedisk_supports_hpa(const struct hd_driveid *id)
472{
473 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
474}
475
476/*
477 * The same here.
478 */
479static inline int idedisk_supports_lba48(const struct hd_driveid *id)
480{
481 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
482 && id->lba_capacity_2;
483}
484
Arjan van de Ven858119e2006-01-14 13:20:43 -0800485static void idedisk_check_hpa(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486{
487 unsigned long long capacity, set_max;
488 int lba48 = idedisk_supports_lba48(drive->id);
489
490 capacity = drive->capacity64;
491 if (lba48)
492 set_max = idedisk_read_native_max_address_ext(drive);
493 else
494 set_max = idedisk_read_native_max_address(drive);
495
496 if (set_max <= capacity)
497 return;
498
499 printk(KERN_INFO "%s: Host Protected Area detected.\n"
500 "\tcurrent capacity is %llu sectors (%llu MB)\n"
501 "\tnative capacity is %llu sectors (%llu MB)\n",
502 drive->name,
503 capacity, sectors_to_MB(capacity),
504 set_max, sectors_to_MB(set_max));
505
506 if (lba48)
507 set_max = idedisk_set_max_address_ext(drive, set_max);
508 else
509 set_max = idedisk_set_max_address(drive, set_max);
510 if (set_max) {
511 drive->capacity64 = set_max;
512 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
513 drive->name);
514 }
515}
516
517/*
518 * Compute drive->capacity, the full capacity of the drive
519 * Called with drive->id != NULL.
520 *
521 * To compute capacity, this uses either of
522 *
523 * 1. CHS value set by user (whatever user sets will be trusted)
524 * 2. LBA value from target drive (require new ATA feature)
525 * 3. LBA value from system BIOS (new one is OK, old one may break)
526 * 4. CHS value from system BIOS (traditional style)
527 *
528 * in above order (i.e., if value of higher priority is available,
529 * reset will be ignored).
530 */
531static void init_idedisk_capacity (ide_drive_t *drive)
532{
533 struct hd_driveid *id = drive->id;
534 /*
535 * If this drive supports the Host Protected Area feature set,
536 * then we may need to change our opinion about the drive's capacity.
537 */
538 int hpa = idedisk_supports_hpa(id);
539
540 if (idedisk_supports_lba48(id)) {
541 /* drive speaks 48-bit LBA */
542 drive->select.b.lba = 1;
543 drive->capacity64 = id->lba_capacity_2;
544 if (hpa)
545 idedisk_check_hpa(drive);
546 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
547 /* drive speaks 28-bit LBA */
548 drive->select.b.lba = 1;
549 drive->capacity64 = id->lba_capacity;
550 if (hpa)
551 idedisk_check_hpa(drive);
552 } else {
553 /* drive speaks boring old 28-bit CHS */
554 drive->capacity64 = drive->cyl * drive->head * drive->sect;
555 }
556}
557
558static sector_t idedisk_capacity (ide_drive_t *drive)
559{
560 return drive->capacity64 - drive->sect0;
561}
562
563#ifdef CONFIG_PROC_FS
564
565static int smart_enable(ide_drive_t *drive)
566{
567 ide_task_t args;
568
569 memset(&args, 0, sizeof(ide_task_t));
570 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_ENABLE;
571 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
572 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
573 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
574 args.command_type = IDE_DRIVE_TASK_NO_DATA;
575 args.handler = &task_no_data_intr;
576 return ide_raw_taskfile(drive, &args, NULL);
577}
578
579static int get_smart_values(ide_drive_t *drive, u8 *buf)
580{
581 ide_task_t args;
582
583 memset(&args, 0, sizeof(ide_task_t));
584 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_VALUES;
585 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
586 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
587 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
588 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
589 args.command_type = IDE_DRIVE_TASK_IN;
590 args.data_phase = TASKFILE_IN;
591 args.handler = &task_in_intr;
592 (void) smart_enable(drive);
593 return ide_raw_taskfile(drive, &args, buf);
594}
595
596static int get_smart_thresholds(ide_drive_t *drive, u8 *buf)
597{
598 ide_task_t args;
599 memset(&args, 0, sizeof(ide_task_t));
600 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_THRESHOLDS;
601 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
602 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
603 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
604 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
605 args.command_type = IDE_DRIVE_TASK_IN;
606 args.data_phase = TASKFILE_IN;
607 args.handler = &task_in_intr;
608 (void) smart_enable(drive);
609 return ide_raw_taskfile(drive, &args, buf);
610}
611
612static int proc_idedisk_read_cache
613 (char *page, char **start, off_t off, int count, int *eof, void *data)
614{
615 ide_drive_t *drive = (ide_drive_t *) data;
616 char *out = page;
617 int len;
618
619 if (drive->id_read)
620 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
621 else
622 len = sprintf(out,"(none)\n");
623 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
624}
625
626static int proc_idedisk_read_capacity
627 (char *page, char **start, off_t off, int count, int *eof, void *data)
628{
629 ide_drive_t*drive = (ide_drive_t *)data;
630 int len;
631
632 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
633 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
634}
635
636static int proc_idedisk_read_smart_thresholds
637 (char *page, char **start, off_t off, int count, int *eof, void *data)
638{
639 ide_drive_t *drive = (ide_drive_t *)data;
640 int len = 0, i = 0;
641
642 if (!get_smart_thresholds(drive, page)) {
643 unsigned short *val = (unsigned short *) page;
644 char *out = ((char *)val) + (SECTOR_WORDS * 4);
645 page = out;
646 do {
647 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
648 val += 1;
649 } while (i < (SECTOR_WORDS * 2));
650 len = out - page;
651 }
652 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
653}
654
655static int proc_idedisk_read_smart_values
656 (char *page, char **start, off_t off, int count, int *eof, void *data)
657{
658 ide_drive_t *drive = (ide_drive_t *)data;
659 int len = 0, i = 0;
660
661 if (!get_smart_values(drive, page)) {
662 unsigned short *val = (unsigned short *) page;
663 char *out = ((char *)val) + (SECTOR_WORDS * 4);
664 page = out;
665 do {
666 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
667 val += 1;
668 } while (i < (SECTOR_WORDS * 2));
669 len = out - page;
670 }
671 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
672}
673
674static ide_proc_entry_t idedisk_proc[] = {
675 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
676 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
677 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
678 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
679 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
680 { NULL, 0, NULL, NULL }
681};
682
683#else
684
685#define idedisk_proc NULL
686
687#endif /* CONFIG_PROC_FS */
688
Tejun Heo3e087b52006-01-06 09:57:31 +0100689static void idedisk_prepare_flush(request_queue_t *q, struct request *rq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690{
691 ide_drive_t *drive = q->queuedata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
693 memset(rq->cmd, 0, sizeof(rq->cmd));
694
695 if (ide_id_has_flush_cache_ext(drive->id) &&
696 (drive->capacity64 >= (1UL << 28)))
697 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
698 else
699 rq->cmd[0] = WIN_FLUSH_CACHE;
700
701
Jens Axboe4aff5e22006-08-10 08:44:47 +0200702 rq->cmd_type = REQ_TYPE_ATA_TASK;
703 rq->cmd_flags |= REQ_SOFTBARRIER;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 rq->buffer = rq->cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705}
706
707static int idedisk_issue_flush(request_queue_t *q, struct gendisk *disk,
708 sector_t *error_sector)
709{
710 ide_drive_t *drive = q->queuedata;
711 struct request *rq;
712 int ret;
713
714 if (!drive->wcache)
715 return 0;
716
717 rq = blk_get_request(q, WRITE, __GFP_WAIT);
718
719 idedisk_prepare_flush(q, rq);
720
James Bottomley 994ca9a2005-06-20 14:11:09 +0200721 ret = blk_execute_rq(q, disk, rq, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
723 /*
724 * if we failed and caller wants error offset, get it
725 */
726 if (ret && error_sector)
727 *error_sector = ide_get_error_location(drive, rq->cmd);
728
729 blk_put_request(rq);
730 return ret;
731}
732
733/*
734 * This is tightly woven into the driver->do_special can not touch.
735 * DON'T do it again until a total personality rewrite is committed.
736 */
737static int set_multcount(ide_drive_t *drive, int arg)
738{
739 struct request rq;
740
741 if (drive->special.b.set_multmode)
742 return -EBUSY;
743 ide_init_drive_cmd (&rq);
Jens Axboe4aff5e22006-08-10 08:44:47 +0200744 rq.cmd_type = REQ_TYPE_ATA_CMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 drive->mult_req = arg;
746 drive->special.b.set_multmode = 1;
747 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
748 return (drive->mult_count == arg) ? 0 : -EIO;
749}
750
751static int set_nowerr(ide_drive_t *drive, int arg)
752{
753 if (ide_spin_wait_hwgroup(drive))
754 return -EBUSY;
755 drive->nowerr = arg;
756 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
757 spin_unlock_irq(&ide_lock);
758 return 0;
759}
760
Tejun Heo3e087b52006-01-06 09:57:31 +0100761static void update_ordered(ide_drive_t *drive)
762{
763 struct hd_driveid *id = drive->id;
764 unsigned ordered = QUEUE_ORDERED_NONE;
765 prepare_flush_fn *prep_fn = NULL;
766 issue_flush_fn *issue_fn = NULL;
767
768 if (drive->wcache) {
769 unsigned long long capacity;
770 int barrier;
771 /*
772 * We must avoid issuing commands a drive does not
773 * understand or we may crash it. We check flush cache
774 * is supported. We also check we have the LBA48 flush
775 * cache if the drive capacity is too large. By this
776 * time we have trimmed the drive capacity if LBA48 is
777 * not available so we don't need to recheck that.
778 */
779 capacity = idedisk_capacity(drive);
Jens Axboe36193482006-07-28 08:54:59 +0200780 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
Tejun Heo3e087b52006-01-06 09:57:31 +0100781 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
782 ide_id_has_flush_cache_ext(id));
783
784 printk(KERN_INFO "%s: cache flushes %ssupported\n",
Jean Delvaref7ad8362006-02-03 03:04:57 -0800785 drive->name, barrier ? "" : "not ");
Tejun Heo3e087b52006-01-06 09:57:31 +0100786
787 if (barrier) {
788 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
789 prep_fn = idedisk_prepare_flush;
790 issue_fn = idedisk_issue_flush;
791 }
792 } else
793 ordered = QUEUE_ORDERED_DRAIN;
794
795 blk_queue_ordered(drive->queue, ordered, prep_fn);
796 blk_queue_issue_flush_fn(drive->queue, issue_fn);
797}
798
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799static int write_cache(ide_drive_t *drive, int arg)
800{
801 ide_task_t args;
Tejun Heo3e087b52006-01-06 09:57:31 +0100802 int err = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803
Tejun Heo3e087b52006-01-06 09:57:31 +0100804 if (ide_id_has_flush_cache(drive->id)) {
805 memset(&args, 0, sizeof(ide_task_t));
806 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
Tejun Heo3e087b52006-01-06 09:57:31 +0100808 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
809 args.command_type = IDE_DRIVE_TASK_NO_DATA;
810 args.handler = &task_no_data_intr;
811 err = ide_raw_taskfile(drive, &args, NULL);
812 if (err == 0)
813 drive->wcache = arg;
814 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815
Tejun Heo3e087b52006-01-06 09:57:31 +0100816 update_ordered(drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Tejun Heo3e087b52006-01-06 09:57:31 +0100818 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819}
820
821static int do_idedisk_flushcache (ide_drive_t *drive)
822{
823 ide_task_t args;
824
825 memset(&args, 0, sizeof(ide_task_t));
826 if (ide_id_has_flush_cache_ext(drive->id))
827 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE_EXT;
828 else
829 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE;
830 args.command_type = IDE_DRIVE_TASK_NO_DATA;
831 args.handler = &task_no_data_intr;
832 return ide_raw_taskfile(drive, &args, NULL);
833}
834
835static int set_acoustic (ide_drive_t *drive, int arg)
836{
837 ide_task_t args;
838
839 memset(&args, 0, sizeof(ide_task_t));
840 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ? SETFEATURES_EN_AAM :
841 SETFEATURES_DIS_AAM;
842 args.tfRegister[IDE_NSECTOR_OFFSET] = arg;
843 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
844 args.command_type = IDE_DRIVE_TASK_NO_DATA;
845 args.handler = &task_no_data_intr;
846 ide_raw_taskfile(drive, &args, NULL);
847 drive->acoustic = arg;
848 return 0;
849}
850
851/*
852 * drive->addressing:
853 * 0: 28-bit
854 * 1: 48-bit
855 * 2: 48-bit capable doing 28-bit
856 */
857static int set_lba_addressing(ide_drive_t *drive, int arg)
858{
859 drive->addressing = 0;
860
861 if (HWIF(drive)->no_lba48)
862 return 0;
863
864 if (!idedisk_supports_lba48(drive->id))
865 return -EIO;
866 drive->addressing = arg;
867 return 0;
868}
869
870static void idedisk_add_settings(ide_drive_t *drive)
871{
872 struct hd_driveid *id = drive->id;
873
874 ide_add_setting(drive, "bios_cyl", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
875 ide_add_setting(drive, "bios_head", SETTING_RW, -1, -1, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
876 ide_add_setting(drive, "bios_sect", SETTING_RW, -1, -1, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
877 ide_add_setting(drive, "address", SETTING_RW, HDIO_GET_ADDRESS, HDIO_SET_ADDRESS, TYPE_INTA, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
878 ide_add_setting(drive, "bswap", SETTING_READ, -1, -1, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
879 ide_add_setting(drive, "multcount", id ? SETTING_RW : SETTING_READ, HDIO_GET_MULTCOUNT, HDIO_SET_MULTCOUNT, TYPE_BYTE, 0, id ? id->max_multsect : 0, 1, 1, &drive->mult_count, set_multcount);
880 ide_add_setting(drive, "nowerr", SETTING_RW, HDIO_GET_NOWERR, HDIO_SET_NOWERR, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
881 ide_add_setting(drive, "lun", SETTING_RW, -1, -1, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
882 ide_add_setting(drive, "wcache", SETTING_RW, HDIO_GET_WCACHE, HDIO_SET_WCACHE, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
883 ide_add_setting(drive, "acoustic", SETTING_RW, HDIO_GET_ACOUSTIC, HDIO_SET_ACOUSTIC, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
884 ide_add_setting(drive, "failures", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
885 ide_add_setting(drive, "max_failures", SETTING_RW, -1, -1, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
886}
887
888static void idedisk_setup (ide_drive_t *drive)
889{
890 struct hd_driveid *id = drive->id;
891 unsigned long long capacity;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
893 idedisk_add_settings(drive);
894
895 if (drive->id_read == 0)
896 return;
897
Richard Purdie98109332006-02-03 03:04:55 -0800898 if (drive->removable) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 /*
900 * Removable disks (eg. SYQUEST); ignore 'WD' drives
901 */
902 if (id->model[0] != 'W' || id->model[1] != 'D') {
903 drive->doorlocking = 1;
904 }
905 }
906
907 (void)set_lba_addressing(drive, 1);
908
909 if (drive->addressing == 1) {
910 ide_hwif_t *hwif = HWIF(drive);
911 int max_s = 2048;
912
913 if (max_s > hwif->rqsize)
914 max_s = hwif->rqsize;
915
916 blk_queue_max_sectors(drive->queue, max_s);
917 }
918
919 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
920
921 /* calculate drive capacity, and select LBA if possible */
922 init_idedisk_capacity (drive);
923
924 /* limit drive capacity to 137GB if LBA48 cannot be used */
925 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
926 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
927 "%llu sectors (%llu MB)\n",
928 drive->name, (unsigned long long)drive->capacity64,
929 sectors_to_MB(drive->capacity64));
930 drive->capacity64 = 1ULL << 28;
931 }
932
933 if (drive->hwif->no_lba48_dma && drive->addressing) {
934 if (drive->capacity64 > 1ULL << 28) {
935 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
936 " be used for accessing sectors > %u\n",
937 drive->name, 1 << 28);
938 } else
939 drive->addressing = 0;
940 }
941
942 /*
943 * if possible, give fdisk access to more of the drive,
944 * by correcting bios_cyls:
945 */
946 capacity = idedisk_capacity (drive);
947 if (!drive->forced_geom) {
948
949 if (idedisk_supports_lba48(drive->id)) {
950 /* compatibility */
951 drive->bios_sect = 63;
952 drive->bios_head = 255;
953 }
954
955 if (drive->bios_sect && drive->bios_head) {
956 unsigned int cap0 = capacity; /* truncate to 32 bits */
957 unsigned int cylsz, cyl;
958
959 if (cap0 != capacity)
960 drive->bios_cyl = 65535;
961 else {
962 cylsz = drive->bios_sect * drive->bios_head;
963 cyl = cap0 / cylsz;
964 if (cyl > 65535)
965 cyl = 65535;
966 if (cyl > drive->bios_cyl)
967 drive->bios_cyl = cyl;
968 }
969 }
970 }
971 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
972 drive->name, capacity, sectors_to_MB(capacity));
973
974 /* Only print cache size when it was specified */
975 if (id->buf_size)
976 printk (" w/%dKiB Cache", id->buf_size/2);
977
978 printk(", CHS=%d/%d/%d",
979 drive->bios_cyl, drive->bios_head, drive->bios_sect);
980 if (drive->using_dma)
981 ide_dma_verbose(drive);
982 printk("\n");
983
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 /* write cache enabled? */
985 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
986 drive->wcache = 1;
987
988 write_cache(drive, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989}
990
991static void ide_cacheflush_p(ide_drive_t *drive)
992{
993 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
994 return;
995
996 if (do_idedisk_flushcache(drive))
997 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
998}
999
Russell King4031bbe2006-01-06 11:41:00 +00001000static void ide_disk_remove(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001{
1002 struct ide_disk_obj *idkp = drive->driver_data;
1003 struct gendisk *g = idkp->disk;
1004
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001005 ide_unregister_subdriver(drive, idkp->driver);
1006
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 del_gendisk(g);
1008
Bartlomiej Zolnierkiewiczd36fef62005-12-15 02:19:20 +01001009 ide_cacheflush_p(drive);
1010
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 ide_disk_put(idkp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012}
1013
1014static void ide_disk_release(struct kref *kref)
1015{
1016 struct ide_disk_obj *idkp = to_ide_disk(kref);
1017 ide_drive_t *drive = idkp->drive;
1018 struct gendisk *g = idkp->disk;
1019
1020 drive->driver_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 g->private_data = NULL;
1022 put_disk(g);
1023 kfree(idkp);
1024}
1025
Russell King4031bbe2006-01-06 11:41:00 +00001026static int ide_disk_probe(ide_drive_t *drive);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027
Russell King4031bbe2006-01-06 11:41:00 +00001028static void ide_device_shutdown(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030#ifdef CONFIG_ALPHA
1031 /* On Alpha, halt(8) doesn't actually turn the machine off,
1032 it puts you into the sort of firmware monitor. Typically,
1033 it's used to boot another kernel image, so it's not much
1034 different from reboot(8). Therefore, we don't need to
1035 spin down the disk in this case, especially since Alpha
1036 firmware doesn't handle disks in standby mode properly.
1037 On the other hand, it's reasonably safe to turn the power
1038 off when the shutdown process reaches the firmware prompt,
1039 as the firmware initialization takes rather long time -
1040 at least 10 seconds, which should be sufficient for
1041 the disk to expire its write cache. */
1042 if (system_state != SYSTEM_POWER_OFF) {
1043#else
1044 if (system_state == SYSTEM_RESTART) {
1045#endif
1046 ide_cacheflush_p(drive);
1047 return;
1048 }
1049
1050 printk("Shutdown: %s\n", drive->name);
Russell King4031bbe2006-01-06 11:41:00 +00001051 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052}
1053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054static ide_driver_t idedisk_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 .gen_driver = {
Laurent Riffard4ef3b8f2005-11-18 22:15:40 +01001056 .owner = THIS_MODULE,
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001057 .name = "ide-disk",
1058 .bus = &ide_bus_type,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 },
Russell King4031bbe2006-01-06 11:41:00 +00001060 .probe = ide_disk_probe,
1061 .remove = ide_disk_remove,
1062 .shutdown = ide_device_shutdown,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063 .version = IDEDISK_VERSION,
1064 .media = ide_disk,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 .supports_dsc_overlap = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 .do_request = ide_do_rw_disk,
1067 .end_request = ide_end_request,
1068 .error = __ide_error,
1069 .abort = __ide_abort,
1070 .proc = idedisk_proc,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071};
1072
1073static int idedisk_open(struct inode *inode, struct file *filp)
1074{
1075 struct gendisk *disk = inode->i_bdev->bd_disk;
1076 struct ide_disk_obj *idkp;
1077 ide_drive_t *drive;
1078
1079 if (!(idkp = ide_disk_get(disk)))
1080 return -ENXIO;
1081
1082 drive = idkp->drive;
1083
1084 drive->usage++;
1085 if (drive->removable && drive->usage == 1) {
1086 ide_task_t args;
1087 memset(&args, 0, sizeof(ide_task_t));
1088 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORLOCK;
1089 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1090 args.handler = &task_no_data_intr;
1091 check_disk_change(inode->i_bdev);
1092 /*
1093 * Ignore the return code from door_lock,
1094 * since the open() has already succeeded,
1095 * and the door_lock is irrelevant at this point.
1096 */
1097 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1098 drive->doorlocking = 0;
1099 }
1100 return 0;
1101}
1102
1103static int idedisk_release(struct inode *inode, struct file *filp)
1104{
1105 struct gendisk *disk = inode->i_bdev->bd_disk;
1106 struct ide_disk_obj *idkp = ide_disk_g(disk);
1107 ide_drive_t *drive = idkp->drive;
1108
1109 if (drive->usage == 1)
1110 ide_cacheflush_p(drive);
1111 if (drive->removable && drive->usage == 1) {
1112 ide_task_t args;
1113 memset(&args, 0, sizeof(ide_task_t));
1114 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORUNLOCK;
1115 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1116 args.handler = &task_no_data_intr;
1117 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1118 drive->doorlocking = 0;
1119 }
1120 drive->usage--;
1121
1122 ide_disk_put(idkp);
1123
1124 return 0;
1125}
1126
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08001127static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1128{
1129 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1130 ide_drive_t *drive = idkp->drive;
1131
1132 geo->heads = drive->bios_head;
1133 geo->sectors = drive->bios_sect;
1134 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1135 return 0;
1136}
1137
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138static int idedisk_ioctl(struct inode *inode, struct file *file,
1139 unsigned int cmd, unsigned long arg)
1140{
1141 struct block_device *bdev = inode->i_bdev;
1142 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1143 return generic_ide_ioctl(idkp->drive, file, bdev, cmd, arg);
1144}
1145
1146static int idedisk_media_changed(struct gendisk *disk)
1147{
1148 struct ide_disk_obj *idkp = ide_disk_g(disk);
1149 ide_drive_t *drive = idkp->drive;
1150
1151 /* do not scan partitions twice if this is a removable device */
1152 if (drive->attach) {
1153 drive->attach = 0;
1154 return 0;
1155 }
1156 /* if removable, always assume it was changed */
1157 return drive->removable;
1158}
1159
1160static int idedisk_revalidate_disk(struct gendisk *disk)
1161{
1162 struct ide_disk_obj *idkp = ide_disk_g(disk);
1163 set_capacity(disk, idedisk_capacity(idkp->drive));
1164 return 0;
1165}
1166
1167static struct block_device_operations idedisk_ops = {
1168 .owner = THIS_MODULE,
1169 .open = idedisk_open,
1170 .release = idedisk_release,
1171 .ioctl = idedisk_ioctl,
Christoph Hellwiga885c8c2006-01-08 01:02:50 -08001172 .getgeo = idedisk_getgeo,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 .media_changed = idedisk_media_changed,
1174 .revalidate_disk= idedisk_revalidate_disk
1175};
1176
1177MODULE_DESCRIPTION("ATA DISK Driver");
1178
Russell King4031bbe2006-01-06 11:41:00 +00001179static int ide_disk_probe(ide_drive_t *drive)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180{
1181 struct ide_disk_obj *idkp;
1182 struct gendisk *g;
1183
1184 /* strstr("foo", "") is non-NULL */
1185 if (!strstr("ide-disk", drive->driver_req))
1186 goto failed;
1187 if (!drive->present)
1188 goto failed;
1189 if (drive->media != ide_disk)
1190 goto failed;
1191
Deepak Saxenaf5e3c2f2005-11-07 01:01:25 -08001192 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 if (!idkp)
1194 goto failed;
1195
Christoph Lameter19460892005-06-23 00:08:19 -07001196 g = alloc_disk_node(1 << PARTN_BITS,
Christoph Lameter86b37862005-08-09 19:59:21 -07001197 hwif_to_node(drive->hwif));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 if (!g)
1199 goto out_free_idkp;
1200
1201 ide_init_disk(g, drive);
1202
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001203 ide_register_subdriver(drive, &idedisk_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 kref_init(&idkp->kref);
1206
1207 idkp->drive = drive;
1208 idkp->driver = &idedisk_driver;
1209 idkp->disk = g;
1210
1211 g->private_data = &idkp->driver;
1212
1213 drive->driver_data = idkp;
1214
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 idedisk_setup(drive);
1216 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1217 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1218 drive->name, drive->head);
1219 drive->attach = 0;
1220 } else
1221 drive->attach = 1;
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001222
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 g->minors = 1 << PARTN_BITS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 g->driverfs_dev = &drive->gendev;
1225 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1226 set_capacity(g, idedisk_capacity(drive));
1227 g->fops = &idedisk_ops;
1228 add_disk(g);
1229 return 0;
1230
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231out_free_idkp:
1232 kfree(idkp);
1233failed:
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001234 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235}
1236
1237static void __exit idedisk_exit (void)
1238{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001239 driver_unregister(&idedisk_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240}
1241
Bartlomiej Zolnierkiewicz17514e82005-11-19 22:24:35 +01001242static int __init idedisk_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243{
Bartlomiej Zolnierkiewicz8604aff2005-05-26 14:55:34 +02001244 return driver_register(&idedisk_driver.gen_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245}
1246
Kay Sievers263756e2005-12-12 18:03:44 +01001247MODULE_ALIAS("ide:*m-disk*");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248module_init(idedisk_init);
1249module_exit(idedisk_exit);
1250MODULE_LICENSE("GPL");