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