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