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