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