sound/aoa/soundbus/core.c

   1 /*
   2  * soundbus
   3  *
   4  * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
   5  *
   6  * GPL v2, can be found in COPYING.
   7  */
   8
   9 #include <linux/module.h>
  10 #include "soundbus.h"
  11
  12 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
  13 MODULE_LICENSE("GPL");
  14 MODULE_DESCRIPTION("Apple Soundbus");
  15
  16 struct soundbus_dev *soundbus_dev_get(struct soundbus_dev *dev)
  17 {
  18         struct device *tmp;
  19
  20         if (!dev)
  21                 return NULL;
  22         tmp = get_device(&dev->ofdev.dev);
  23         if (tmp)
  24                 return to_soundbus_device(tmp);
  25         else
  26                 return NULL;
  27 }
  28 EXPORT_SYMBOL_GPL(soundbus_dev_get);
  29
  30 void soundbus_dev_put(struct soundbus_dev *dev)
  31 {
  32         if (dev)
  33                 put_device(&dev->ofdev.dev);
  34 }
  35 EXPORT_SYMBOL_GPL(soundbus_dev_put);
  36
  37 static int soundbus_probe(struct device *dev)
  38 {
  39         int error = -ENODEV;
  40         struct soundbus_driver *drv;
  41         struct soundbus_dev *soundbus_dev;
  42
  43         drv = to_soundbus_driver(dev->driver);
  44         soundbus_dev = to_soundbus_device(dev);
  45
  46         if (!drv->probe)
  47                 return error;
  48
  49         soundbus_dev_get(soundbus_dev);
  50
  51         error = drv->probe(soundbus_dev);
  52         if (error)
  53                 soundbus_dev_put(soundbus_dev);
  54
  55         return error;
  56 }
  57
  58
  59 static int soundbus_uevent(struct device *dev, char **envp, int num_envp,
  60                            char *buffer, int buffer_size)
  61 {
  62         struct soundbus_dev * soundbus_dev;
  63         struct of_device * of;
  64         const char *compat;
  65         int retval = 0, i = 0, length = 0;
  66         int cplen, seen = 0;
  67
  68         if (!dev)
  69                 return -ENODEV;
  70
  71         soundbus_dev = to_soundbus_device(dev);
  72         if (!soundbus_dev)
  73                 return -ENODEV;
  74
  75         of = &soundbus_dev->ofdev;
  76
  77         /* stuff we want to pass to /sbin/hotplug */
  78         retval = add_uevent_var(envp, num_envp, &i,
  79                                 buffer, buffer_size, &length,
  80                                 "OF_NAME=%s", of->node->name);
  81         if (retval)
  82                 return retval;
  83
  84         retval = add_uevent_var(envp, num_envp, &i,
  85                                 buffer, buffer_size, &length,
  86                                 "OF_TYPE=%s", of->node->type);
  87         if (retval)
  88                 return retval;
  89
  90         /* Since the compatible field can contain pretty much anything
  91          * it's not really legal to split it out with commas. We split it
  92          * up using a number of environment variables instead. */
  93
  94         compat = of_get_property(of->node, "compatible", &cplen);
  95         while (compat && cplen > 0) {
  96                 int tmp = length;
  97                 retval = add_uevent_var(envp, num_envp, &i,
  98                                         buffer, buffer_size, &length,
  99                                         "OF_COMPATIBLE_%d=%s", seen, compat);
 100                 if (retval)
 101                         return retval;
 102                 compat += length - tmp;
 103                 cplen -= length - tmp;
 104                 seen += 1;
 105         }
 106
 107         retval = add_uevent_var(envp, num_envp, &i,
 108                                 buffer, buffer_size, &length,
 109                                 "OF_COMPATIBLE_N=%d", seen);
 110         if (retval)
 111                 return retval;
 112         retval = add_uevent_var(envp, num_envp, &i,
 113                                 buffer, buffer_size, &length,
 114                                 "MODALIAS=%s", soundbus_dev->modalias);
 115
 116         envp[i] = NULL;
 117
 118         return retval;
 119 }
 120
 121 static int soundbus_device_remove(struct device *dev)
 122 {
 123         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
 124         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
 125
 126         if (dev->driver && drv->remove)
 127                 drv->remove(soundbus_dev);
 128         soundbus_dev_put(soundbus_dev);
 129
 130         return 0;
 131 }
 132
 133 static void soundbus_device_shutdown(struct device *dev)
 134 {
 135         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
 136         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
 137
 138         if (dev->driver && drv->shutdown)
 139                 drv->shutdown(soundbus_dev);
 140 }
 141
 142 #ifdef CONFIG_PM
 143
 144 static int soundbus_device_suspend(struct device *dev, pm_message_t state)
 145 {
 146         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
 147         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
 148
 149         if (dev->driver && drv->suspend)
 150                 return drv->suspend(soundbus_dev, state);
 151         return 0;
 152 }
 153
 154 static int soundbus_device_resume(struct device * dev)
 155 {
 156         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
 157         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
 158
 159         if (dev->driver && drv->resume)
 160                 return drv->resume(soundbus_dev);
 161         return 0;
 162 }
 163
 164 #endif /* CONFIG_PM */
 165
 166 static struct bus_type soundbus_bus_type = {
 167         .name           = "aoa-soundbus",
 168         .probe          = soundbus_probe,
 169         .uevent         = soundbus_uevent,
 170         .remove         = soundbus_device_remove,
 171         .shutdown       = soundbus_device_shutdown,
 172 #ifdef CONFIG_PM
 173         .suspend        = soundbus_device_suspend,
 174         .resume         = soundbus_device_resume,
 175 #endif
 176         .dev_attrs      = soundbus_dev_attrs,
 177 };
 178
 179 int soundbus_add_one(struct soundbus_dev *dev)
 180 {
 181         static int devcount;
 182
 183         /* sanity checks */
 184         if (!dev->attach_codec ||
 185             !dev->ofdev.node ||
 186             dev->pcmname ||
 187             dev->pcmid != -1) {
 188                 printk(KERN_ERR "soundbus: adding device failed sanity check!\n");
 189                 return -EINVAL;
 190         }
 191
 192         snprintf(dev->ofdev.dev.bus_id, BUS_ID_SIZE, "soundbus:%x", ++devcount);
 193         dev->ofdev.dev.bus = &soundbus_bus_type;
 194         return of_device_register(&dev->ofdev);
 195 }
 196 EXPORT_SYMBOL_GPL(soundbus_add_one);
 197
 198 void soundbus_remove_one(struct soundbus_dev *dev)
 199 {
 200         of_device_unregister(&dev->ofdev);
 201 }
 202 EXPORT_SYMBOL_GPL(soundbus_remove_one);
 203
 204 int soundbus_register_driver(struct soundbus_driver *drv)
 205 {
 206         /* initialize common driver fields */
 207         drv->driver.name = drv->name;
 208         drv->driver.bus = &soundbus_bus_type;
 209
 210         /* register with core */
 211         return driver_register(&drv->driver);
 212 }
 213 EXPORT_SYMBOL_GPL(soundbus_register_driver);
 214
 215 void soundbus_unregister_driver(struct soundbus_driver *drv)
 216 {
 217         driver_unregister(&drv->driver);
 218 }
 219 EXPORT_SYMBOL_GPL(soundbus_unregister_driver);
 220
 221 static int __init soundbus_init(void)
 222 {
 223         return bus_register(&soundbus_bus_type);
 224 }
 225
 226 static void __exit soundbus_exit(void)
 227 {
 228         bus_unregister(&soundbus_bus_type);
 229 }
 230
 231 subsys_initcall(soundbus_init);
 232 module_exit(soundbus_exit);