arch/sh/kernel/cpu/bus.c

   1 /*
   2  * arch/sh/kernel/cpu/bus.c
   3  *
   4  * Virtual bus for SuperH.
   5  *
   6  * Copyright (C) 2004 Paul Mundt
   7  *
   8  * Shamelessly cloned from arch/arm/mach-omap/bus.c, which was written
   9  * by:
  10  *
  11  *      Copyright (C) 2003 - 2004 Nokia Corporation
  12  *      Written by Tony Lindgren <tony@atomide.com>
  13  *      Portions of code based on sa1111.c.
  14  *
  15  * This program is free software; you can redistribute it and/or modify it
  16  * under the terms of the GNU General Public License as published by the
  17  * Free Software Foundation; either version 2 of the License, or (at your
  18  * option) any later version.
  19  */
  20 #include <linux/kernel.h>
  21 #include <linux/device.h>
  22 #include <linux/init.h>
  23 #include <linux/module.h>
  24 #include <asm/bus-sh.h>
  25
  26 static int sh_bus_match(struct device *dev, struct device_driver *drv)
  27 {
  28         struct sh_driver *shdrv = to_sh_driver(drv);
  29         struct sh_dev *shdev = to_sh_dev(dev);
  30
  31         return shdev->dev_id == shdrv->dev_id;
  32 }
  33
  34 static int sh_bus_suspend(struct device *dev, pm_message_t state)
  35 {
  36         struct sh_dev *shdev = to_sh_dev(dev);
  37         struct sh_driver *shdrv = to_sh_driver(dev->driver);
  38
  39         if (shdrv && shdrv->suspend)
  40                 return shdrv->suspend(shdev, state);
  41
  42         return 0;
  43 }
  44
  45 static int sh_bus_resume(struct device *dev)
  46 {
  47         struct sh_dev *shdev = to_sh_dev(dev);
  48         struct sh_driver *shdrv = to_sh_driver(dev->driver);
  49
  50         if (shdrv && shdrv->resume)
  51                 return shdrv->resume(shdev);
  52
  53         return 0;
  54 }
  55
  56 static int sh_device_probe(struct device *dev)
  57 {
  58         struct sh_dev *shdev = to_sh_dev(dev);
  59         struct sh_driver *shdrv = to_sh_driver(dev->driver);
  60
  61         if (shdrv && shdrv->probe)
  62                 return shdrv->probe(shdev);
  63
  64         return -ENODEV;
  65 }
  66
  67 static int sh_device_remove(struct device *dev)
  68 {
  69         struct sh_dev *shdev = to_sh_dev(dev);
  70         struct sh_driver *shdrv = to_sh_driver(dev->driver);
  71
  72         if (shdrv && shdrv->remove)
  73                 return shdrv->remove(shdev);
  74
  75         return 0;
  76 }
  77
  78 static struct device sh_bus_devices[SH_NR_BUSES] = {
  79         {
  80                 .bus_id         = SH_BUS_NAME_VIRT,
  81         },
  82 };
  83
  84 struct bus_type sh_bus_types[SH_NR_BUSES] = {
  85         {
  86                 .name           = SH_BUS_NAME_VIRT,
  87                 .match          = sh_bus_match,
  88                 .probe          = sh_bus_probe,
  89                 .remove         = sh_bus_remove,
  90                 .suspend        = sh_bus_suspend,
  91                 .resume         = sh_bus_resume,
  92         },
  93 };
  94
  95 int sh_device_register(struct sh_dev *dev)
  96 {
  97         if (!dev)
  98                 return -EINVAL;
  99
 100         if (dev->bus_id < 0 || dev->bus_id >= SH_NR_BUSES) {
 101                 printk(KERN_ERR "%s: bus_id invalid: %s bus: %d\n",
 102                        __FUNCTION__, dev->name, dev->bus_id);
 103                 return -EINVAL;
 104         }
 105
 106         dev->dev.parent = &sh_bus_devices[dev->bus_id];
 107         dev->dev.bus    = &sh_bus_types[dev->bus_id];
 108
 109         /* This is needed for USB OHCI to work */
 110         if (dev->dma_mask)
 111                 dev->dev.dma_mask = dev->dma_mask;
 112
 113         snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%s%u",
 114                  dev->name, dev->dev_id);
 115
 116         printk(KERN_INFO "Registering SH device '%s'. Parent at %s\n",
 117                dev->dev.bus_id, dev->dev.parent->bus_id);
 118
 119         return device_register(&dev->dev);
 120 }
 121
 122 void sh_device_unregister(struct sh_dev *dev)
 123 {
 124         device_unregister(&dev->dev);
 125 }
 126
 127 int sh_driver_register(struct sh_driver *drv)
 128 {
 129         if (!drv)
 130                 return -EINVAL;
 131
 132         if (drv->bus_id < 0 || drv->bus_id >= SH_NR_BUSES) {
 133                 printk(KERN_ERR "%s: bus_id invalid: bus: %d device %d\n",
 134                        __FUNCTION__, drv->bus_id, drv->dev_id);
 135                 return -EINVAL;
 136         }
 137
 138         drv->drv.bus    = &sh_bus_types[drv->bus_id];
 139
 140         return driver_register(&drv->drv);
 141 }
 142
 143 void sh_driver_unregister(struct sh_driver *drv)
 144 {
 145         driver_unregister(&drv->drv);
 146 }
 147
 148 static int __init sh_bus_init(void)
 149 {
 150         int i, ret = 0;
 151
 152         for (i = 0; i < SH_NR_BUSES; i++) {
 153                 ret = device_register(&sh_bus_devices[i]);
 154                 if (ret != 0) {
 155                         printk(KERN_ERR "Unable to register bus device %s\n",
 156                                sh_bus_devices[i].bus_id);
 157                         continue;
 158                 }
 159
 160                 ret = bus_register(&sh_bus_types[i]);
 161                 if (ret != 0) {
 162                         printk(KERN_ERR "Unable to register bus %s\n",
 163                                sh_bus_types[i].name);
 164                         device_unregister(&sh_bus_devices[i]);
 165                 }
 166         }
 167
 168         printk(KERN_INFO "SH Virtual Bus initialized\n");
 169
 170         return ret;
 171 }
 172
 173 static void __exit sh_bus_exit(void)
 174 {
 175         int i;
 176
 177         for (i = 0; i < SH_NR_BUSES; i++) {
 178                 bus_unregister(&sh_bus_types[i]);
 179                 device_unregister(&sh_bus_devices[i]);
 180         }
 181 }
 182
 183 module_init(sh_bus_init);
 184 module_exit(sh_bus_exit);
 185
 186 MODULE_AUTHOR("Paul Mundt <lethal@linux-sh.org>");
 187 MODULE_DESCRIPTION("SH Virtual Bus");
 188 MODULE_LICENSE("GPL");
 189
 190 EXPORT_SYMBOL(sh_bus_types);
 191 EXPORT_SYMBOL(sh_device_register);
 192 EXPORT_SYMBOL(sh_device_unregister);
 193 EXPORT_SYMBOL(sh_driver_register);
 194 EXPORT_SYMBOL(sh_driver_unregister);
 195