?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Start split out of common open firmware code
[usb.git] / drivers / ide / ide-disk.c
blobb1304a7f3e0acfea5bb2ab900a0f0f1ab75e0169
1 /*
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
40 * Version 1.17 do flush on standby, do flush on ATA < ATA6
41 * fix wcache setup.
42 */
43
44 #define IDEDISK_VERSION "1.18"
45
46 //#define DEBUG
47
48 #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>
60 #include <linux/mutex.h>
61 #include <linux/leds.h>
62
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
73 struct ide_disk_obj {
74 ide_drive_t *drive;
75 ide_driver_t *driver;
76 struct gendisk *disk;
77 struct kref kref;
78 unsigned int openers; /* protected by BKL for now */
79 };
80
81 static DEFINE_MUTEX(idedisk_ref_mutex);
82
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
88 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
89 {
90 struct ide_disk_obj *idkp = NULL;
91
92 mutex_lock(&idedisk_ref_mutex);
93 idkp = ide_disk_g(disk);
94 if (idkp)
95 kref_get(&idkp->kref);
96 mutex_unlock(&idedisk_ref_mutex);
97 return idkp;
98 }
99
100 static void ide_disk_release(struct kref *);
101
102 static void ide_disk_put(struct ide_disk_obj *idkp)
103 {
104 mutex_lock(&idedisk_ref_mutex);
105 kref_put(&idkp->kref, ide_disk_release);
106 mutex_unlock(&idedisk_ref_mutex);
107 }
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 */
118 static int lba_capacity_is_ok (struct hd_driveid *id)
119 {
120 unsigned long lba_sects, chs_sects, head, tail;
121
122 /* No non-LBA info .. so valid! */
123 if (id->cyls == 0)
124 return 1;
125
126 /*
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 */
162 static 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
193 pr_debug("%s: LBA=0x%012llx\n", drive->name,
194 (unsigned long long)block);
195
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
307 static 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
319 ledtrig_ide_activity();
320
321 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
322 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
323 (unsigned long long)block, rq->nr_sectors,
324 (unsigned long)rq->buffer);
325
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 */
336 static 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
361 static 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 */
394 static 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
422 static 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
458 static 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 */
470 static 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 */
478 static 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
484 static void idedisk_check_hpa(ide_drive_t *drive)
485 {
486 unsigned long long capacity, set_max;
487 int lba48 = idedisk_supports_lba48(drive->id);
488
489 capacity = drive->capacity64;
490 if (lba48)
491 set_max = idedisk_read_native_max_address_ext(drive);
492 else
493 set_max = idedisk_read_native_max_address(drive);
494
495 if (set_max <= capacity)
496 return;
497
498 printk(KERN_INFO "%s: Host Protected Area detected.\n"
499 "\tcurrent capacity is %llu sectors (%llu MB)\n"
500 "\tnative capacity is %llu sectors (%llu MB)\n",
501 drive->name,
502 capacity, sectors_to_MB(capacity),
503 set_max, sectors_to_MB(set_max));
504
505 if (lba48)
506 set_max = idedisk_set_max_address_ext(drive, set_max);
507 else
508 set_max = idedisk_set_max_address(drive, set_max);
509 if (set_max) {
510 drive->capacity64 = set_max;
511 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
512 drive->name);
513 }
514 }
515
516 /*
517 * Compute drive->capacity, the full capacity of the drive
518 * Called with drive->id != NULL.
519 *
520 * To compute capacity, this uses either of
521 *
522 * 1. CHS value set by user (whatever user sets will be trusted)
523 * 2. LBA value from target drive (require new ATA feature)
524 * 3. LBA value from system BIOS (new one is OK, old one may break)
525 * 4. CHS value from system BIOS (traditional style)
526 *
527 * in above order (i.e., if value of higher priority is available,
528 * reset will be ignored).
529 */
530 static void init_idedisk_capacity (ide_drive_t *drive)
531 {
532 struct hd_driveid *id = drive->id;
533 /*
534 * If this drive supports the Host Protected Area feature set,
535 * then we may need to change our opinion about the drive's capacity.
536 */
537 int hpa = idedisk_supports_hpa(id);
538
539 if (idedisk_supports_lba48(id)) {
540 /* drive speaks 48-bit LBA */
541 drive->select.b.lba = 1;
542 drive->capacity64 = id->lba_capacity_2;
543 if (hpa)
544 idedisk_check_hpa(drive);
545 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
546 /* drive speaks 28-bit LBA */
547 drive->select.b.lba = 1;
548 drive->capacity64 = id->lba_capacity;
549 if (hpa)
550 idedisk_check_hpa(drive);
551 } else {
552 /* drive speaks boring old 28-bit CHS */
553 drive->capacity64 = drive->cyl * drive->head * drive->sect;
554 }
555 }
556
557 static sector_t idedisk_capacity (ide_drive_t *drive)
558 {
559 return drive->capacity64 - drive->sect0;
560 }
561
562 #ifdef CONFIG_IDE_PROC_FS
563 static int smart_enable(ide_drive_t *drive)
564 {
565 ide_task_t args;
566
567 memset(&args, 0, sizeof(ide_task_t));
568 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_ENABLE;
569 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
570 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
571 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
572 args.command_type = IDE_DRIVE_TASK_NO_DATA;
573 args.handler = &task_no_data_intr;
574 return ide_raw_taskfile(drive, &args, NULL);
575 }
576
577 static int get_smart_values(ide_drive_t *drive, u8 *buf)
578 {
579 ide_task_t args;
580
581 memset(&args, 0, sizeof(ide_task_t));
582 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_VALUES;
583 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
584 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
585 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
586 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
587 args.command_type = IDE_DRIVE_TASK_IN;
588 args.data_phase = TASKFILE_IN;
589 args.handler = &task_in_intr;
590 (void) smart_enable(drive);
591 return ide_raw_taskfile(drive, &args, buf);
592 }
593
594 static int get_smart_thresholds(ide_drive_t *drive, u8 *buf)
595 {
596 ide_task_t args;
597 memset(&args, 0, sizeof(ide_task_t));
598 args.tfRegister[IDE_FEATURE_OFFSET] = SMART_READ_THRESHOLDS;
599 args.tfRegister[IDE_NSECTOR_OFFSET] = 0x01;
600 args.tfRegister[IDE_LCYL_OFFSET] = SMART_LCYL_PASS;
601 args.tfRegister[IDE_HCYL_OFFSET] = SMART_HCYL_PASS;
602 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SMART;
603 args.command_type = IDE_DRIVE_TASK_IN;
604 args.data_phase = TASKFILE_IN;
605 args.handler = &task_in_intr;
606 (void) smart_enable(drive);
607 return ide_raw_taskfile(drive, &args, buf);
608 }
609
610 static int proc_idedisk_read_cache
611 (char *page, char **start, off_t off, int count, int *eof, void *data)
612 {
613 ide_drive_t *drive = (ide_drive_t *) data;
614 char *out = page;
615 int len;
616
617 if (drive->id_read)
618 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
619 else
620 len = sprintf(out,"(none)\n");
621 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
622 }
623
624 static int proc_idedisk_read_capacity
625 (char *page, char **start, off_t off, int count, int *eof, void *data)
626 {
627 ide_drive_t*drive = (ide_drive_t *)data;
628 int len;
629
630 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
631 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
632 }
633
634 static int proc_idedisk_read_smart_thresholds
635 (char *page, char **start, off_t off, int count, int *eof, void *data)
636 {
637 ide_drive_t *drive = (ide_drive_t *)data;
638 int len = 0, i = 0;
639
640 if (!get_smart_thresholds(drive, page)) {
641 unsigned short *val = (unsigned short *) page;
642 char *out = ((char *)val) + (SECTOR_WORDS * 4);
643 page = out;
644 do {
645 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
646 val += 1;
647 } while (i < (SECTOR_WORDS * 2));
648 len = out - page;
649 }
650 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
651 }
652
653 static int proc_idedisk_read_smart_values
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_values(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
672 static ide_proc_entry_t idedisk_proc[] = {
673 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
674 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
675 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
676 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
677 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
678 { NULL, 0, NULL, NULL }
679 };
680 #endif /* CONFIG_IDE_PROC_FS */
681
682 static void idedisk_prepare_flush(request_queue_t *q, struct request *rq)
683 {
684 ide_drive_t *drive = q->queuedata;
685
686 memset(rq->cmd, 0, sizeof(rq->cmd));
687
688 if (ide_id_has_flush_cache_ext(drive->id) &&
689 (drive->capacity64 >= (1UL << 28)))
690 rq->cmd[0] = WIN_FLUSH_CACHE_EXT;
691 else
692 rq->cmd[0] = WIN_FLUSH_CACHE;
693
694
695 rq->cmd_type = REQ_TYPE_ATA_TASK;
696 rq->cmd_flags |= REQ_SOFTBARRIER;
697 rq->buffer = rq->cmd;
698 }
699
700 static int idedisk_issue_flush(request_queue_t *q, struct gendisk *disk,
701 sector_t *error_sector)
702 {
703 ide_drive_t *drive = q->queuedata;
704 struct request *rq;
705 int ret;
706
707 if (!drive->wcache)
708 return 0;
709
710 rq = blk_get_request(q, WRITE, __GFP_WAIT);
711
712 idedisk_prepare_flush(q, rq);
713
714 ret = blk_execute_rq(q, disk, rq, 0);
715
716 /*
717 * if we failed and caller wants error offset, get it
718 */
719 if (ret && error_sector)
720 *error_sector = ide_get_error_location(drive, rq->cmd);
721
722 blk_put_request(rq);
723 return ret;
724 }
725
726 /*
727 * This is tightly woven into the driver->do_special can not touch.
728 * DON'T do it again until a total personality rewrite is committed.
729 */
730 static int set_multcount(ide_drive_t *drive, int arg)
731 {
732 struct request rq;
733
734 if (arg < 0 || arg > drive->id->max_multsect)
735 return -EINVAL;
736
737 if (drive->special.b.set_multmode)
738 return -EBUSY;
739 ide_init_drive_cmd (&rq);
740 rq.cmd_type = REQ_TYPE_ATA_CMD;
741 drive->mult_req = arg;
742 drive->special.b.set_multmode = 1;
743 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
744 return (drive->mult_count == arg) ? 0 : -EIO;
745 }
746
747 static int set_nowerr(ide_drive_t *drive, int arg)
748 {
749 if (arg < 0 || arg > 1)
750 return -EINVAL;
751
752 if (ide_spin_wait_hwgroup(drive))
753 return -EBUSY;
754 drive->nowerr = arg;
755 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
756 spin_unlock_irq(&ide_lock);
757 return 0;
758 }
759
760 static void update_ordered(ide_drive_t *drive)
761 {
762 struct hd_driveid *id = drive->id;
763 unsigned ordered = QUEUE_ORDERED_NONE;
764 prepare_flush_fn *prep_fn = NULL;
765 issue_flush_fn *issue_fn = NULL;
766
767 if (drive->wcache) {
768 unsigned long long capacity;
769 int barrier;
770 /*
771 * We must avoid issuing commands a drive does not
772 * understand or we may crash it. We check flush cache
773 * is supported. We also check we have the LBA48 flush
774 * cache if the drive capacity is too large. By this
775 * time we have trimmed the drive capacity if LBA48 is
776 * not available so we don't need to recheck that.
777 */
778 capacity = idedisk_capacity(drive);
779 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
780 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
781 ide_id_has_flush_cache_ext(id));
782
783 printk(KERN_INFO "%s: cache flushes %ssupported\n",
784 drive->name, barrier ? "" : "not ");
785
786 if (barrier) {
787 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
788 prep_fn = idedisk_prepare_flush;
789 issue_fn = idedisk_issue_flush;
790 }
791 } else
792 ordered = QUEUE_ORDERED_DRAIN;
793
794 blk_queue_ordered(drive->queue, ordered, prep_fn);
795 blk_queue_issue_flush_fn(drive->queue, issue_fn);
796 }
797
798 static int write_cache(ide_drive_t *drive, int arg)
799 {
800 ide_task_t args;
801 int err = 1;
802
803 if (arg < 0 || arg > 1)
804 return -EINVAL;
805
806 if (ide_id_has_flush_cache(drive->id)) {
807 memset(&args, 0, sizeof(ide_task_t));
808 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ?
809 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
810 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
811 args.command_type = IDE_DRIVE_TASK_NO_DATA;
812 args.handler = &task_no_data_intr;
813 err = ide_raw_taskfile(drive, &args, NULL);
814 if (err == 0)
815 drive->wcache = arg;
816 }
817
818 update_ordered(drive);
819
820 return err;
821 }
822
823 static int do_idedisk_flushcache (ide_drive_t *drive)
824 {
825 ide_task_t args;
826
827 memset(&args, 0, sizeof(ide_task_t));
828 if (ide_id_has_flush_cache_ext(drive->id))
829 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE_EXT;
830 else
831 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_FLUSH_CACHE;
832 args.command_type = IDE_DRIVE_TASK_NO_DATA;
833 args.handler = &task_no_data_intr;
834 return ide_raw_taskfile(drive, &args, NULL);
835 }
836
837 static int set_acoustic (ide_drive_t *drive, int arg)
838 {
839 ide_task_t args;
840
841 if (arg < 0 || arg > 254)
842 return -EINVAL;
843
844 memset(&args, 0, sizeof(ide_task_t));
845 args.tfRegister[IDE_FEATURE_OFFSET] = (arg) ? SETFEATURES_EN_AAM :
846 SETFEATURES_DIS_AAM;
847 args.tfRegister[IDE_NSECTOR_OFFSET] = arg;
848 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_SETFEATURES;
849 args.command_type = IDE_DRIVE_TASK_NO_DATA;
850 args.handler = &task_no_data_intr;
851 ide_raw_taskfile(drive, &args, NULL);
852 drive->acoustic = arg;
853 return 0;
854 }
855
856 /*
857 * drive->addressing:
858 * 0: 28-bit
859 * 1: 48-bit
860 * 2: 48-bit capable doing 28-bit
861 */
862 static int set_lba_addressing(ide_drive_t *drive, int arg)
863 {
864 if (arg < 0 || arg > 2)
865 return -EINVAL;
866
867 drive->addressing = 0;
868
869 if (HWIF(drive)->no_lba48)
870 return 0;
871
872 if (!idedisk_supports_lba48(drive->id))
873 return -EIO;
874 drive->addressing = arg;
875 return 0;
876 }
877
878 #ifdef CONFIG_IDE_PROC_FS
879 static void idedisk_add_settings(ide_drive_t *drive)
880 {
881 struct hd_driveid *id = drive->id;
882
883 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
884 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
885 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
886 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
887 ide_add_setting(drive, "bswap", SETTING_READ, TYPE_BYTE, 0, 1, 1, 1, &drive->bswap, NULL);
888 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount);
889 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
890 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
891 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
892 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
893 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
894 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
895 }
896 #else
897 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
898 #endif
899
900 static void idedisk_setup (ide_drive_t *drive)
901 {
902 struct hd_driveid *id = drive->id;
903 unsigned long long capacity;
904
905 idedisk_add_settings(drive);
906
907 if (drive->id_read == 0)
908 return;
909
910 if (drive->removable) {
911 /*
912 * Removable disks (eg. SYQUEST); ignore 'WD' drives
913 */
914 if (id->model[0] != 'W' || id->model[1] != 'D') {
915 drive->doorlocking = 1;
916 }
917 }
918
919 (void)set_lba_addressing(drive, 1);
920
921 if (drive->addressing == 1) {
922 ide_hwif_t *hwif = HWIF(drive);
923 int max_s = 2048;
924
925 if (max_s > hwif->rqsize)
926 max_s = hwif->rqsize;
927
928 blk_queue_max_sectors(drive->queue, max_s);
929 }
930
931 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
932
933 /* calculate drive capacity, and select LBA if possible */
934 init_idedisk_capacity (drive);
935
936 /* limit drive capacity to 137GB if LBA48 cannot be used */
937 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
938 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
939 "%llu sectors (%llu MB)\n",
940 drive->name, (unsigned long long)drive->capacity64,
941 sectors_to_MB(drive->capacity64));
942 drive->capacity64 = 1ULL << 28;
943 }
944
945 if (drive->hwif->no_lba48_dma && drive->addressing) {
946 if (drive->capacity64 > 1ULL << 28) {
947 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
948 " be used for accessing sectors > %u\n",
949 drive->name, 1 << 28);
950 } else
951 drive->addressing = 0;
952 }
953
954 /*
955 * if possible, give fdisk access to more of the drive,
956 * by correcting bios_cyls:
957 */
958 capacity = idedisk_capacity (drive);
959 if (!drive->forced_geom) {
960
961 if (idedisk_supports_lba48(drive->id)) {
962 /* compatibility */
963 drive->bios_sect = 63;
964 drive->bios_head = 255;
965 }
966
967 if (drive->bios_sect && drive->bios_head) {
968 unsigned int cap0 = capacity; /* truncate to 32 bits */
969 unsigned int cylsz, cyl;
970
971 if (cap0 != capacity)
972 drive->bios_cyl = 65535;
973 else {
974 cylsz = drive->bios_sect * drive->bios_head;
975 cyl = cap0 / cylsz;
976 if (cyl > 65535)
977 cyl = 65535;
978 if (cyl > drive->bios_cyl)
979 drive->bios_cyl = cyl;
980 }
981 }
982 }
983 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
984 drive->name, capacity, sectors_to_MB(capacity));
985
986 /* Only print cache size when it was specified */
987 if (id->buf_size)
988 printk (" w/%dKiB Cache", id->buf_size/2);
989
990 printk(", CHS=%d/%d/%d",
991 drive->bios_cyl, drive->bios_head, drive->bios_sect);
992 if (drive->using_dma)
993 ide_dma_verbose(drive);
994 printk("\n");
995
996 /* write cache enabled? */
997 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
998 drive->wcache = 1;
999
1000 write_cache(drive, 1);
1001 }
1002
1003 static void ide_cacheflush_p(ide_drive_t *drive)
1004 {
1005 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
1006 return;
1007
1008 if (do_idedisk_flushcache(drive))
1009 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
1010 }
1011
1012 static void ide_disk_remove(ide_drive_t *drive)
1013 {
1014 struct ide_disk_obj *idkp = drive->driver_data;
1015 struct gendisk *g = idkp->disk;
1016
1017 ide_proc_unregister_driver(drive, idkp->driver);
1018
1019 del_gendisk(g);
1020
1021 ide_cacheflush_p(drive);
1022
1023 ide_disk_put(idkp);
1024 }
1025
1026 static void ide_disk_release(struct kref *kref)
1027 {
1028 struct ide_disk_obj *idkp = to_ide_disk(kref);
1029 ide_drive_t *drive = idkp->drive;
1030 struct gendisk *g = idkp->disk;
1031
1032 drive->driver_data = NULL;
1033 g->private_data = NULL;
1034 put_disk(g);
1035 kfree(idkp);
1036 }
1037
1038 static int ide_disk_probe(ide_drive_t *drive);
1039
1040 /*
1041 * On HPA drives the capacity needs to be
1042 * reinitilized on resume otherwise the disk
1043 * can not be used and a hard reset is required
1044 */
1045 static void ide_disk_resume(ide_drive_t *drive)
1046 {
1047 if (idedisk_supports_hpa(drive->id))
1048 init_idedisk_capacity(drive);
1049 }
1050
1051 static void ide_device_shutdown(ide_drive_t *drive)
1052 {
1053 #ifdef CONFIG_ALPHA
1054 /* On Alpha, halt(8) doesn't actually turn the machine off,
1055 it puts you into the sort of firmware monitor. Typically,
1056 it's used to boot another kernel image, so it's not much
1057 different from reboot(8). Therefore, we don't need to
1058 spin down the disk in this case, especially since Alpha
1059 firmware doesn't handle disks in standby mode properly.
1060 On the other hand, it's reasonably safe to turn the power
1061 off when the shutdown process reaches the firmware prompt,
1062 as the firmware initialization takes rather long time -
1063 at least 10 seconds, which should be sufficient for
1064 the disk to expire its write cache. */
1065 if (system_state != SYSTEM_POWER_OFF) {
1066 #else
1067 if (system_state == SYSTEM_RESTART) {
1068 #endif
1069 ide_cacheflush_p(drive);
1070 return;
1071 }
1072
1073 printk("Shutdown: %s\n", drive->name);
1074 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
1075 }
1076
1077 static ide_driver_t idedisk_driver = {
1078 .gen_driver = {
1079 .owner = THIS_MODULE,
1080 .name = "ide-disk",
1081 .bus = &ide_bus_type,
1082 },
1083 .probe = ide_disk_probe,
1084 .remove = ide_disk_remove,
1085 .resume = ide_disk_resume,
1086 .shutdown = ide_device_shutdown,
1087 .version = IDEDISK_VERSION,
1088 .media = ide_disk,
1089 .supports_dsc_overlap = 0,
1090 .do_request = ide_do_rw_disk,
1091 .end_request = ide_end_request,
1092 .error = __ide_error,
1093 .abort = __ide_abort,
1094 #ifdef CONFIG_IDE_PROC_FS
1095 .proc = idedisk_proc,
1096 #endif
1097 };
1098
1099 static int idedisk_open(struct inode *inode, struct file *filp)
1100 {
1101 struct gendisk *disk = inode->i_bdev->bd_disk;
1102 struct ide_disk_obj *idkp;
1103 ide_drive_t *drive;
1104
1105 if (!(idkp = ide_disk_get(disk)))
1106 return -ENXIO;
1107
1108 drive = idkp->drive;
1109
1110 idkp->openers++;
1111
1112 if (drive->removable && idkp->openers == 1) {
1113 ide_task_t args;
1114 memset(&args, 0, sizeof(ide_task_t));
1115 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORLOCK;
1116 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1117 args.handler = &task_no_data_intr;
1118 check_disk_change(inode->i_bdev);
1119 /*
1120 * Ignore the return code from door_lock,
1121 * since the open() has already succeeded,
1122 * and the door_lock is irrelevant at this point.
1123 */
1124 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1125 drive->doorlocking = 0;
1126 }
1127 return 0;
1128 }
1129
1130 static int idedisk_release(struct inode *inode, struct file *filp)
1131 {
1132 struct gendisk *disk = inode->i_bdev->bd_disk;
1133 struct ide_disk_obj *idkp = ide_disk_g(disk);
1134 ide_drive_t *drive = idkp->drive;
1135
1136 if (idkp->openers == 1)
1137 ide_cacheflush_p(drive);
1138
1139 if (drive->removable && idkp->openers == 1) {
1140 ide_task_t args;
1141 memset(&args, 0, sizeof(ide_task_t));
1142 args.tfRegister[IDE_COMMAND_OFFSET] = WIN_DOORUNLOCK;
1143 args.command_type = IDE_DRIVE_TASK_NO_DATA;
1144 args.handler = &task_no_data_intr;
1145 if (drive->doorlocking && ide_raw_taskfile(drive, &args, NULL))
1146 drive->doorlocking = 0;
1147 }
1148
1149 idkp->openers--;
1150
1151 ide_disk_put(idkp);
1152
1153 return 0;
1154 }
1155
1156 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1157 {
1158 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1159 ide_drive_t *drive = idkp->drive;
1160
1161 geo->heads = drive->bios_head;
1162 geo->sectors = drive->bios_sect;
1163 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1164 return 0;
1165 }
1166
1167 static int idedisk_ioctl(struct inode *inode, struct file *file,
1168 unsigned int cmd, unsigned long arg)
1169 {
1170 unsigned long flags;
1171 struct block_device *bdev = inode->i_bdev;
1172 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1173 ide_drive_t *drive = idkp->drive;
1174 int err, (*setfunc)(ide_drive_t *, int);
1175 u8 *val;
1176
1177 switch (cmd) {
1178 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1179 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1180 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1181 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1182 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1183 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1184 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1185 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1186 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1187 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1188 }
1189
1190 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1191
1192 read_val:
1193 mutex_lock(&ide_setting_mtx);
1194 spin_lock_irqsave(&ide_lock, flags);
1195 err = *val;
1196 spin_unlock_irqrestore(&ide_lock, flags);
1197 mutex_unlock(&ide_setting_mtx);
1198 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1199
1200 set_val:
1201 if (bdev != bdev->bd_contains)
1202 err = -EINVAL;
1203 else {
1204 if (!capable(CAP_SYS_ADMIN))
1205 err = -EACCES;
1206 else {
1207 mutex_lock(&ide_setting_mtx);
1208 err = setfunc(drive, arg);
1209 mutex_unlock(&ide_setting_mtx);
1210 }
1211 }
1212 return err;
1213 }
1214
1215 static int idedisk_media_changed(struct gendisk *disk)
1216 {
1217 struct ide_disk_obj *idkp = ide_disk_g(disk);
1218 ide_drive_t *drive = idkp->drive;
1219
1220 /* do not scan partitions twice if this is a removable device */
1221 if (drive->attach) {
1222 drive->attach = 0;
1223 return 0;
1224 }
1225 /* if removable, always assume it was changed */
1226 return drive->removable;
1227 }
1228
1229 static int idedisk_revalidate_disk(struct gendisk *disk)
1230 {
1231 struct ide_disk_obj *idkp = ide_disk_g(disk);
1232 set_capacity(disk, idedisk_capacity(idkp->drive));
1233 return 0;
1234 }
1235
1236 static struct block_device_operations idedisk_ops = {
1237 .owner = THIS_MODULE,
1238 .open = idedisk_open,
1239 .release = idedisk_release,
1240 .ioctl = idedisk_ioctl,
1241 .getgeo = idedisk_getgeo,
1242 .media_changed = idedisk_media_changed,
1243 .revalidate_disk= idedisk_revalidate_disk
1244 };
1245
1246 MODULE_DESCRIPTION("ATA DISK Driver");
1247
1248 static int ide_disk_probe(ide_drive_t *drive)
1249 {
1250 struct ide_disk_obj *idkp;
1251 struct gendisk *g;
1252
1253 /* strstr("foo", "") is non-NULL */
1254 if (!strstr("ide-disk", drive->driver_req))
1255 goto failed;
1256 if (!drive->present)
1257 goto failed;
1258 if (drive->media != ide_disk)
1259 goto failed;
1260
1261 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1262 if (!idkp)
1263 goto failed;
1264
1265 g = alloc_disk_node(1 << PARTN_BITS,
1266 hwif_to_node(drive->hwif));
1267 if (!g)
1268 goto out_free_idkp;
1269
1270 ide_init_disk(g, drive);
1271
1272 ide_proc_register_driver(drive, &idedisk_driver);
1273
1274 kref_init(&idkp->kref);
1275
1276 idkp->drive = drive;
1277 idkp->driver = &idedisk_driver;
1278 idkp->disk = g;
1279
1280 g->private_data = &idkp->driver;
1281
1282 drive->driver_data = idkp;
1283
1284 idedisk_setup(drive);
1285 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1286 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1287 drive->name, drive->head);
1288 drive->attach = 0;
1289 } else
1290 drive->attach = 1;
1291
1292 g->minors = 1 << PARTN_BITS;
1293 g->driverfs_dev = &drive->gendev;
1294 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1295 set_capacity(g, idedisk_capacity(drive));
1296 g->fops = &idedisk_ops;
1297 add_disk(g);
1298 return 0;
1299
1300 out_free_idkp:
1301 kfree(idkp);
1302 failed:
1303 return -ENODEV;
1304 }
1305
1306 static void __exit idedisk_exit (void)
1307 {
1308 driver_unregister(&idedisk_driver.gen_driver);
1309 }
1310
1311 static int __init idedisk_init(void)
1312 {
1313 return driver_register(&idedisk_driver.gen_driver);
1314 }
1315
1316 MODULE_ALIAS("ide:*m-disk*");
1317 module_init(idedisk_init);
1318 module_exit(idedisk_exit);
1319 MODULE_LICENSE("GPL");
USB Experimental Work