drivers/ide/ide-generic.c

   1 /*
   2  * generic/default IDE host driver
   3  *
   4  * Copyright (C) 2004, 2008 Bartlomiej Zolnierkiewicz
   5  * This code was split off from ide.c.  See it for original copyrights.
   6  *
   7  * May be copied or modified under the terms of the GNU General Public License.
   8  */
   9
  10 /*
  11  * For special cases new interfaces may be added using sysfs, i.e.
  12  *
  13  *      echo -n "0x168:0x36e:10" > /sys/class/ide_generic/add
  14  *
  15  * will add an interface using I/O ports 0x168-0x16f/0x36e and IRQ 10.
  16  */
  17
  18 #include <linux/kernel.h>
  19 #include <linux/init.h>
  20 #include <linux/module.h>
  21 #include <linux/ide.h>
  22
  23 /* FIXME: convert m32r to use ide_platform host driver */
  24 #ifdef CONFIG_M32R
  25 #include <asm/m32r.h>
  26 #endif
  27
  28 #define DRV_NAME        "ide_generic"
  29
  30 static int probe_mask = 0x03;
  31 module_param(probe_mask, int, 0);
  32 MODULE_PARM_DESC(probe_mask, "probe mask for legacy ISA IDE ports");
  33
  34 static ssize_t store_add(struct class *cls, const char *buf, size_t n)
  35 {
  36         unsigned int base, ctl;
  37         int irq, rc;
  38         hw_regs_t hw, *hws[] = { &hw, NULL, NULL, NULL };
  39
  40         if (sscanf(buf, "%x:%x:%d", &base, &ctl, &irq) != 3)
  41                 return -EINVAL;
  42
  43         memset(&hw, 0, sizeof(hw));
  44         ide_std_init_ports(&hw, base, ctl);
  45         hw.irq = irq;
  46         hw.chipset = ide_generic;
  47
  48         rc = ide_host_add(NULL, hws, NULL);
  49         if (rc)
  50                 return rc;
  51
  52         return n;
  53 };
  54
  55 static struct class_attribute ide_generic_class_attrs[] = {
  56         __ATTR(add, S_IWUSR, NULL, store_add),
  57         __ATTR_NULL
  58 };
  59
  60 static void ide_generic_class_release(struct class *cls)
  61 {
  62         kfree(cls);
  63 }
  64
  65 static int __init ide_generic_sysfs_init(void)
  66 {
  67         struct class *cls;
  68         int rc;
  69
  70         cls = kzalloc(sizeof(*cls), GFP_KERNEL);
  71         if (!cls)
  72                 return -ENOMEM;
  73
  74         cls->name = DRV_NAME;
  75         cls->owner = THIS_MODULE;
  76         cls->class_release = ide_generic_class_release;
  77         cls->class_attrs = ide_generic_class_attrs;
  78
  79         rc = class_register(cls);
  80         if (rc) {
  81                 kfree(cls);
  82                 return rc;
  83         }
  84
  85         return 0;
  86 }
  87
  88 #if defined(CONFIG_PLAT_M32700UT) || defined(CONFIG_PLAT_MAPPI2) \
  89         || defined(CONFIG_PLAT_OPSPUT)
  90 static const u16 legacy_bases[] = { 0x1f0 };
  91 static const int legacy_irqs[]  = { PLD_IRQ_CFIREQ };
  92 #elif defined(CONFIG_PLAT_MAPPI3)
  93 static const u16 legacy_bases[] = { 0x1f0, 0x170 };
  94 static const int legacy_irqs[]  = { PLD_IRQ_CFIREQ, PLD_IRQ_IDEIREQ };
  95 #elif defined(CONFIG_ALPHA)
  96 static const u16 legacy_bases[] = { 0x1f0, 0x170, 0x1e8, 0x168 };
  97 static const int legacy_irqs[]  = { 14, 15, 11, 10 };
  98 #else
  99 static const u16 legacy_bases[] = { 0x1f0, 0x170, 0x1e8, 0x168, 0x1e0, 0x160 };
 100 static const int legacy_irqs[]  = { 14, 15, 11, 10, 8, 12 };
 101 #endif
 102
 103 static int __init ide_generic_init(void)
 104 {
 105         hw_regs_t hw[MAX_HWIFS], *hws[MAX_HWIFS];
 106         struct ide_host *host;
 107         unsigned long io_addr;
 108         int i, rc;
 109
 110 #ifdef CONFIG_MIPS
 111         if (!ide_probe_legacy())
 112                 return -ENODEV;
 113 #endif
 114         printk(KERN_INFO DRV_NAME ": please use \"probe_mask=0x3f\" module "
 115                          "parameter for probing all legacy ISA IDE ports\n");
 116
 117         memset(hws, 0, sizeof(hw_regs_t *) * MAX_HWIFS);
 118
 119         for (i = 0; i < ARRAY_SIZE(legacy_bases); i++) {
 120                 io_addr = legacy_bases[i];
 121
 122                 hws[i] = NULL;
 123
 124                 if ((probe_mask & (1 << i)) && io_addr) {
 125                         if (!request_region(io_addr, 8, DRV_NAME)) {
 126                                 printk(KERN_ERR "%s: I/O resource 0x%lX-0x%lX "
 127                                                 "not free.\n",
 128                                                 DRV_NAME, io_addr, io_addr + 7);
 129                                 continue;
 130                         }
 131
 132                         if (!request_region(io_addr + 0x206, 1, DRV_NAME)) {
 133                                 printk(KERN_ERR "%s: I/O resource 0x%lX "
 134                                                 "not free.\n",
 135                                                 DRV_NAME, io_addr + 0x206);
 136                                 release_region(io_addr, 8);
 137                                 continue;
 138                         }
 139
 140                         memset(&hw[i], 0, sizeof(hw[i]));
 141                         ide_std_init_ports(&hw[i], io_addr, io_addr + 0x206);
 142 #ifdef CONFIG_IA64
 143                         hw[i].irq = isa_irq_to_vector(legacy_irqs[i]);
 144 #else
 145                         hw[i].irq = legacy_irqs[i];
 146 #endif
 147                         hw[i].chipset = ide_generic;
 148
 149                         hws[i] = &hw[i];
 150                 }
 151         }
 152
 153         host = ide_host_alloc_all(NULL, hws);
 154         if (host == NULL) {
 155                 rc = -ENOMEM;
 156                 goto err;
 157         }
 158
 159         rc = ide_host_register(host, NULL, hws);
 160         if (rc)
 161                 goto err_free;
 162
 163         if (ide_generic_sysfs_init())
 164                 printk(KERN_ERR DRV_NAME ": failed to create ide_generic "
 165                                          "class\n");
 166
 167         return 0;
 168 err_free:
 169         ide_host_free(host);
 170 err:
 171         for (i = 0; i < MAX_HWIFS; i++) {
 172                 if (hws[i] == NULL)
 173                         continue;
 174
 175                 io_addr = hws[i]->io_ports.data_addr;
 176                 release_region(io_addr + 0x206, 1);
 177                 release_region(io_addr, 8);
 178         }
 179         return rc;
 180 }
 181
 182 module_init(ide_generic_init);
 183
 184 MODULE_LICENSE("GPL");