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