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