1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47#include <linux/module.h>
48#include <linux/types.h>
49#include <linux/string.h>
50#include <linux/kernel.h>
51#include <linux/interrupt.h>
52#include <linux/major.h>
53#include <linux/errno.h>
54#include <linux/genhd.h>
55#include <linux/slab.h>
56#include <linux/init.h>
57#include <linux/pci.h>
58#include <linux/ide.h>
59#include <linux/hdreg.h>
60#include <linux/completion.h>
61#include <linux/device.h>
62
63
64
65#define IDE_DEFAULT_MAX_FAILURES 1
66
67struct class *ide_port_class;
68
69static const u8 ide_hwif_to_major[] = { IDE0_MAJOR, IDE1_MAJOR,
70 IDE2_MAJOR, IDE3_MAJOR,
71 IDE4_MAJOR, IDE5_MAJOR,
72 IDE6_MAJOR, IDE7_MAJOR,
73 IDE8_MAJOR, IDE9_MAJOR };
74
75DEFINE_MUTEX(ide_cfg_mtx);
76
77__cacheline_aligned_in_smp DEFINE_SPINLOCK(ide_lock);
78EXPORT_SYMBOL(ide_lock);
79
80static void ide_port_init_devices_data(ide_hwif_t *);
81
82
83
84
85void ide_init_port_data(ide_hwif_t *hwif, unsigned int index)
86{
87
88 memset(hwif, 0, sizeof(ide_hwif_t));
89
90
91 hwif->index = index;
92 hwif->major = ide_hwif_to_major[index];
93
94 hwif->name[0] = 'i';
95 hwif->name[1] = 'd';
96 hwif->name[2] = 'e';
97 hwif->name[3] = '0' + index;
98
99 init_completion(&hwif->gendev_rel_comp);
100
101 hwif->tp_ops = &default_tp_ops;
102
103 ide_port_init_devices_data(hwif);
104}
105
106static void ide_port_init_devices_data(ide_hwif_t *hwif)
107{
108 int unit;
109
110 for (unit = 0; unit < MAX_DRIVES; ++unit) {
111 ide_drive_t *drive = &hwif->drives[unit];
112 u8 j = (hwif->index * MAX_DRIVES) + unit;
113
114 memset(drive, 0, sizeof(*drive));
115
116 drive->media = ide_disk;
117 drive->select = (unit << 4) | ATA_DEVICE_OBS;
118 drive->hwif = hwif;
119 drive->ready_stat = ATA_DRDY;
120 drive->bad_wstat = BAD_W_STAT;
121 drive->special.b.recalibrate = 1;
122 drive->special.b.set_geometry = 1;
123 drive->name[0] = 'h';
124 drive->name[1] = 'd';
125 drive->name[2] = 'a' + j;
126 drive->max_failures = IDE_DEFAULT_MAX_FAILURES;
127
128 INIT_LIST_HEAD(&drive->list);
129 init_completion(&drive->gendev_rel_comp);
130 }
131}
132
133
134static void __ide_port_unregister_devices(ide_hwif_t *hwif)
135{
136 int i;
137
138 for (i = 0; i < MAX_DRIVES; i++) {
139 ide_drive_t *drive = &hwif->drives[i];
140
141 if (drive->dev_flags & IDE_DFLAG_PRESENT) {
142 spin_unlock_irq(&ide_lock);
143 device_unregister(&drive->gendev);
144 wait_for_completion(&drive->gendev_rel_comp);
145 spin_lock_irq(&ide_lock);
146 }
147 }
148}
149
150void ide_port_unregister_devices(ide_hwif_t *hwif)
151{
152 mutex_lock(&ide_cfg_mtx);
153 spin_lock_irq(&ide_lock);
154 __ide_port_unregister_devices(hwif);
155 hwif->present = 0;
156 ide_port_init_devices_data(hwif);
157 spin_unlock_irq(&ide_lock);
158 mutex_unlock(&ide_cfg_mtx);
159}
160EXPORT_SYMBOL_GPL(ide_port_unregister_devices);
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184void ide_unregister(ide_hwif_t *hwif)
185{
186 ide_hwif_t *g;
187 ide_hwgroup_t *hwgroup;
188 int irq_count = 0;
189
190 BUG_ON(in_interrupt());
191 BUG_ON(irqs_disabled());
192
193 mutex_lock(&ide_cfg_mtx);
194
195 spin_lock_irq(&ide_lock);
196 if (hwif->present) {
197 __ide_port_unregister_devices(hwif);
198 hwif->present = 0;
199 }
200 spin_unlock_irq(&ide_lock);
201
202 ide_proc_unregister_port(hwif);
203
204 hwgroup = hwif->hwgroup;
205
206
207
208 g = hwgroup->hwif;
209 do {
210 if (g->irq == hwif->irq)
211 ++irq_count;
212 g = g->next;
213 } while (g != hwgroup->hwif);
214 if (irq_count == 1)
215 free_irq(hwif->irq, hwgroup);
216
217 ide_remove_port_from_hwgroup(hwif);
218
219 device_unregister(hwif->portdev);
220 device_unregister(&hwif->gendev);
221 wait_for_completion(&hwif->gendev_rel_comp);
222
223
224
225
226 blk_unregister_region(MKDEV(hwif->major, 0), MAX_DRIVES<<PARTN_BITS);
227 kfree(hwif->sg_table);
228 unregister_blkdev(hwif->major, hwif->name);
229
230 ide_release_dma_engine(hwif);
231
232 mutex_unlock(&ide_cfg_mtx);
233}
234
235void ide_init_port_hw(ide_hwif_t *hwif, hw_regs_t *hw)
236{
237 memcpy(&hwif->io_ports, &hw->io_ports, sizeof(hwif->io_ports));
238 hwif->irq = hw->irq;
239 hwif->chipset = hw->chipset;
240 hwif->dev = hw->dev;
241 hwif->gendev.parent = hw->parent ? hw->parent : hw->dev;
242 hwif->ack_intr = hw->ack_intr;
243 hwif->config_data = hw->config;
244}
245
246
247
248
249
250DEFINE_MUTEX(ide_setting_mtx);
251
252ide_devset_get(io_32bit, io_32bit);
253
254static int set_io_32bit(ide_drive_t *drive, int arg)
255{
256 if (drive->dev_flags & IDE_DFLAG_NO_IO_32BIT)
257 return -EPERM;
258
259 if (arg < 0 || arg > 1 + (SUPPORT_VLB_SYNC << 1))
260 return -EINVAL;
261
262 drive->io_32bit = arg;
263
264 return 0;
265}
266
267ide_devset_get_flag(ksettings, IDE_DFLAG_KEEP_SETTINGS);
268
269static int set_ksettings(ide_drive_t *drive, int arg)
270{
271 if (arg < 0 || arg > 1)
272 return -EINVAL;
273
274 if (arg)
275 drive->dev_flags |= IDE_DFLAG_KEEP_SETTINGS;
276 else
277 drive->dev_flags &= ~IDE_DFLAG_KEEP_SETTINGS;
278
279 return 0;
280}
281
282ide_devset_get_flag(using_dma, IDE_DFLAG_USING_DMA);
283
284static int set_using_dma(ide_drive_t *drive, int arg)
285{
286#ifdef CONFIG_BLK_DEV_IDEDMA
287 int err = -EPERM;
288
289 if (arg < 0 || arg > 1)
290 return -EINVAL;
291
292 if (ata_id_has_dma(drive->id) == 0)
293 goto out;
294
295 if (drive->hwif->dma_ops == NULL)
296 goto out;
297
298 err = 0;
299
300 if (arg) {
301 if (ide_set_dma(drive))
302 err = -EIO;
303 } else
304 ide_dma_off(drive);
305
306out:
307 return err;
308#else
309 if (arg < 0 || arg > 1)
310 return -EINVAL;
311
312 return -EPERM;
313#endif
314}
315
316
317
318
319static int set_pio_mode_abuse(ide_hwif_t *hwif, u8 req_pio)
320{
321 switch (req_pio) {
322 case 202:
323 case 201:
324 case 200:
325 case 102:
326 case 101:
327 case 100:
328 return (hwif->host_flags & IDE_HFLAG_ABUSE_DMA_MODES) ? 1 : 0;
329 case 9:
330 case 8:
331 return (hwif->host_flags & IDE_HFLAG_ABUSE_PREFETCH) ? 1 : 0;
332 case 7:
333 case 6:
334 return (hwif->host_flags & IDE_HFLAG_ABUSE_FAST_DEVSEL) ? 1 : 0;
335 default:
336 return 0;
337 }
338}
339
340static int set_pio_mode(ide_drive_t *drive, int arg)
341{
342 ide_hwif_t *hwif = drive->hwif;
343 const struct ide_port_ops *port_ops = hwif->port_ops;
344
345 if (arg < 0 || arg > 255)
346 return -EINVAL;
347
348 if (port_ops == NULL || port_ops->set_pio_mode == NULL ||
349 (hwif->host_flags & IDE_HFLAG_NO_SET_MODE))
350 return -ENOSYS;
351
352 if (set_pio_mode_abuse(drive->hwif, arg)) {
353 if (arg == 8 || arg == 9) {
354 unsigned long flags;
355
356
357 spin_lock_irqsave(&ide_lock, flags);
358 port_ops->set_pio_mode(drive, arg);
359 spin_unlock_irqrestore(&ide_lock, flags);
360 } else
361 port_ops->set_pio_mode(drive, arg);
362 } else {
363 int keep_dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
364
365 ide_set_pio(drive, arg);
366
367 if (hwif->host_flags & IDE_HFLAG_SET_PIO_MODE_KEEP_DMA) {
368 if (keep_dma)
369 ide_dma_on(drive);
370 }
371 }
372
373 return 0;
374}
375
376ide_devset_get_flag(unmaskirq, IDE_DFLAG_UNMASK);
377
378static int set_unmaskirq(ide_drive_t *drive, int arg)
379{
380 if (drive->dev_flags & IDE_DFLAG_NO_UNMASK)
381 return -EPERM;
382
383 if (arg < 0 || arg > 1)
384 return -EINVAL;
385
386 if (arg)
387 drive->dev_flags |= IDE_DFLAG_UNMASK;
388 else
389 drive->dev_flags &= ~IDE_DFLAG_UNMASK;
390
391 return 0;
392}
393
394ide_ext_devset_rw_sync(io_32bit, io_32bit);
395ide_ext_devset_rw_sync(keepsettings, ksettings);
396ide_ext_devset_rw_sync(unmaskirq, unmaskirq);
397ide_ext_devset_rw_sync(using_dma, using_dma);
398__IDE_DEVSET(pio_mode, DS_SYNC, NULL, set_pio_mode);
399
400static int generic_ide_suspend(struct device *dev, pm_message_t mesg)
401{
402 ide_drive_t *drive = dev->driver_data, *pair = ide_get_pair_dev(drive);
403 ide_hwif_t *hwif = HWIF(drive);
404 struct request *rq;
405 struct request_pm_state rqpm;
406 ide_task_t args;
407 int ret;
408
409
410 if ((drive->dn & 1) == 0 || pair == NULL)
411 ide_acpi_get_timing(hwif);
412
413 memset(&rqpm, 0, sizeof(rqpm));
414 memset(&args, 0, sizeof(args));
415 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
416 rq->cmd_type = REQ_TYPE_PM_SUSPEND;
417 rq->special = &args;
418 rq->data = &rqpm;
419 rqpm.pm_step = IDE_PM_START_SUSPEND;
420 if (mesg.event == PM_EVENT_PRETHAW)
421 mesg.event = PM_EVENT_FREEZE;
422 rqpm.pm_state = mesg.event;
423
424 ret = blk_execute_rq(drive->queue, NULL, rq, 0);
425 blk_put_request(rq);
426
427
428 if (ret == 0 && ((drive->dn & 1) || pair == NULL))
429 ide_acpi_set_state(hwif, 0);
430
431 return ret;
432}
433
434static int generic_ide_resume(struct device *dev)
435{
436 ide_drive_t *drive = dev->driver_data, *pair = ide_get_pair_dev(drive);
437 ide_hwif_t *hwif = HWIF(drive);
438 struct request *rq;
439 struct request_pm_state rqpm;
440 ide_task_t args;
441 int err;
442
443
444 if ((drive->dn & 1) == 0 || pair == NULL) {
445 ide_acpi_set_state(hwif, 1);
446 ide_acpi_push_timing(hwif);
447 }
448
449 ide_acpi_exec_tfs(drive);
450
451 memset(&rqpm, 0, sizeof(rqpm));
452 memset(&args, 0, sizeof(args));
453 rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
454 rq->cmd_type = REQ_TYPE_PM_RESUME;
455 rq->cmd_flags |= REQ_PREEMPT;
456 rq->special = &args;
457 rq->data = &rqpm;
458 rqpm.pm_step = IDE_PM_START_RESUME;
459 rqpm.pm_state = PM_EVENT_ON;
460
461 err = blk_execute_rq(drive->queue, NULL, rq, 1);
462 blk_put_request(rq);
463
464 if (err == 0 && dev->driver) {
465 ide_driver_t *drv = to_ide_driver(dev->driver);
466
467 if (drv->resume)
468 drv->resume(drive);
469 }
470
471 return err;
472}
473
474
475
476
477
478
479
480
481int ide_device_get(ide_drive_t *drive)
482{
483 struct device *host_dev;
484 struct module *module;
485
486 if (!get_device(&drive->gendev))
487 return -ENXIO;
488
489 host_dev = drive->hwif->host->dev[0];
490 module = host_dev ? host_dev->driver->owner : NULL;
491
492 if (module && !try_module_get(module)) {
493 put_device(&drive->gendev);
494 return -ENXIO;
495 }
496
497 return 0;
498}
499EXPORT_SYMBOL_GPL(ide_device_get);
500
501
502
503
504
505
506
507
508void ide_device_put(ide_drive_t *drive)
509{
510#ifdef CONFIG_MODULE_UNLOAD
511 struct device *host_dev = drive->hwif->host->dev[0];
512 struct module *module = host_dev ? host_dev->driver->owner : NULL;
513
514 if (module)
515 module_put(module);
516#endif
517 put_device(&drive->gendev);
518}
519EXPORT_SYMBOL_GPL(ide_device_put);
520
521static int ide_bus_match(struct device *dev, struct device_driver *drv)
522{
523 return 1;
524}
525
526static char *media_string(ide_drive_t *drive)
527{
528 switch (drive->media) {
529 case ide_disk:
530 return "disk";
531 case ide_cdrom:
532 return "cdrom";
533 case ide_tape:
534 return "tape";
535 case ide_floppy:
536 return "floppy";
537 case ide_optical:
538 return "optical";
539 default:
540 return "UNKNOWN";
541 }
542}
543
544static ssize_t media_show(struct device *dev, struct device_attribute *attr, char *buf)
545{
546 ide_drive_t *drive = to_ide_device(dev);
547 return sprintf(buf, "%s\n", media_string(drive));
548}
549
550static ssize_t drivename_show(struct device *dev, struct device_attribute *attr, char *buf)
551{
552 ide_drive_t *drive = to_ide_device(dev);
553 return sprintf(buf, "%s\n", drive->name);
554}
555
556static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, char *buf)
557{
558 ide_drive_t *drive = to_ide_device(dev);
559 return sprintf(buf, "ide:m-%s\n", media_string(drive));
560}
561
562static ssize_t model_show(struct device *dev, struct device_attribute *attr,
563 char *buf)
564{
565 ide_drive_t *drive = to_ide_device(dev);
566 return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_PROD]);
567}
568
569static ssize_t firmware_show(struct device *dev, struct device_attribute *attr,
570 char *buf)
571{
572 ide_drive_t *drive = to_ide_device(dev);
573 return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_FW_REV]);
574}
575
576static ssize_t serial_show(struct device *dev, struct device_attribute *attr,
577 char *buf)
578{
579 ide_drive_t *drive = to_ide_device(dev);
580 return sprintf(buf, "%s\n", (char *)&drive->id[ATA_ID_SERNO]);
581}
582
583static struct device_attribute ide_dev_attrs[] = {
584 __ATTR_RO(media),
585 __ATTR_RO(drivename),
586 __ATTR_RO(modalias),
587 __ATTR_RO(model),
588 __ATTR_RO(firmware),
589 __ATTR(serial, 0400, serial_show, NULL),
590 __ATTR(unload_heads, 0644, ide_park_show, ide_park_store),
591 __ATTR_NULL
592};
593
594static int ide_uevent(struct device *dev, struct kobj_uevent_env *env)
595{
596 ide_drive_t *drive = to_ide_device(dev);
597
598 add_uevent_var(env, "MEDIA=%s", media_string(drive));
599 add_uevent_var(env, "DRIVENAME=%s", drive->name);
600 add_uevent_var(env, "MODALIAS=ide:m-%s", media_string(drive));
601 return 0;
602}
603
604static int generic_ide_probe(struct device *dev)
605{
606 ide_drive_t *drive = to_ide_device(dev);
607 ide_driver_t *drv = to_ide_driver(dev->driver);
608
609 return drv->probe ? drv->probe(drive) : -ENODEV;
610}
611
612static int generic_ide_remove(struct device *dev)
613{
614 ide_drive_t *drive = to_ide_device(dev);
615 ide_driver_t *drv = to_ide_driver(dev->driver);
616
617 if (drv->remove)
618 drv->remove(drive);
619
620 return 0;
621}
622
623static void generic_ide_shutdown(struct device *dev)
624{
625 ide_drive_t *drive = to_ide_device(dev);
626 ide_driver_t *drv = to_ide_driver(dev->driver);
627
628 if (dev->driver && drv->shutdown)
629 drv->shutdown(drive);
630}
631
632struct bus_type ide_bus_type = {
633 .name = "ide",
634 .match = ide_bus_match,
635 .uevent = ide_uevent,
636 .probe = generic_ide_probe,
637 .remove = generic_ide_remove,
638 .shutdown = generic_ide_shutdown,
639 .dev_attrs = ide_dev_attrs,
640 .suspend = generic_ide_suspend,
641 .resume = generic_ide_resume,
642};
643
644EXPORT_SYMBOL_GPL(ide_bus_type);
645
646int ide_vlb_clk;
647EXPORT_SYMBOL_GPL(ide_vlb_clk);
648
649module_param_named(vlb_clock, ide_vlb_clk, int, 0);
650MODULE_PARM_DESC(vlb_clock, "VLB clock frequency (in MHz)");
651
652int ide_pci_clk;
653EXPORT_SYMBOL_GPL(ide_pci_clk);
654
655module_param_named(pci_clock, ide_pci_clk, int, 0);
656MODULE_PARM_DESC(pci_clock, "PCI bus clock frequency (in MHz)");
657
658static int ide_set_dev_param_mask(const char *s, struct kernel_param *kp)
659{
660 int a, b, i, j = 1;
661 unsigned int *dev_param_mask = (unsigned int *)kp->arg;
662
663 if (sscanf(s, "%d.%d:%d", &a, &b, &j) != 3 &&
664 sscanf(s, "%d.%d", &a, &b) != 2)
665 return -EINVAL;
666
667 i = a * MAX_DRIVES + b;
668
669 if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1)
670 return -EINVAL;
671
672 if (j)
673 *dev_param_mask |= (1 << i);
674 else
675 *dev_param_mask &= (1 << i);
676
677 return 0;
678}
679
680static unsigned int ide_nodma;
681
682module_param_call(nodma, ide_set_dev_param_mask, NULL, &ide_nodma, 0);
683MODULE_PARM_DESC(nodma, "disallow DMA for a device");
684
685static unsigned int ide_noflush;
686
687module_param_call(noflush, ide_set_dev_param_mask, NULL, &ide_noflush, 0);
688MODULE_PARM_DESC(noflush, "disable flush requests for a device");
689
690static unsigned int ide_noprobe;
691
692module_param_call(noprobe, ide_set_dev_param_mask, NULL, &ide_noprobe, 0);
693MODULE_PARM_DESC(noprobe, "skip probing for a device");
694
695static unsigned int ide_nowerr;
696
697module_param_call(nowerr, ide_set_dev_param_mask, NULL, &ide_nowerr, 0);
698MODULE_PARM_DESC(nowerr, "ignore the ATA_DF bit for a device");
699
700static unsigned int ide_cdroms;
701
702module_param_call(cdrom, ide_set_dev_param_mask, NULL, &ide_cdroms, 0);
703MODULE_PARM_DESC(cdrom, "force device as a CD-ROM");
704
705struct chs_geom {
706 unsigned int cyl;
707 u8 head;
708 u8 sect;
709};
710
711static unsigned int ide_disks;
712static struct chs_geom ide_disks_chs[MAX_HWIFS * MAX_DRIVES];
713
714static int ide_set_disk_chs(const char *str, struct kernel_param *kp)
715{
716 int a, b, c = 0, h = 0, s = 0, i, j = 1;
717
718 if (sscanf(str, "%d.%d:%d,%d,%d", &a, &b, &c, &h, &s) != 5 &&
719 sscanf(str, "%d.%d:%d", &a, &b, &j) != 3)
720 return -EINVAL;
721
722 i = a * MAX_DRIVES + b;
723
724 if (i >= MAX_HWIFS * MAX_DRIVES || j < 0 || j > 1)
725 return -EINVAL;
726
727 if (c > INT_MAX || h > 255 || s > 255)
728 return -EINVAL;
729
730 if (j)
731 ide_disks |= (1 << i);
732 else
733 ide_disks &= (1 << i);
734
735 ide_disks_chs[i].cyl = c;
736 ide_disks_chs[i].head = h;
737 ide_disks_chs[i].sect = s;
738
739 return 0;
740}
741
742module_param_call(chs, ide_set_disk_chs, NULL, NULL, 0);
743MODULE_PARM_DESC(chs, "force device as a disk (using CHS)");
744
745static void ide_dev_apply_params(ide_drive_t *drive, u8 unit)
746{
747 int i = drive->hwif->index * MAX_DRIVES + unit;
748
749 if (ide_nodma & (1 << i)) {
750 printk(KERN_INFO "ide: disallowing DMA for %s\n", drive->name);
751 drive->dev_flags |= IDE_DFLAG_NODMA;
752 }
753 if (ide_noflush & (1 << i)) {
754 printk(KERN_INFO "ide: disabling flush requests for %s\n",
755 drive->name);
756 drive->dev_flags |= IDE_DFLAG_NOFLUSH;
757 }
758 if (ide_noprobe & (1 << i)) {
759 printk(KERN_INFO "ide: skipping probe for %s\n", drive->name);
760 drive->dev_flags |= IDE_DFLAG_NOPROBE;
761 }
762 if (ide_nowerr & (1 << i)) {
763 printk(KERN_INFO "ide: ignoring the ATA_DF bit for %s\n",
764 drive->name);
765 drive->bad_wstat = BAD_R_STAT;
766 }
767 if (ide_cdroms & (1 << i)) {
768 printk(KERN_INFO "ide: forcing %s as a CD-ROM\n", drive->name);
769 drive->dev_flags |= IDE_DFLAG_PRESENT;
770 drive->media = ide_cdrom;
771
772 drive->ready_stat = 0;
773 }
774 if (ide_disks & (1 << i)) {
775 drive->cyl = drive->bios_cyl = ide_disks_chs[i].cyl;
776 drive->head = drive->bios_head = ide_disks_chs[i].head;
777 drive->sect = drive->bios_sect = ide_disks_chs[i].sect;
778
779 printk(KERN_INFO "ide: forcing %s as a disk (%d/%d/%d)\n",
780 drive->name,
781 drive->cyl, drive->head, drive->sect);
782
783 drive->dev_flags |= IDE_DFLAG_FORCED_GEOM | IDE_DFLAG_PRESENT;
784 drive->media = ide_disk;
785 drive->ready_stat = ATA_DRDY;
786 }
787}
788
789static unsigned int ide_ignore_cable;
790
791static int ide_set_ignore_cable(const char *s, struct kernel_param *kp)
792{
793 int i, j = 1;
794
795 if (sscanf(s, "%d:%d", &i, &j) != 2 && sscanf(s, "%d", &i) != 1)
796 return -EINVAL;
797
798 if (i >= MAX_HWIFS || j < 0 || j > 1)
799 return -EINVAL;
800
801 if (j)
802 ide_ignore_cable |= (1 << i);
803 else
804 ide_ignore_cable &= (1 << i);
805
806 return 0;
807}
808
809module_param_call(ignore_cable, ide_set_ignore_cable, NULL, NULL, 0);
810MODULE_PARM_DESC(ignore_cable, "ignore cable detection");
811
812void ide_port_apply_params(ide_hwif_t *hwif)
813{
814 int i;
815
816 if (ide_ignore_cable & (1 << hwif->index)) {
817 printk(KERN_INFO "ide: ignoring cable detection for %s\n",
818 hwif->name);
819 hwif->cbl = ATA_CBL_PATA40_SHORT;
820 }
821
822 for (i = 0; i < MAX_DRIVES; i++)
823 ide_dev_apply_params(&hwif->drives[i], i);
824}
825
826
827
828
829static int __init ide_init(void)
830{
831 int ret;
832
833 printk(KERN_INFO "Uniform Multi-Platform E-IDE driver\n");
834
835 ret = bus_register(&ide_bus_type);
836 if (ret < 0) {
837 printk(KERN_WARNING "IDE: bus_register error: %d\n", ret);
838 return ret;
839 }
840
841 ide_port_class = class_create(THIS_MODULE, "ide_port");
842 if (IS_ERR(ide_port_class)) {
843 ret = PTR_ERR(ide_port_class);
844 goto out_port_class;
845 }
846
847 proc_ide_create();
848
849 return 0;
850
851out_port_class:
852 bus_unregister(&ide_bus_type);
853
854 return ret;
855}
856
857static void __exit ide_exit(void)
858{
859 proc_ide_destroy();
860
861 class_destroy(ide_port_class);
862
863 bus_unregister(&ide_bus_type);
864}
865
866module_init(ide_init);
867module_exit(ide_exit);
868
869MODULE_LICENSE("GPL");