?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
W1: feature, enable hardware strong pullup
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / ide / ide-disk.c
blob3853bde8eedc3c291b8b676529563afccdcc2f0d
1 /*
2 * Copyright (C) 1994-1998 Linus Torvalds & authors (see below)
3 * Copyright (C) 1998-2002 Linux ATA Development
4 * Andre Hedrick <andre@linux-ide.org>
5 * Copyright (C) 2003 Red Hat <alan@redhat.com>
6 * Copyright (C) 2003-2005, 2007 Bartlomiej Zolnierkiewicz
7 */
8
9 /*
10 * Mostly written by Mark Lord <mlord@pobox.com>
11 * and Gadi Oxman <gadio@netvision.net.il>
12 * and Andre Hedrick <andre@linux-ide.org>
13 *
14 * This is the IDE/ATA disk driver, as evolved from hd.c and ide.c.
15 */
16
17 #define IDEDISK_VERSION "1.18"
18
19 #include <linux/module.h>
20 #include <linux/types.h>
21 #include <linux/string.h>
22 #include <linux/kernel.h>
23 #include <linux/timer.h>
24 #include <linux/mm.h>
25 #include <linux/interrupt.h>
26 #include <linux/major.h>
27 #include <linux/errno.h>
28 #include <linux/genhd.h>
29 #include <linux/slab.h>
30 #include <linux/delay.h>
31 #include <linux/mutex.h>
32 #include <linux/leds.h>
33 #include <linux/ide.h>
34 #include <linux/hdreg.h>
35
36 #include <asm/byteorder.h>
37 #include <asm/irq.h>
38 #include <asm/uaccess.h>
39 #include <asm/io.h>
40 #include <asm/div64.h>
41
42 #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT)
43 #define IDE_DISK_MINORS (1 << PARTN_BITS)
44 #else
45 #define IDE_DISK_MINORS 0
46 #endif
47
48 #include "ide-disk.h"
49
50 static DEFINE_MUTEX(idedisk_ref_mutex);
51
52 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
53
54 static void ide_disk_release(struct kref *);
55
56 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
57 {
58 struct ide_disk_obj *idkp = NULL;
59
60 mutex_lock(&idedisk_ref_mutex);
61 idkp = ide_disk_g(disk);
62 if (idkp) {
63 if (ide_device_get(idkp->drive))
64 idkp = NULL;
65 else
66 kref_get(&idkp->kref);
67 }
68 mutex_unlock(&idedisk_ref_mutex);
69 return idkp;
70 }
71
72 static void ide_disk_put(struct ide_disk_obj *idkp)
73 {
74 ide_drive_t *drive = idkp->drive;
75
76 mutex_lock(&idedisk_ref_mutex);
77 kref_put(&idkp->kref, ide_disk_release);
78 ide_device_put(drive);
79 mutex_unlock(&idedisk_ref_mutex);
80 }
81
82 static const u8 ide_rw_cmds[] = {
83 ATA_CMD_READ_MULTI,
84 ATA_CMD_WRITE_MULTI,
85 ATA_CMD_READ_MULTI_EXT,
86 ATA_CMD_WRITE_MULTI_EXT,
87 ATA_CMD_PIO_READ,
88 ATA_CMD_PIO_WRITE,
89 ATA_CMD_PIO_READ_EXT,
90 ATA_CMD_PIO_WRITE_EXT,
91 ATA_CMD_READ,
92 ATA_CMD_WRITE,
93 ATA_CMD_READ_EXT,
94 ATA_CMD_WRITE_EXT,
95 };
96
97 static const u8 ide_data_phases[] = {
98 TASKFILE_MULTI_IN,
99 TASKFILE_MULTI_OUT,
100 TASKFILE_IN,
101 TASKFILE_OUT,
102 TASKFILE_IN_DMA,
103 TASKFILE_OUT_DMA,
104 };
105
106 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
107 {
108 u8 index, lba48, write;
109
110 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
111 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
112
113 if (dma)
114 index = 8;
115 else
116 index = drive->mult_count ? 0 : 4;
117
118 task->tf.command = ide_rw_cmds[index + lba48 + write];
119
120 if (dma)
121 index = 8; /* fixup index */
122
123 task->data_phase = ide_data_phases[index / 2 + write];
124 }
125
126 /*
127 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
128 * using LBA if supported, or CHS otherwise, to address sectors.
129 */
130 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
131 sector_t block)
132 {
133 ide_hwif_t *hwif = HWIF(drive);
134 u16 nsectors = (u16)rq->nr_sectors;
135 u8 lba48 = !!(drive->dev_flags & IDE_DFLAG_LBA48);
136 u8 dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
137 ide_task_t task;
138 struct ide_taskfile *tf = &task.tf;
139 ide_startstop_t rc;
140
141 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
142 if (block + rq->nr_sectors > 1ULL << 28)
143 dma = 0;
144 else
145 lba48 = 0;
146 }
147
148 if (!dma) {
149 ide_init_sg_cmd(drive, rq);
150 ide_map_sg(drive, rq);
151 }
152
153 memset(&task, 0, sizeof(task));
154 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
155
156 if (drive->dev_flags & IDE_DFLAG_LBA) {
157 if (lba48) {
158 pr_debug("%s: LBA=0x%012llx\n", drive->name,
159 (unsigned long long)block);
160
161 tf->hob_nsect = (nsectors >> 8) & 0xff;
162 tf->hob_lbal = (u8)(block >> 24);
163 if (sizeof(block) != 4) {
164 tf->hob_lbam = (u8)((u64)block >> 32);
165 tf->hob_lbah = (u8)((u64)block >> 40);
166 }
167
168 tf->nsect = nsectors & 0xff;
169 tf->lbal = (u8) block;
170 tf->lbam = (u8)(block >> 8);
171 tf->lbah = (u8)(block >> 16);
172
173 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
174 } else {
175 tf->nsect = nsectors & 0xff;
176 tf->lbal = block;
177 tf->lbam = block >>= 8;
178 tf->lbah = block >>= 8;
179 tf->device = (block >> 8) & 0xf;
180 }
181
182 tf->device |= ATA_LBA;
183 } else {
184 unsigned int sect, head, cyl, track;
185
186 track = (int)block / drive->sect;
187 sect = (int)block % drive->sect + 1;
188 head = track % drive->head;
189 cyl = track / drive->head;
190
191 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
192
193 tf->nsect = nsectors & 0xff;
194 tf->lbal = sect;
195 tf->lbam = cyl;
196 tf->lbah = cyl >> 8;
197 tf->device = head;
198 }
199
200 if (rq_data_dir(rq))
201 task.tf_flags |= IDE_TFLAG_WRITE;
202
203 ide_tf_set_cmd(drive, &task, dma);
204 if (!dma)
205 hwif->data_phase = task.data_phase;
206 task.rq = rq;
207
208 rc = do_rw_taskfile(drive, &task);
209
210 if (rc == ide_stopped && dma) {
211 /* fallback to PIO */
212 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
213 ide_tf_set_cmd(drive, &task, 0);
214 hwif->data_phase = task.data_phase;
215 ide_init_sg_cmd(drive, rq);
216 rc = do_rw_taskfile(drive, &task);
217 }
218
219 return rc;
220 }
221
222 /*
223 * 268435455 == 137439 MB or 28bit limit
224 * 320173056 == 163929 MB or 48bit addressing
225 * 1073741822 == 549756 MB or 48bit addressing fake drive
226 */
227
228 static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
229 sector_t block)
230 {
231 ide_hwif_t *hwif = HWIF(drive);
232
233 BUG_ON(drive->dev_flags & IDE_DFLAG_BLOCKED);
234
235 if (!blk_fs_request(rq)) {
236 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
237 ide_end_request(drive, 0, 0);
238 return ide_stopped;
239 }
240
241 ledtrig_ide_activity();
242
243 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
244 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
245 (unsigned long long)block, rq->nr_sectors,
246 (unsigned long)rq->buffer);
247
248 if (hwif->rw_disk)
249 hwif->rw_disk(drive, rq);
250
251 return __ide_do_rw_disk(drive, rq, block);
252 }
253
254 /*
255 * Queries for true maximum capacity of the drive.
256 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
257 */
258 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
259 {
260 ide_task_t args;
261 struct ide_taskfile *tf = &args.tf;
262 u64 addr = 0;
263
264 /* Create IDE/ATA command request structure */
265 memset(&args, 0, sizeof(ide_task_t));
266 if (lba48)
267 tf->command = ATA_CMD_READ_NATIVE_MAX_EXT;
268 else
269 tf->command = ATA_CMD_READ_NATIVE_MAX;
270 tf->device = ATA_LBA;
271 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
272 if (lba48)
273 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
274 /* submit command request */
275 ide_no_data_taskfile(drive, &args);
276
277 /* if OK, compute maximum address value */
278 if ((tf->status & 0x01) == 0)
279 addr = ide_get_lba_addr(tf, lba48) + 1;
280
281 return addr;
282 }
283
284 /*
285 * Sets maximum virtual LBA address of the drive.
286 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
287 */
288 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
289 {
290 ide_task_t args;
291 struct ide_taskfile *tf = &args.tf;
292 u64 addr_set = 0;
293
294 addr_req--;
295 /* Create IDE/ATA command request structure */
296 memset(&args, 0, sizeof(ide_task_t));
297 tf->lbal = (addr_req >> 0) & 0xff;
298 tf->lbam = (addr_req >>= 8) & 0xff;
299 tf->lbah = (addr_req >>= 8) & 0xff;
300 if (lba48) {
301 tf->hob_lbal = (addr_req >>= 8) & 0xff;
302 tf->hob_lbam = (addr_req >>= 8) & 0xff;
303 tf->hob_lbah = (addr_req >>= 8) & 0xff;
304 tf->command = ATA_CMD_SET_MAX_EXT;
305 } else {
306 tf->device = (addr_req >>= 8) & 0x0f;
307 tf->command = ATA_CMD_SET_MAX;
308 }
309 tf->device |= ATA_LBA;
310 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
311 if (lba48)
312 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
313 /* submit command request */
314 ide_no_data_taskfile(drive, &args);
315 /* if OK, compute maximum address value */
316 if ((tf->status & 0x01) == 0)
317 addr_set = ide_get_lba_addr(tf, lba48) + 1;
318
319 return addr_set;
320 }
321
322 static unsigned long long sectors_to_MB(unsigned long long n)
323 {
324 n <<= 9; /* make it bytes */
325 do_div(n, 1000000); /* make it MB */
326 return n;
327 }
328
329 /*
330 * Some disks report total number of sectors instead of
331 * maximum sector address. We list them here.
332 */
333 static const struct drive_list_entry hpa_list[] = {
334 { "ST340823A", NULL },
335 { "ST320413A", NULL },
336 { "ST310211A", NULL },
337 { NULL, NULL }
338 };
339
340 static void idedisk_check_hpa(ide_drive_t *drive)
341 {
342 unsigned long long capacity, set_max;
343 int lba48 = ata_id_lba48_enabled(drive->id);
344
345 capacity = drive->capacity64;
346
347 set_max = idedisk_read_native_max_address(drive, lba48);
348
349 if (ide_in_drive_list(drive->id, hpa_list)) {
350 /*
351 * Since we are inclusive wrt to firmware revisions do this
352 * extra check and apply the workaround only when needed.
353 */
354 if (set_max == capacity + 1)
355 set_max--;
356 }
357
358 if (set_max <= capacity)
359 return;
360
361 printk(KERN_INFO "%s: Host Protected Area detected.\n"
362 "\tcurrent capacity is %llu sectors (%llu MB)\n"
363 "\tnative capacity is %llu sectors (%llu MB)\n",
364 drive->name,
365 capacity, sectors_to_MB(capacity),
366 set_max, sectors_to_MB(set_max));
367
368 set_max = idedisk_set_max_address(drive, set_max, lba48);
369
370 if (set_max) {
371 drive->capacity64 = set_max;
372 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
373 drive->name);
374 }
375 }
376
377 static void init_idedisk_capacity(ide_drive_t *drive)
378 {
379 u16 *id = drive->id;
380 int lba;
381
382 if (ata_id_lba48_enabled(id)) {
383 /* drive speaks 48-bit LBA */
384 lba = 1;
385 drive->capacity64 = ata_id_u64(id, ATA_ID_LBA_CAPACITY_2);
386 } else if (ata_id_has_lba(id) && ata_id_is_lba_capacity_ok(id)) {
387 /* drive speaks 28-bit LBA */
388 lba = 1;
389 drive->capacity64 = ata_id_u32(id, ATA_ID_LBA_CAPACITY);
390 } else {
391 /* drive speaks boring old 28-bit CHS */
392 lba = 0;
393 drive->capacity64 = drive->cyl * drive->head * drive->sect;
394 }
395
396 if (lba) {
397 drive->dev_flags |= IDE_DFLAG_LBA;
398
399 /*
400 * If this device supports the Host Protected Area feature set,
401 * then we may need to change our opinion about its capacity.
402 */
403 if (ata_id_hpa_enabled(id))
404 idedisk_check_hpa(drive);
405 }
406 }
407
408 sector_t ide_disk_capacity(ide_drive_t *drive)
409 {
410 return drive->capacity64;
411 }
412
413 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
414 {
415 ide_drive_t *drive = q->queuedata;
416 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
417
418 /* FIXME: map struct ide_taskfile on rq->cmd[] */
419 BUG_ON(task == NULL);
420
421 memset(task, 0, sizeof(*task));
422 if (ata_id_flush_ext_enabled(drive->id) &&
423 (drive->capacity64 >= (1UL << 28)))
424 task->tf.command = ATA_CMD_FLUSH_EXT;
425 else
426 task->tf.command = ATA_CMD_FLUSH;
427 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
428 IDE_TFLAG_DYN;
429 task->data_phase = TASKFILE_NO_DATA;
430
431 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
432 rq->cmd_flags |= REQ_SOFTBARRIER;
433 rq->special = task;
434 }
435
436 ide_devset_get(multcount, mult_count);
437
438 /*
439 * This is tightly woven into the driver->do_special can not touch.
440 * DON'T do it again until a total personality rewrite is committed.
441 */
442 static int set_multcount(ide_drive_t *drive, int arg)
443 {
444 struct request *rq;
445 int error;
446
447 if (arg < 0 || arg > (drive->id[ATA_ID_MAX_MULTSECT] & 0xff))
448 return -EINVAL;
449
450 if (drive->special.b.set_multmode)
451 return -EBUSY;
452
453 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
454 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
455
456 drive->mult_req = arg;
457 drive->special.b.set_multmode = 1;
458 error = blk_execute_rq(drive->queue, NULL, rq, 0);
459 blk_put_request(rq);
460
461 return (drive->mult_count == arg) ? 0 : -EIO;
462 }
463
464 ide_devset_get_flag(nowerr, IDE_DFLAG_NOWERR);
465
466 static int set_nowerr(ide_drive_t *drive, int arg)
467 {
468 if (arg < 0 || arg > 1)
469 return -EINVAL;
470
471 if (arg)
472 drive->dev_flags |= IDE_DFLAG_NOWERR;
473 else
474 drive->dev_flags &= ~IDE_DFLAG_NOWERR;
475
476 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
477
478 return 0;
479 }
480
481 static int ide_do_setfeature(ide_drive_t *drive, u8 feature, u8 nsect)
482 {
483 ide_task_t task;
484
485 memset(&task, 0, sizeof(task));
486 task.tf.feature = feature;
487 task.tf.nsect = nsect;
488 task.tf.command = ATA_CMD_SET_FEATURES;
489 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
490
491 return ide_no_data_taskfile(drive, &task);
492 }
493
494 static void update_ordered(ide_drive_t *drive)
495 {
496 u16 *id = drive->id;
497 unsigned ordered = QUEUE_ORDERED_NONE;
498 prepare_flush_fn *prep_fn = NULL;
499
500 if (drive->dev_flags & IDE_DFLAG_WCACHE) {
501 unsigned long long capacity;
502 int barrier;
503 /*
504 * We must avoid issuing commands a drive does not
505 * understand or we may crash it. We check flush cache
506 * is supported. We also check we have the LBA48 flush
507 * cache if the drive capacity is too large. By this
508 * time we have trimmed the drive capacity if LBA48 is
509 * not available so we don't need to recheck that.
510 */
511 capacity = ide_disk_capacity(drive);
512 barrier = ata_id_flush_enabled(id) &&
513 (drive->dev_flags & IDE_DFLAG_NOFLUSH) == 0 &&
514 ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 ||
515 capacity <= (1ULL << 28) ||
516 ata_id_flush_ext_enabled(id));
517
518 printk(KERN_INFO "%s: cache flushes %ssupported\n",
519 drive->name, barrier ? "" : "not ");
520
521 if (barrier) {
522 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
523 prep_fn = idedisk_prepare_flush;
524 }
525 } else
526 ordered = QUEUE_ORDERED_DRAIN;
527
528 blk_queue_ordered(drive->queue, ordered, prep_fn);
529 }
530
531 ide_devset_get_flag(wcache, IDE_DFLAG_WCACHE);
532
533 static int set_wcache(ide_drive_t *drive, int arg)
534 {
535 int err = 1;
536
537 if (arg < 0 || arg > 1)
538 return -EINVAL;
539
540 if (ata_id_flush_enabled(drive->id)) {
541 err = ide_do_setfeature(drive,
542 arg ? SETFEATURES_WC_ON : SETFEATURES_WC_OFF, 0);
543 if (err == 0) {
544 if (arg)
545 drive->dev_flags |= IDE_DFLAG_WCACHE;
546 else
547 drive->dev_flags &= ~IDE_DFLAG_WCACHE;
548 }
549 }
550
551 update_ordered(drive);
552
553 return err;
554 }
555
556 static int do_idedisk_flushcache(ide_drive_t *drive)
557 {
558 ide_task_t args;
559
560 memset(&args, 0, sizeof(ide_task_t));
561 if (ata_id_flush_ext_enabled(drive->id))
562 args.tf.command = ATA_CMD_FLUSH_EXT;
563 else
564 args.tf.command = ATA_CMD_FLUSH;
565 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
566 return ide_no_data_taskfile(drive, &args);
567 }
568
569 ide_devset_get(acoustic, acoustic);
570
571 static int set_acoustic(ide_drive_t *drive, int arg)
572 {
573 if (arg < 0 || arg > 254)
574 return -EINVAL;
575
576 ide_do_setfeature(drive,
577 arg ? SETFEATURES_AAM_ON : SETFEATURES_AAM_OFF, arg);
578
579 drive->acoustic = arg;
580
581 return 0;
582 }
583
584 ide_devset_get_flag(addressing, IDE_DFLAG_LBA48);
585
586 /*
587 * drive->addressing:
588 * 0: 28-bit
589 * 1: 48-bit
590 * 2: 48-bit capable doing 28-bit
591 */
592 static int set_addressing(ide_drive_t *drive, int arg)
593 {
594 if (arg < 0 || arg > 2)
595 return -EINVAL;
596
597 if (arg && ((drive->hwif->host_flags & IDE_HFLAG_NO_LBA48) ||
598 ata_id_lba48_enabled(drive->id) == 0))
599 return -EIO;
600
601 if (arg == 2)
602 arg = 0;
603
604 if (arg)
605 drive->dev_flags |= IDE_DFLAG_LBA48;
606 else
607 drive->dev_flags &= ~IDE_DFLAG_LBA48;
608
609 return 0;
610 }
611
612 ide_ext_devset_rw(acoustic, acoustic);
613 ide_ext_devset_rw(address, addressing);
614 ide_ext_devset_rw(multcount, multcount);
615 ide_ext_devset_rw(wcache, wcache);
616
617 ide_ext_devset_rw_sync(nowerr, nowerr);
618
619 static void idedisk_setup(ide_drive_t *drive)
620 {
621 struct ide_disk_obj *idkp = drive->driver_data;
622 ide_hwif_t *hwif = drive->hwif;
623 u16 *id = drive->id;
624 char *m = (char *)&id[ATA_ID_PROD];
625 unsigned long long capacity;
626
627 ide_proc_register_driver(drive, idkp->driver);
628
629 if ((drive->dev_flags & IDE_DFLAG_ID_READ) == 0)
630 return;
631
632 if (drive->dev_flags & IDE_DFLAG_REMOVABLE) {
633 /*
634 * Removable disks (eg. SYQUEST); ignore 'WD' drives
635 */
636 if (m[0] != 'W' || m[1] != 'D')
637 drive->dev_flags |= IDE_DFLAG_DOORLOCKING;
638 }
639
640 (void)set_addressing(drive, 1);
641
642 if (drive->dev_flags & IDE_DFLAG_LBA48) {
643 int max_s = 2048;
644
645 if (max_s > hwif->rqsize)
646 max_s = hwif->rqsize;
647
648 blk_queue_max_sectors(drive->queue, max_s);
649 }
650
651 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
652 drive->queue->max_sectors / 2);
653
654 /* calculate drive capacity, and select LBA if possible */
655 init_idedisk_capacity(drive);
656
657 /* limit drive capacity to 137GB if LBA48 cannot be used */
658 if ((drive->dev_flags & IDE_DFLAG_LBA48) == 0 &&
659 drive->capacity64 > 1ULL << 28) {
660 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
661 "%llu sectors (%llu MB)\n",
662 drive->name, (unsigned long long)drive->capacity64,
663 sectors_to_MB(drive->capacity64));
664 drive->capacity64 = 1ULL << 28;
665 }
666
667 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) &&
668 (drive->dev_flags & IDE_DFLAG_LBA48)) {
669 if (drive->capacity64 > 1ULL << 28) {
670 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode"
671 " will be used for accessing sectors "
672 "> %u\n", drive->name, 1 << 28);
673 } else
674 drive->dev_flags &= ~IDE_DFLAG_LBA48;
675 }
676
677 /*
678 * if possible, give fdisk access to more of the drive,
679 * by correcting bios_cyls:
680 */
681 capacity = ide_disk_capacity(drive);
682
683 if ((drive->dev_flags & IDE_DFLAG_FORCED_GEOM) == 0) {
684 if (ata_id_lba48_enabled(drive->id)) {
685 /* compatibility */
686 drive->bios_sect = 63;
687 drive->bios_head = 255;
688 }
689
690 if (drive->bios_sect && drive->bios_head) {
691 unsigned int cap0 = capacity; /* truncate to 32 bits */
692 unsigned int cylsz, cyl;
693
694 if (cap0 != capacity)
695 drive->bios_cyl = 65535;
696 else {
697 cylsz = drive->bios_sect * drive->bios_head;
698 cyl = cap0 / cylsz;
699 if (cyl > 65535)
700 cyl = 65535;
701 if (cyl > drive->bios_cyl)
702 drive->bios_cyl = cyl;
703 }
704 }
705 }
706 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
707 drive->name, capacity, sectors_to_MB(capacity));
708
709 /* Only print cache size when it was specified */
710 if (id[ATA_ID_BUF_SIZE])
711 printk(KERN_CONT " w/%dKiB Cache", id[ATA_ID_BUF_SIZE] / 2);
712
713 printk(KERN_CONT ", CHS=%d/%d/%d\n",
714 drive->bios_cyl, drive->bios_head, drive->bios_sect);
715
716 /* write cache enabled? */
717 if ((id[ATA_ID_CSFO] & 1) || ata_id_wcache_enabled(id))
718 drive->dev_flags |= IDE_DFLAG_WCACHE;
719
720 set_wcache(drive, 1);
721 }
722
723 static void ide_cacheflush_p(ide_drive_t *drive)
724 {
725 if (ata_id_flush_enabled(drive->id) == 0 ||
726 (drive->dev_flags & IDE_DFLAG_WCACHE) == 0)
727 return;
728
729 if (do_idedisk_flushcache(drive))
730 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
731 }
732
733 static void ide_disk_remove(ide_drive_t *drive)
734 {
735 struct ide_disk_obj *idkp = drive->driver_data;
736 struct gendisk *g = idkp->disk;
737
738 ide_proc_unregister_driver(drive, idkp->driver);
739
740 del_gendisk(g);
741
742 ide_cacheflush_p(drive);
743
744 ide_disk_put(idkp);
745 }
746
747 static void ide_disk_release(struct kref *kref)
748 {
749 struct ide_disk_obj *idkp = to_ide_disk(kref);
750 ide_drive_t *drive = idkp->drive;
751 struct gendisk *g = idkp->disk;
752
753 drive->driver_data = NULL;
754 g->private_data = NULL;
755 put_disk(g);
756 kfree(idkp);
757 }
758
759 static int ide_disk_probe(ide_drive_t *drive);
760
761 /*
762 * On HPA drives the capacity needs to be
763 * reinitilized on resume otherwise the disk
764 * can not be used and a hard reset is required
765 */
766 static void ide_disk_resume(ide_drive_t *drive)
767 {
768 if (ata_id_hpa_enabled(drive->id))
769 init_idedisk_capacity(drive);
770 }
771
772 static void ide_device_shutdown(ide_drive_t *drive)
773 {
774 #ifdef CONFIG_ALPHA
775 /* On Alpha, halt(8) doesn't actually turn the machine off,
776 it puts you into the sort of firmware monitor. Typically,
777 it's used to boot another kernel image, so it's not much
778 different from reboot(8). Therefore, we don't need to
779 spin down the disk in this case, especially since Alpha
780 firmware doesn't handle disks in standby mode properly.
781 On the other hand, it's reasonably safe to turn the power
782 off when the shutdown process reaches the firmware prompt,
783 as the firmware initialization takes rather long time -
784 at least 10 seconds, which should be sufficient for
785 the disk to expire its write cache. */
786 if (system_state != SYSTEM_POWER_OFF) {
787 #else
788 if (system_state == SYSTEM_RESTART) {
789 #endif
790 ide_cacheflush_p(drive);
791 return;
792 }
793
794 printk(KERN_INFO "Shutdown: %s\n", drive->name);
795
796 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
797 }
798
799 static ide_driver_t idedisk_driver = {
800 .gen_driver = {
801 .owner = THIS_MODULE,
802 .name = "ide-disk",
803 .bus = &ide_bus_type,
804 },
805 .probe = ide_disk_probe,
806 .remove = ide_disk_remove,
807 .resume = ide_disk_resume,
808 .shutdown = ide_device_shutdown,
809 .version = IDEDISK_VERSION,
810 .do_request = ide_do_rw_disk,
811 .end_request = ide_end_request,
812 .error = __ide_error,
813 #ifdef CONFIG_IDE_PROC_FS
814 .proc = ide_disk_proc,
815 .settings = ide_disk_settings,
816 #endif
817 };
818
819 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
820 {
821 ide_task_t task;
822
823 memset(&task, 0, sizeof(task));
824 task.tf.command = on ? ATA_CMD_MEDIA_LOCK : ATA_CMD_MEDIA_UNLOCK;
825 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
826
827 return ide_no_data_taskfile(drive, &task);
828 }
829
830 static int idedisk_open(struct inode *inode, struct file *filp)
831 {
832 struct gendisk *disk = inode->i_bdev->bd_disk;
833 struct ide_disk_obj *idkp;
834 ide_drive_t *drive;
835
836 idkp = ide_disk_get(disk);
837 if (idkp == NULL)
838 return -ENXIO;
839
840 drive = idkp->drive;
841
842 idkp->openers++;
843
844 if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
845 check_disk_change(inode->i_bdev);
846 /*
847 * Ignore the return code from door_lock,
848 * since the open() has already succeeded,
849 * and the door_lock is irrelevant at this point.
850 */
851 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
852 idedisk_set_doorlock(drive, 1))
853 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
854 }
855 return 0;
856 }
857
858 static int idedisk_release(struct inode *inode, struct file *filp)
859 {
860 struct gendisk *disk = inode->i_bdev->bd_disk;
861 struct ide_disk_obj *idkp = ide_disk_g(disk);
862 ide_drive_t *drive = idkp->drive;
863
864 if (idkp->openers == 1)
865 ide_cacheflush_p(drive);
866
867 if ((drive->dev_flags & IDE_DFLAG_REMOVABLE) && idkp->openers == 1) {
868 if ((drive->dev_flags & IDE_DFLAG_DOORLOCKING) &&
869 idedisk_set_doorlock(drive, 0))
870 drive->dev_flags &= ~IDE_DFLAG_DOORLOCKING;
871 }
872
873 idkp->openers--;
874
875 ide_disk_put(idkp);
876
877 return 0;
878 }
879
880 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
881 {
882 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
883 ide_drive_t *drive = idkp->drive;
884
885 geo->heads = drive->bios_head;
886 geo->sectors = drive->bios_sect;
887 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
888 return 0;
889 }
890
891 static int idedisk_media_changed(struct gendisk *disk)
892 {
893 struct ide_disk_obj *idkp = ide_disk_g(disk);
894 ide_drive_t *drive = idkp->drive;
895
896 /* do not scan partitions twice if this is a removable device */
897 if (drive->dev_flags & IDE_DFLAG_ATTACH) {
898 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
899 return 0;
900 }
901
902 /* if removable, always assume it was changed */
903 return !!(drive->dev_flags & IDE_DFLAG_REMOVABLE);
904 }
905
906 static int idedisk_revalidate_disk(struct gendisk *disk)
907 {
908 struct ide_disk_obj *idkp = ide_disk_g(disk);
909 set_capacity(disk, ide_disk_capacity(idkp->drive));
910 return 0;
911 }
912
913 static struct block_device_operations idedisk_ops = {
914 .owner = THIS_MODULE,
915 .open = idedisk_open,
916 .release = idedisk_release,
917 .ioctl = ide_disk_ioctl,
918 .getgeo = idedisk_getgeo,
919 .media_changed = idedisk_media_changed,
920 .revalidate_disk = idedisk_revalidate_disk
921 };
922
923 MODULE_DESCRIPTION("ATA DISK Driver");
924
925 static int ide_disk_probe(ide_drive_t *drive)
926 {
927 struct ide_disk_obj *idkp;
928 struct gendisk *g;
929
930 /* strstr("foo", "") is non-NULL */
931 if (!strstr("ide-disk", drive->driver_req))
932 goto failed;
933
934 if (drive->media != ide_disk)
935 goto failed;
936
937 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
938 if (!idkp)
939 goto failed;
940
941 g = alloc_disk_node(IDE_DISK_MINORS, hwif_to_node(drive->hwif));
942 if (!g)
943 goto out_free_idkp;
944
945 ide_init_disk(g, drive);
946
947 kref_init(&idkp->kref);
948
949 idkp->drive = drive;
950 idkp->driver = &idedisk_driver;
951 idkp->disk = g;
952
953 g->private_data = &idkp->driver;
954
955 drive->driver_data = idkp;
956
957 idedisk_setup(drive);
958 if ((drive->dev_flags & IDE_DFLAG_LBA) == 0 &&
959 (drive->head == 0 || drive->head > 16)) {
960 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
961 drive->name, drive->head);
962 drive->dev_flags &= ~IDE_DFLAG_ATTACH;
963 } else
964 drive->dev_flags |= IDE_DFLAG_ATTACH;
965
966 g->minors = IDE_DISK_MINORS;
967 g->driverfs_dev = &drive->gendev;
968 g->flags |= GENHD_FL_EXT_DEVT;
969 if (drive->dev_flags & IDE_DFLAG_REMOVABLE)
970 g->flags = GENHD_FL_REMOVABLE;
971 set_capacity(g, ide_disk_capacity(drive));
972 g->fops = &idedisk_ops;
973 add_disk(g);
974 return 0;
975
976 out_free_idkp:
977 kfree(idkp);
978 failed:
979 return -ENODEV;
980 }
981
982 static void __exit idedisk_exit(void)
983 {
984 driver_unregister(&idedisk_driver.gen_driver);
985 }
986
987 static int __init idedisk_init(void)
988 {
989 return driver_register(&idedisk_driver.gen_driver);
990 }
991
992 MODULE_ALIAS("ide:*m-disk*");
993 MODULE_ALIAS("ide-disk");
994 module_init(idedisk_init);
995 module_exit(idedisk_exit);
996 MODULE_LICENSE("GPL");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree