?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[wrt350n-kernel.git] / drivers / ide / ide-disk.c
blobc5e4ecb57becc2c991af022350512d6be3fa2561
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 //#define DEBUG
20
21 #include <linux/module.h>
22 #include <linux/types.h>
23 #include <linux/string.h>
24 #include <linux/kernel.h>
25 #include <linux/timer.h>
26 #include <linux/mm.h>
27 #include <linux/interrupt.h>
28 #include <linux/major.h>
29 #include <linux/errno.h>
30 #include <linux/genhd.h>
31 #include <linux/slab.h>
32 #include <linux/delay.h>
33 #include <linux/mutex.h>
34 #include <linux/leds.h>
35
36 #define _IDE_DISK
37
38 #include <linux/ide.h>
39
40 #include <asm/byteorder.h>
41 #include <asm/irq.h>
42 #include <asm/uaccess.h>
43 #include <asm/io.h>
44 #include <asm/div64.h>
45
46 struct ide_disk_obj {
47 ide_drive_t *drive;
48 ide_driver_t *driver;
49 struct gendisk *disk;
50 struct kref kref;
51 unsigned int openers; /* protected by BKL for now */
52 };
53
54 static DEFINE_MUTEX(idedisk_ref_mutex);
55
56 #define to_ide_disk(obj) container_of(obj, struct ide_disk_obj, kref)
57
58 #define ide_disk_g(disk) \
59 container_of((disk)->private_data, struct ide_disk_obj, driver)
60
61 static struct ide_disk_obj *ide_disk_get(struct gendisk *disk)
62 {
63 struct ide_disk_obj *idkp = NULL;
64
65 mutex_lock(&idedisk_ref_mutex);
66 idkp = ide_disk_g(disk);
67 if (idkp)
68 kref_get(&idkp->kref);
69 mutex_unlock(&idedisk_ref_mutex);
70 return idkp;
71 }
72
73 static void ide_disk_release(struct kref *);
74
75 static void ide_disk_put(struct ide_disk_obj *idkp)
76 {
77 mutex_lock(&idedisk_ref_mutex);
78 kref_put(&idkp->kref, ide_disk_release);
79 mutex_unlock(&idedisk_ref_mutex);
80 }
81
82 /*
83 * lba_capacity_is_ok() performs a sanity check on the claimed "lba_capacity"
84 * value for this drive (from its reported identification information).
85 *
86 * Returns: 1 if lba_capacity looks sensible
87 * 0 otherwise
88 *
89 * It is called only once for each drive.
90 */
91 static int lba_capacity_is_ok (struct hd_driveid *id)
92 {
93 unsigned long lba_sects, chs_sects, head, tail;
94
95 /* No non-LBA info .. so valid! */
96 if (id->cyls == 0)
97 return 1;
98
99 /*
100 * The ATA spec tells large drives to return
101 * C/H/S = 16383/16/63 independent of their size.
102 * Some drives can be jumpered to use 15 heads instead of 16.
103 * Some drives can be jumpered to use 4092 cyls instead of 16383.
104 */
105 if ((id->cyls == 16383
106 || (id->cyls == 4092 && id->cur_cyls == 16383)) &&
107 id->sectors == 63 &&
108 (id->heads == 15 || id->heads == 16) &&
109 (id->lba_capacity >= 16383*63*id->heads))
110 return 1;
111
112 lba_sects = id->lba_capacity;
113 chs_sects = id->cyls * id->heads * id->sectors;
114
115 /* perform a rough sanity check on lba_sects: within 10% is OK */
116 if ((lba_sects - chs_sects) < chs_sects/10)
117 return 1;
118
119 /* some drives have the word order reversed */
120 head = ((lba_sects >> 16) & 0xffff);
121 tail = (lba_sects & 0xffff);
122 lba_sects = (head | (tail << 16));
123 if ((lba_sects - chs_sects) < chs_sects/10) {
124 id->lba_capacity = lba_sects;
125 return 1; /* lba_capacity is (now) good */
126 }
127
128 return 0; /* lba_capacity value may be bad */
129 }
130
131 static const u8 ide_rw_cmds[] = {
132 WIN_MULTREAD,
133 WIN_MULTWRITE,
134 WIN_MULTREAD_EXT,
135 WIN_MULTWRITE_EXT,
136 WIN_READ,
137 WIN_WRITE,
138 WIN_READ_EXT,
139 WIN_WRITE_EXT,
140 WIN_READDMA,
141 WIN_WRITEDMA,
142 WIN_READDMA_EXT,
143 WIN_WRITEDMA_EXT,
144 };
145
146 static const u8 ide_data_phases[] = {
147 TASKFILE_MULTI_IN,
148 TASKFILE_MULTI_OUT,
149 TASKFILE_IN,
150 TASKFILE_OUT,
151 TASKFILE_IN_DMA,
152 TASKFILE_OUT_DMA,
153 };
154
155 static void ide_tf_set_cmd(ide_drive_t *drive, ide_task_t *task, u8 dma)
156 {
157 u8 index, lba48, write;
158
159 lba48 = (task->tf_flags & IDE_TFLAG_LBA48) ? 2 : 0;
160 write = (task->tf_flags & IDE_TFLAG_WRITE) ? 1 : 0;
161
162 if (dma)
163 index = drive->vdma ? 4 : 8;
164 else
165 index = drive->mult_count ? 0 : 4;
166
167 task->tf.command = ide_rw_cmds[index + lba48 + write];
168
169 if (dma)
170 index = 8; /* fixup index */
171
172 task->data_phase = ide_data_phases[index / 2 + write];
173 }
174
175 /*
176 * __ide_do_rw_disk() issues READ and WRITE commands to a disk,
177 * using LBA if supported, or CHS otherwise, to address sectors.
178 */
179 static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq, sector_t block)
180 {
181 ide_hwif_t *hwif = HWIF(drive);
182 unsigned int dma = drive->using_dma;
183 u16 nsectors = (u16)rq->nr_sectors;
184 u8 lba48 = (drive->addressing == 1) ? 1 : 0;
185 ide_task_t task;
186 struct ide_taskfile *tf = &task.tf;
187 ide_startstop_t rc;
188
189 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
190 if (block + rq->nr_sectors > 1ULL << 28)
191 dma = 0;
192 else
193 lba48 = 0;
194 }
195
196 if (!dma) {
197 ide_init_sg_cmd(drive, rq);
198 ide_map_sg(drive, rq);
199 }
200
201 memset(&task, 0, sizeof(task));
202 task.tf_flags = IDE_TFLAG_NO_SELECT_MASK; /* FIXME? */
203 task.tf_flags |= (IDE_TFLAG_TF | IDE_TFLAG_DEVICE);
204
205 if (drive->select.b.lba) {
206 if (lba48) {
207 pr_debug("%s: LBA=0x%012llx\n", drive->name,
208 (unsigned long long)block);
209
210 tf->hob_nsect = (nsectors >> 8) & 0xff;
211 tf->hob_lbal = (u8)(block >> 24);
212 if (sizeof(block) != 4) {
213 tf->hob_lbam = (u8)((u64)block >> 32);
214 tf->hob_lbah = (u8)((u64)block >> 40);
215 }
216
217 tf->nsect = nsectors & 0xff;
218 tf->lbal = (u8) block;
219 tf->lbam = (u8)(block >> 8);
220 tf->lbah = (u8)(block >> 16);
221
222 task.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
223 } else {
224 tf->nsect = nsectors & 0xff;
225 tf->lbal = block;
226 tf->lbam = block >>= 8;
227 tf->lbah = block >>= 8;
228 tf->device = (block >> 8) & 0xf;
229 }
230 } else {
231 unsigned int sect,head,cyl,track;
232 track = (int)block / drive->sect;
233 sect = (int)block % drive->sect + 1;
234 head = track % drive->head;
235 cyl = track / drive->head;
236
237 pr_debug("%s: CHS=%u/%u/%u\n", drive->name, cyl, head, sect);
238
239 tf->nsect = nsectors & 0xff;
240 tf->lbal = sect;
241 tf->lbam = cyl;
242 tf->lbah = cyl >> 8;
243 tf->device = head;
244 }
245
246 if (rq_data_dir(rq))
247 task.tf_flags |= IDE_TFLAG_WRITE;
248
249 ide_tf_set_cmd(drive, &task, dma);
250 if (!dma)
251 hwif->data_phase = task.data_phase;
252 task.rq = rq;
253
254 rc = do_rw_taskfile(drive, &task);
255
256 if (rc == ide_stopped && dma) {
257 /* fallback to PIO */
258 task.tf_flags |= IDE_TFLAG_DMA_PIO_FALLBACK;
259 ide_tf_set_cmd(drive, &task, 0);
260 hwif->data_phase = task.data_phase;
261 ide_init_sg_cmd(drive, rq);
262 rc = do_rw_taskfile(drive, &task);
263 }
264
265 return rc;
266 }
267
268 /*
269 * 268435455 == 137439 MB or 28bit limit
270 * 320173056 == 163929 MB or 48bit addressing
271 * 1073741822 == 549756 MB or 48bit addressing fake drive
272 */
273
274 static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, sector_t block)
275 {
276 ide_hwif_t *hwif = HWIF(drive);
277
278 BUG_ON(drive->blocked);
279
280 if (!blk_fs_request(rq)) {
281 blk_dump_rq_flags(rq, "ide_do_rw_disk - bad command");
282 ide_end_request(drive, 0, 0);
283 return ide_stopped;
284 }
285
286 ledtrig_ide_activity();
287
288 pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
289 drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
290 (unsigned long long)block, rq->nr_sectors,
291 (unsigned long)rq->buffer);
292
293 if (hwif->rw_disk)
294 hwif->rw_disk(drive, rq);
295
296 return __ide_do_rw_disk(drive, rq, block);
297 }
298
299 /*
300 * Queries for true maximum capacity of the drive.
301 * Returns maximum LBA address (> 0) of the drive, 0 if failed.
302 */
303 static u64 idedisk_read_native_max_address(ide_drive_t *drive, int lba48)
304 {
305 ide_task_t args;
306 struct ide_taskfile *tf = &args.tf;
307 u64 addr = 0;
308
309 /* Create IDE/ATA command request structure */
310 memset(&args, 0, sizeof(ide_task_t));
311 if (lba48)
312 tf->command = WIN_READ_NATIVE_MAX_EXT;
313 else
314 tf->command = WIN_READ_NATIVE_MAX;
315 tf->device = ATA_LBA;
316 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
317 if (lba48)
318 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
319 /* submit command request */
320 ide_no_data_taskfile(drive, &args);
321
322 /* if OK, compute maximum address value */
323 if ((tf->status & 0x01) == 0)
324 addr = ide_get_lba_addr(tf, lba48) + 1;
325
326 return addr;
327 }
328
329 /*
330 * Sets maximum virtual LBA address of the drive.
331 * Returns new maximum virtual LBA address (> 0) or 0 on failure.
332 */
333 static u64 idedisk_set_max_address(ide_drive_t *drive, u64 addr_req, int lba48)
334 {
335 ide_task_t args;
336 struct ide_taskfile *tf = &args.tf;
337 u64 addr_set = 0;
338
339 addr_req--;
340 /* Create IDE/ATA command request structure */
341 memset(&args, 0, sizeof(ide_task_t));
342 tf->lbal = (addr_req >> 0) & 0xff;
343 tf->lbam = (addr_req >>= 8) & 0xff;
344 tf->lbah = (addr_req >>= 8) & 0xff;
345 if (lba48) {
346 tf->hob_lbal = (addr_req >>= 8) & 0xff;
347 tf->hob_lbam = (addr_req >>= 8) & 0xff;
348 tf->hob_lbah = (addr_req >>= 8) & 0xff;
349 tf->command = WIN_SET_MAX_EXT;
350 } else {
351 tf->device = (addr_req >>= 8) & 0x0f;
352 tf->command = WIN_SET_MAX;
353 }
354 tf->device |= ATA_LBA;
355 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
356 if (lba48)
357 args.tf_flags |= (IDE_TFLAG_LBA48 | IDE_TFLAG_HOB);
358 /* submit command request */
359 ide_no_data_taskfile(drive, &args);
360 /* if OK, compute maximum address value */
361 if ((tf->status & 0x01) == 0)
362 addr_set = ide_get_lba_addr(tf, lba48) + 1;
363
364 return addr_set;
365 }
366
367 static unsigned long long sectors_to_MB(unsigned long long n)
368 {
369 n <<= 9; /* make it bytes */
370 do_div(n, 1000000); /* make it MB */
371 return n;
372 }
373
374 /*
375 * Bits 10 of command_set_1 and cfs_enable_1 must be equal,
376 * so on non-buggy drives we need test only one.
377 * However, we should also check whether these fields are valid.
378 */
379 static inline int idedisk_supports_hpa(const struct hd_driveid *id)
380 {
381 return (id->command_set_1 & 0x0400) && (id->cfs_enable_1 & 0x0400);
382 }
383
384 /*
385 * The same here.
386 */
387 static inline int idedisk_supports_lba48(const struct hd_driveid *id)
388 {
389 return (id->command_set_2 & 0x0400) && (id->cfs_enable_2 & 0x0400)
390 && id->lba_capacity_2;
391 }
392
393 /*
394 * Some disks report total number of sectors instead of
395 * maximum sector address. We list them here.
396 */
397 static const struct drive_list_entry hpa_list[] = {
398 { "ST340823A", NULL },
399 { "ST320413A", NULL },
400 <<<<<<< HEAD:drivers/ide/ide-disk.c
401 =======
402 { "ST310211A", NULL },
403 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/ide/ide-disk.c
404 { NULL, NULL }
405 };
406
407 static void idedisk_check_hpa(ide_drive_t *drive)
408 {
409 unsigned long long capacity, set_max;
410 int lba48 = idedisk_supports_lba48(drive->id);
411
412 capacity = drive->capacity64;
413
414 set_max = idedisk_read_native_max_address(drive, lba48);
415
416 if (ide_in_drive_list(drive->id, hpa_list)) {
417 /*
418 * Since we are inclusive wrt to firmware revisions do this
419 * extra check and apply the workaround only when needed.
420 */
421 if (set_max == capacity + 1)
422 set_max--;
423 }
424
425 if (set_max <= capacity)
426 return;
427
428 printk(KERN_INFO "%s: Host Protected Area detected.\n"
429 "\tcurrent capacity is %llu sectors (%llu MB)\n"
430 "\tnative capacity is %llu sectors (%llu MB)\n",
431 drive->name,
432 capacity, sectors_to_MB(capacity),
433 set_max, sectors_to_MB(set_max));
434
435 set_max = idedisk_set_max_address(drive, set_max, lba48);
436
437 if (set_max) {
438 drive->capacity64 = set_max;
439 printk(KERN_INFO "%s: Host Protected Area disabled.\n",
440 drive->name);
441 }
442 }
443
444 /*
445 * Compute drive->capacity, the full capacity of the drive
446 * Called with drive->id != NULL.
447 *
448 * To compute capacity, this uses either of
449 *
450 * 1. CHS value set by user (whatever user sets will be trusted)
451 * 2. LBA value from target drive (require new ATA feature)
452 * 3. LBA value from system BIOS (new one is OK, old one may break)
453 * 4. CHS value from system BIOS (traditional style)
454 *
455 * in above order (i.e., if value of higher priority is available,
456 * reset will be ignored).
457 */
458 static void init_idedisk_capacity (ide_drive_t *drive)
459 {
460 struct hd_driveid *id = drive->id;
461 /*
462 * If this drive supports the Host Protected Area feature set,
463 * then we may need to change our opinion about the drive's capacity.
464 */
465 int hpa = idedisk_supports_hpa(id);
466
467 if (idedisk_supports_lba48(id)) {
468 /* drive speaks 48-bit LBA */
469 drive->select.b.lba = 1;
470 drive->capacity64 = id->lba_capacity_2;
471 if (hpa)
472 idedisk_check_hpa(drive);
473 } else if ((id->capability & 2) && lba_capacity_is_ok(id)) {
474 /* drive speaks 28-bit LBA */
475 drive->select.b.lba = 1;
476 drive->capacity64 = id->lba_capacity;
477 if (hpa)
478 idedisk_check_hpa(drive);
479 } else {
480 /* drive speaks boring old 28-bit CHS */
481 drive->capacity64 = drive->cyl * drive->head * drive->sect;
482 }
483 }
484
485 static sector_t idedisk_capacity (ide_drive_t *drive)
486 {
487 return drive->capacity64 - drive->sect0;
488 }
489
490 #ifdef CONFIG_IDE_PROC_FS
491 static int smart_enable(ide_drive_t *drive)
492 {
493 ide_task_t args;
494 struct ide_taskfile *tf = &args.tf;
495
496 memset(&args, 0, sizeof(ide_task_t));
497 tf->feature = SMART_ENABLE;
498 tf->lbam = SMART_LCYL_PASS;
499 tf->lbah = SMART_HCYL_PASS;
500 tf->command = WIN_SMART;
501 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
502 return ide_no_data_taskfile(drive, &args);
503 }
504
505 static int get_smart_data(ide_drive_t *drive, u8 *buf, u8 sub_cmd)
506 {
507 ide_task_t args;
508 struct ide_taskfile *tf = &args.tf;
509
510 memset(&args, 0, sizeof(ide_task_t));
511 tf->feature = sub_cmd;
512 tf->nsect = 0x01;
513 tf->lbam = SMART_LCYL_PASS;
514 tf->lbah = SMART_HCYL_PASS;
515 tf->command = WIN_SMART;
516 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
517 args.data_phase = TASKFILE_IN;
518 (void) smart_enable(drive);
519 return ide_raw_taskfile(drive, &args, buf, 1);
520 }
521
522 static int proc_idedisk_read_cache
523 (char *page, char **start, off_t off, int count, int *eof, void *data)
524 {
525 ide_drive_t *drive = (ide_drive_t *) data;
526 char *out = page;
527 int len;
528
529 if (drive->id_read)
530 len = sprintf(out,"%i\n", drive->id->buf_size / 2);
531 else
532 len = sprintf(out,"(none)\n");
533 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
534 }
535
536 static int proc_idedisk_read_capacity
537 (char *page, char **start, off_t off, int count, int *eof, void *data)
538 {
539 ide_drive_t*drive = (ide_drive_t *)data;
540 int len;
541
542 len = sprintf(page,"%llu\n", (long long)idedisk_capacity(drive));
543 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
544 }
545
546 static int proc_idedisk_read_smart_thresholds
547 (char *page, char **start, off_t off, int count, int *eof, void *data)
548 {
549 ide_drive_t *drive = (ide_drive_t *)data;
550 int len = 0, i = 0;
551
552 if (get_smart_data(drive, page, SMART_READ_THRESHOLDS) == 0) {
553 unsigned short *val = (unsigned short *) page;
554 char *out = ((char *)val) + (SECTOR_WORDS * 4);
555 page = out;
556 do {
557 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
558 val += 1;
559 } while (i < (SECTOR_WORDS * 2));
560 len = out - page;
561 }
562 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
563 }
564
565 static int proc_idedisk_read_smart_values
566 (char *page, char **start, off_t off, int count, int *eof, void *data)
567 {
568 ide_drive_t *drive = (ide_drive_t *)data;
569 int len = 0, i = 0;
570
571 if (get_smart_data(drive, page, SMART_READ_VALUES) == 0) {
572 unsigned short *val = (unsigned short *) page;
573 char *out = ((char *)val) + (SECTOR_WORDS * 4);
574 page = out;
575 do {
576 out += sprintf(out, "%04x%c", le16_to_cpu(*val), (++i & 7) ? ' ' : '\n');
577 val += 1;
578 } while (i < (SECTOR_WORDS * 2));
579 len = out - page;
580 }
581 PROC_IDE_READ_RETURN(page,start,off,count,eof,len);
582 }
583
584 static ide_proc_entry_t idedisk_proc[] = {
585 { "cache", S_IFREG|S_IRUGO, proc_idedisk_read_cache, NULL },
586 { "capacity", S_IFREG|S_IRUGO, proc_idedisk_read_capacity, NULL },
587 { "geometry", S_IFREG|S_IRUGO, proc_ide_read_geometry, NULL },
588 { "smart_values", S_IFREG|S_IRUSR, proc_idedisk_read_smart_values, NULL },
589 { "smart_thresholds", S_IFREG|S_IRUSR, proc_idedisk_read_smart_thresholds, NULL },
590 { NULL, 0, NULL, NULL }
591 };
592 #endif /* CONFIG_IDE_PROC_FS */
593
594 static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
595 {
596 ide_drive_t *drive = q->queuedata;
597 ide_task_t *task = kmalloc(sizeof(*task), GFP_ATOMIC);
598
599 /* FIXME: map struct ide_taskfile on rq->cmd[] */
600 BUG_ON(task == NULL);
601
602 memset(task, 0, sizeof(*task));
603 if (ide_id_has_flush_cache_ext(drive->id) &&
604 (drive->capacity64 >= (1UL << 28)))
605 task->tf.command = WIN_FLUSH_CACHE_EXT;
606 else
607 task->tf.command = WIN_FLUSH_CACHE;
608 task->tf_flags = IDE_TFLAG_OUT_TF | IDE_TFLAG_OUT_DEVICE |
609 IDE_TFLAG_DYN;
610 task->data_phase = TASKFILE_NO_DATA;
611
612 rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
613 rq->cmd_flags |= REQ_SOFTBARRIER;
614 rq->special = task;
615 }
616
617 /*
618 * This is tightly woven into the driver->do_special can not touch.
619 * DON'T do it again until a total personality rewrite is committed.
620 */
621 static int set_multcount(ide_drive_t *drive, int arg)
622 {
623 struct request rq;
624
625 if (arg < 0 || arg > drive->id->max_multsect)
626 return -EINVAL;
627
628 if (drive->special.b.set_multmode)
629 return -EBUSY;
630
631 ide_init_drive_cmd (&rq);
632 rq.cmd_type = REQ_TYPE_ATA_TASKFILE;
633
634 drive->mult_req = arg;
635 drive->special.b.set_multmode = 1;
636 (void) ide_do_drive_cmd (drive, &rq, ide_wait);
637 return (drive->mult_count == arg) ? 0 : -EIO;
638 }
639
640 static int set_nowerr(ide_drive_t *drive, int arg)
641 {
642 if (arg < 0 || arg > 1)
643 return -EINVAL;
644
645 if (ide_spin_wait_hwgroup(drive))
646 return -EBUSY;
647 drive->nowerr = arg;
648 drive->bad_wstat = arg ? BAD_R_STAT : BAD_W_STAT;
649 spin_unlock_irq(&ide_lock);
650 return 0;
651 }
652
653 static void update_ordered(ide_drive_t *drive)
654 {
655 struct hd_driveid *id = drive->id;
656 unsigned ordered = QUEUE_ORDERED_NONE;
657 prepare_flush_fn *prep_fn = NULL;
658
659 if (drive->wcache) {
660 unsigned long long capacity;
661 int barrier;
662 /*
663 * We must avoid issuing commands a drive does not
664 * understand or we may crash it. We check flush cache
665 * is supported. We also check we have the LBA48 flush
666 * cache if the drive capacity is too large. By this
667 * time we have trimmed the drive capacity if LBA48 is
668 * not available so we don't need to recheck that.
669 */
670 capacity = idedisk_capacity(drive);
671 barrier = ide_id_has_flush_cache(id) && !drive->noflush &&
672 (drive->addressing == 0 || capacity <= (1ULL << 28) ||
673 ide_id_has_flush_cache_ext(id));
674
675 printk(KERN_INFO "%s: cache flushes %ssupported\n",
676 drive->name, barrier ? "" : "not ");
677
678 if (barrier) {
679 ordered = QUEUE_ORDERED_DRAIN_FLUSH;
680 prep_fn = idedisk_prepare_flush;
681 }
682 } else
683 ordered = QUEUE_ORDERED_DRAIN;
684
685 blk_queue_ordered(drive->queue, ordered, prep_fn);
686 }
687
688 static int write_cache(ide_drive_t *drive, int arg)
689 {
690 ide_task_t args;
691 int err = 1;
692
693 if (arg < 0 || arg > 1)
694 return -EINVAL;
695
696 if (ide_id_has_flush_cache(drive->id)) {
697 memset(&args, 0, sizeof(ide_task_t));
698 args.tf.feature = arg ?
699 SETFEATURES_EN_WCACHE : SETFEATURES_DIS_WCACHE;
700 args.tf.command = WIN_SETFEATURES;
701 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
702 err = ide_no_data_taskfile(drive, &args);
703 if (err == 0)
704 drive->wcache = arg;
705 }
706
707 update_ordered(drive);
708
709 return err;
710 }
711
712 static int do_idedisk_flushcache (ide_drive_t *drive)
713 {
714 ide_task_t args;
715
716 memset(&args, 0, sizeof(ide_task_t));
717 if (ide_id_has_flush_cache_ext(drive->id))
718 args.tf.command = WIN_FLUSH_CACHE_EXT;
719 else
720 args.tf.command = WIN_FLUSH_CACHE;
721 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
722 return ide_no_data_taskfile(drive, &args);
723 }
724
725 static int set_acoustic (ide_drive_t *drive, int arg)
726 {
727 ide_task_t args;
728
729 if (arg < 0 || arg > 254)
730 return -EINVAL;
731
732 memset(&args, 0, sizeof(ide_task_t));
733 args.tf.feature = arg ? SETFEATURES_EN_AAM : SETFEATURES_DIS_AAM;
734 args.tf.nsect = arg;
735 args.tf.command = WIN_SETFEATURES;
736 args.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
737 ide_no_data_taskfile(drive, &args);
738 drive->acoustic = arg;
739 return 0;
740 }
741
742 /*
743 * drive->addressing:
744 * 0: 28-bit
745 * 1: 48-bit
746 * 2: 48-bit capable doing 28-bit
747 */
748 static int set_lba_addressing(ide_drive_t *drive, int arg)
749 {
750 if (arg < 0 || arg > 2)
751 return -EINVAL;
752
753 drive->addressing = 0;
754
755 if (drive->hwif->host_flags & IDE_HFLAG_NO_LBA48)
756 return 0;
757
758 if (!idedisk_supports_lba48(drive->id))
759 return -EIO;
760 drive->addressing = arg;
761 return 0;
762 }
763
764 #ifdef CONFIG_IDE_PROC_FS
765 static void idedisk_add_settings(ide_drive_t *drive)
766 {
767 struct hd_driveid *id = drive->id;
768
769 ide_add_setting(drive, "bios_cyl", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->bios_cyl, NULL);
770 ide_add_setting(drive, "bios_head", SETTING_RW, TYPE_BYTE, 0, 255, 1, 1, &drive->bios_head, NULL);
771 ide_add_setting(drive, "bios_sect", SETTING_RW, TYPE_BYTE, 0, 63, 1, 1, &drive->bios_sect, NULL);
772 ide_add_setting(drive, "address", SETTING_RW, TYPE_BYTE, 0, 2, 1, 1, &drive->addressing, set_lba_addressing);
773 ide_add_setting(drive, "multcount", SETTING_RW, TYPE_BYTE, 0, id->max_multsect, 1, 1, &drive->mult_count, set_multcount);
774 ide_add_setting(drive, "nowerr", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->nowerr, set_nowerr);
775 ide_add_setting(drive, "lun", SETTING_RW, TYPE_INT, 0, 7, 1, 1, &drive->lun, NULL);
776 ide_add_setting(drive, "wcache", SETTING_RW, TYPE_BYTE, 0, 1, 1, 1, &drive->wcache, write_cache);
777 ide_add_setting(drive, "acoustic", SETTING_RW, TYPE_BYTE, 0, 254, 1, 1, &drive->acoustic, set_acoustic);
778 ide_add_setting(drive, "failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->failures, NULL);
779 ide_add_setting(drive, "max_failures", SETTING_RW, TYPE_INT, 0, 65535, 1, 1, &drive->max_failures, NULL);
780 }
781 #else
782 static inline void idedisk_add_settings(ide_drive_t *drive) { ; }
783 #endif
784
785 static void idedisk_setup (ide_drive_t *drive)
786 {
787 ide_hwif_t *hwif = drive->hwif;
788 struct hd_driveid *id = drive->id;
789 unsigned long long capacity;
790
791 idedisk_add_settings(drive);
792
793 if (drive->id_read == 0)
794 return;
795
796 if (drive->removable) {
797 /*
798 * Removable disks (eg. SYQUEST); ignore 'WD' drives
799 */
800 if (id->model[0] != 'W' || id->model[1] != 'D') {
801 drive->doorlocking = 1;
802 }
803 }
804
805 (void)set_lba_addressing(drive, 1);
806
807 if (drive->addressing == 1) {
808 int max_s = 2048;
809
810 if (max_s > hwif->rqsize)
811 max_s = hwif->rqsize;
812
813 blk_queue_max_sectors(drive->queue, max_s);
814 }
815
816 printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name, drive->queue->max_sectors / 2);
817
818 /* calculate drive capacity, and select LBA if possible */
819 init_idedisk_capacity (drive);
820
821 /* limit drive capacity to 137GB if LBA48 cannot be used */
822 if (drive->addressing == 0 && drive->capacity64 > 1ULL << 28) {
823 printk(KERN_WARNING "%s: cannot use LBA48 - full capacity "
824 "%llu sectors (%llu MB)\n",
825 drive->name, (unsigned long long)drive->capacity64,
826 sectors_to_MB(drive->capacity64));
827 drive->capacity64 = 1ULL << 28;
828 }
829
830 if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && drive->addressing) {
831 if (drive->capacity64 > 1ULL << 28) {
832 printk(KERN_INFO "%s: cannot use LBA48 DMA - PIO mode will"
833 " be used for accessing sectors > %u\n",
834 drive->name, 1 << 28);
835 } else
836 drive->addressing = 0;
837 }
838
839 /*
840 * if possible, give fdisk access to more of the drive,
841 * by correcting bios_cyls:
842 */
843 capacity = idedisk_capacity (drive);
844 if (!drive->forced_geom) {
845
846 if (idedisk_supports_lba48(drive->id)) {
847 /* compatibility */
848 drive->bios_sect = 63;
849 drive->bios_head = 255;
850 }
851
852 if (drive->bios_sect && drive->bios_head) {
853 unsigned int cap0 = capacity; /* truncate to 32 bits */
854 unsigned int cylsz, cyl;
855
856 if (cap0 != capacity)
857 drive->bios_cyl = 65535;
858 else {
859 cylsz = drive->bios_sect * drive->bios_head;
860 cyl = cap0 / cylsz;
861 if (cyl > 65535)
862 cyl = 65535;
863 if (cyl > drive->bios_cyl)
864 drive->bios_cyl = cyl;
865 }
866 }
867 }
868 printk(KERN_INFO "%s: %llu sectors (%llu MB)",
869 drive->name, capacity, sectors_to_MB(capacity));
870
871 /* Only print cache size when it was specified */
872 if (id->buf_size)
873 <<<<<<< HEAD:drivers/ide/ide-disk.c
874 printk (" w/%dKiB Cache", id->buf_size/2);
875 =======
876 printk(KERN_CONT " w/%dKiB Cache", id->buf_size / 2);
877 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/ide/ide-disk.c
878
879 printk(KERN_CONT ", CHS=%d/%d/%d\n",
880 drive->bios_cyl, drive->bios_head, drive->bios_sect);
881
882 /* write cache enabled? */
883 if ((id->csfo & 1) || (id->cfs_enable_1 & (1 << 5)))
884 drive->wcache = 1;
885
886 write_cache(drive, 1);
887 }
888
889 static void ide_cacheflush_p(ide_drive_t *drive)
890 {
891 if (!drive->wcache || !ide_id_has_flush_cache(drive->id))
892 return;
893
894 if (do_idedisk_flushcache(drive))
895 printk(KERN_INFO "%s: wcache flush failed!\n", drive->name);
896 }
897
898 static void ide_disk_remove(ide_drive_t *drive)
899 {
900 struct ide_disk_obj *idkp = drive->driver_data;
901 struct gendisk *g = idkp->disk;
902
903 ide_proc_unregister_driver(drive, idkp->driver);
904
905 del_gendisk(g);
906
907 ide_cacheflush_p(drive);
908
909 ide_disk_put(idkp);
910 }
911
912 static void ide_disk_release(struct kref *kref)
913 {
914 struct ide_disk_obj *idkp = to_ide_disk(kref);
915 ide_drive_t *drive = idkp->drive;
916 struct gendisk *g = idkp->disk;
917
918 drive->driver_data = NULL;
919 g->private_data = NULL;
920 put_disk(g);
921 kfree(idkp);
922 }
923
924 static int ide_disk_probe(ide_drive_t *drive);
925
926 /*
927 * On HPA drives the capacity needs to be
928 * reinitilized on resume otherwise the disk
929 * can not be used and a hard reset is required
930 */
931 static void ide_disk_resume(ide_drive_t *drive)
932 {
933 if (idedisk_supports_hpa(drive->id))
934 init_idedisk_capacity(drive);
935 }
936
937 static void ide_device_shutdown(ide_drive_t *drive)
938 {
939 #ifdef CONFIG_ALPHA
940 /* On Alpha, halt(8) doesn't actually turn the machine off,
941 it puts you into the sort of firmware monitor. Typically,
942 it's used to boot another kernel image, so it's not much
943 different from reboot(8). Therefore, we don't need to
944 spin down the disk in this case, especially since Alpha
945 firmware doesn't handle disks in standby mode properly.
946 On the other hand, it's reasonably safe to turn the power
947 off when the shutdown process reaches the firmware prompt,
948 as the firmware initialization takes rather long time -
949 at least 10 seconds, which should be sufficient for
950 the disk to expire its write cache. */
951 if (system_state != SYSTEM_POWER_OFF) {
952 #else
953 if (system_state == SYSTEM_RESTART) {
954 #endif
955 ide_cacheflush_p(drive);
956 return;
957 }
958
959 <<<<<<< HEAD:drivers/ide/ide-disk.c
960 printk("Shutdown: %s\n", drive->name);
961 =======
962 printk(KERN_INFO "Shutdown: %s\n", drive->name);
963
964 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/ide/ide-disk.c
965 drive->gendev.bus->suspend(&drive->gendev, PMSG_SUSPEND);
966 }
967
968 static ide_driver_t idedisk_driver = {
969 .gen_driver = {
970 .owner = THIS_MODULE,
971 .name = "ide-disk",
972 .bus = &ide_bus_type,
973 },
974 .probe = ide_disk_probe,
975 .remove = ide_disk_remove,
976 .resume = ide_disk_resume,
977 .shutdown = ide_device_shutdown,
978 .version = IDEDISK_VERSION,
979 .media = ide_disk,
980 .supports_dsc_overlap = 0,
981 .do_request = ide_do_rw_disk,
982 .end_request = ide_end_request,
983 .error = __ide_error,
984 .abort = __ide_abort,
985 #ifdef CONFIG_IDE_PROC_FS
986 .proc = idedisk_proc,
987 #endif
988 };
989
990 static int idedisk_set_doorlock(ide_drive_t *drive, int on)
991 {
992 ide_task_t task;
993
994 memset(&task, 0, sizeof(task));
995 task.tf.command = on ? WIN_DOORLOCK : WIN_DOORUNLOCK;
996 task.tf_flags = IDE_TFLAG_TF | IDE_TFLAG_DEVICE;
997
998 return ide_no_data_taskfile(drive, &task);
999 }
1000
1001 static int idedisk_open(struct inode *inode, struct file *filp)
1002 {
1003 struct gendisk *disk = inode->i_bdev->bd_disk;
1004 struct ide_disk_obj *idkp;
1005 ide_drive_t *drive;
1006
1007 if (!(idkp = ide_disk_get(disk)))
1008 return -ENXIO;
1009
1010 drive = idkp->drive;
1011
1012 idkp->openers++;
1013
1014 if (drive->removable && idkp->openers == 1) {
1015 check_disk_change(inode->i_bdev);
1016 /*
1017 * Ignore the return code from door_lock,
1018 * since the open() has already succeeded,
1019 * and the door_lock is irrelevant at this point.
1020 */
1021 if (drive->doorlocking && idedisk_set_doorlock(drive, 1))
1022 drive->doorlocking = 0;
1023 }
1024 return 0;
1025 }
1026
1027 static int idedisk_release(struct inode *inode, struct file *filp)
1028 {
1029 struct gendisk *disk = inode->i_bdev->bd_disk;
1030 struct ide_disk_obj *idkp = ide_disk_g(disk);
1031 ide_drive_t *drive = idkp->drive;
1032
1033 if (idkp->openers == 1)
1034 ide_cacheflush_p(drive);
1035
1036 if (drive->removable && idkp->openers == 1) {
1037 if (drive->doorlocking && idedisk_set_doorlock(drive, 0))
1038 drive->doorlocking = 0;
1039 }
1040
1041 idkp->openers--;
1042
1043 ide_disk_put(idkp);
1044
1045 return 0;
1046 }
1047
1048 static int idedisk_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1049 {
1050 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1051 ide_drive_t *drive = idkp->drive;
1052
1053 geo->heads = drive->bios_head;
1054 geo->sectors = drive->bios_sect;
1055 geo->cylinders = (u16)drive->bios_cyl; /* truncate */
1056 return 0;
1057 }
1058
1059 static int idedisk_ioctl(struct inode *inode, struct file *file,
1060 unsigned int cmd, unsigned long arg)
1061 {
1062 unsigned long flags;
1063 struct block_device *bdev = inode->i_bdev;
1064 struct ide_disk_obj *idkp = ide_disk_g(bdev->bd_disk);
1065 ide_drive_t *drive = idkp->drive;
1066 int err, (*setfunc)(ide_drive_t *, int);
1067 u8 *val;
1068
1069 switch (cmd) {
1070 case HDIO_GET_ADDRESS: val = &drive->addressing; goto read_val;
1071 case HDIO_GET_MULTCOUNT: val = &drive->mult_count; goto read_val;
1072 case HDIO_GET_NOWERR: val = &drive->nowerr; goto read_val;
1073 case HDIO_GET_WCACHE: val = &drive->wcache; goto read_val;
1074 case HDIO_GET_ACOUSTIC: val = &drive->acoustic; goto read_val;
1075 case HDIO_SET_ADDRESS: setfunc = set_lba_addressing; goto set_val;
1076 case HDIO_SET_MULTCOUNT: setfunc = set_multcount; goto set_val;
1077 case HDIO_SET_NOWERR: setfunc = set_nowerr; goto set_val;
1078 case HDIO_SET_WCACHE: setfunc = write_cache; goto set_val;
1079 case HDIO_SET_ACOUSTIC: setfunc = set_acoustic; goto set_val;
1080 }
1081
1082 return generic_ide_ioctl(drive, file, bdev, cmd, arg);
1083
1084 read_val:
1085 mutex_lock(&ide_setting_mtx);
1086 spin_lock_irqsave(&ide_lock, flags);
1087 err = *val;
1088 spin_unlock_irqrestore(&ide_lock, flags);
1089 mutex_unlock(&ide_setting_mtx);
1090 return err >= 0 ? put_user(err, (long __user *)arg) : err;
1091
1092 set_val:
1093 if (bdev != bdev->bd_contains)
1094 err = -EINVAL;
1095 else {
1096 if (!capable(CAP_SYS_ADMIN))
1097 err = -EACCES;
1098 else {
1099 mutex_lock(&ide_setting_mtx);
1100 err = setfunc(drive, arg);
1101 mutex_unlock(&ide_setting_mtx);
1102 }
1103 }
1104 return err;
1105 }
1106
1107 static int idedisk_media_changed(struct gendisk *disk)
1108 {
1109 struct ide_disk_obj *idkp = ide_disk_g(disk);
1110 ide_drive_t *drive = idkp->drive;
1111
1112 /* do not scan partitions twice if this is a removable device */
1113 if (drive->attach) {
1114 drive->attach = 0;
1115 return 0;
1116 }
1117 /* if removable, always assume it was changed */
1118 return drive->removable;
1119 }
1120
1121 static int idedisk_revalidate_disk(struct gendisk *disk)
1122 {
1123 struct ide_disk_obj *idkp = ide_disk_g(disk);
1124 set_capacity(disk, idedisk_capacity(idkp->drive));
1125 return 0;
1126 }
1127
1128 static struct block_device_operations idedisk_ops = {
1129 .owner = THIS_MODULE,
1130 .open = idedisk_open,
1131 .release = idedisk_release,
1132 .ioctl = idedisk_ioctl,
1133 .getgeo = idedisk_getgeo,
1134 .media_changed = idedisk_media_changed,
1135 .revalidate_disk= idedisk_revalidate_disk
1136 };
1137
1138 MODULE_DESCRIPTION("ATA DISK Driver");
1139
1140 static int ide_disk_probe(ide_drive_t *drive)
1141 {
1142 struct ide_disk_obj *idkp;
1143 struct gendisk *g;
1144
1145 /* strstr("foo", "") is non-NULL */
1146 if (!strstr("ide-disk", drive->driver_req))
1147 goto failed;
1148 if (!drive->present)
1149 goto failed;
1150 if (drive->media != ide_disk)
1151 goto failed;
1152
1153 idkp = kzalloc(sizeof(*idkp), GFP_KERNEL);
1154 if (!idkp)
1155 goto failed;
1156
1157 g = alloc_disk_node(1 << PARTN_BITS,
1158 hwif_to_node(drive->hwif));
1159 if (!g)
1160 goto out_free_idkp;
1161
1162 ide_init_disk(g, drive);
1163
1164 ide_proc_register_driver(drive, &idedisk_driver);
1165
1166 kref_init(&idkp->kref);
1167
1168 idkp->drive = drive;
1169 idkp->driver = &idedisk_driver;
1170 idkp->disk = g;
1171
1172 g->private_data = &idkp->driver;
1173
1174 drive->driver_data = idkp;
1175
1176 idedisk_setup(drive);
1177 if ((!drive->head || drive->head > 16) && !drive->select.b.lba) {
1178 printk(KERN_ERR "%s: INVALID GEOMETRY: %d PHYSICAL HEADS?\n",
1179 drive->name, drive->head);
1180 drive->attach = 0;
1181 } else
1182 drive->attach = 1;
1183
1184 g->minors = 1 << PARTN_BITS;
1185 g->driverfs_dev = &drive->gendev;
1186 g->flags = drive->removable ? GENHD_FL_REMOVABLE : 0;
1187 set_capacity(g, idedisk_capacity(drive));
1188 g->fops = &idedisk_ops;
1189 add_disk(g);
1190 return 0;
1191
1192 out_free_idkp:
1193 kfree(idkp);
1194 failed:
1195 return -ENODEV;
1196 }
1197
1198 static void __exit idedisk_exit (void)
1199 {
1200 driver_unregister(&idedisk_driver.gen_driver);
1201 }
1202
1203 static int __init idedisk_init(void)
1204 {
1205 return driver_register(&idedisk_driver.gen_driver);
1206 }
1207
1208 MODULE_ALIAS("ide:*m-disk*");
1209 module_init(idedisk_init);
1210 module_exit(idedisk_exit);
1211 MODULE_LICENSE("GPL");
WRT350N Kernel Patches