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