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         char *scratch, *compat, *compat2;
  65         int i = 0;
  66         int length, cplen, cplen2, 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         envp[i++] = scratch = buffer;
  79         length = scnprintf (scratch, buffer_size, "OF_NAME=%s", of->node->name);
  80         ++length;
  81         buffer_size -= length;
  82         if ((buffer_size <= 0) || (i >= num_envp))
  83                 return -ENOMEM;
  84         scratch += length;
  85
  86         envp[i++] = scratch;
  87         length = scnprintf (scratch, buffer_size, "OF_TYPE=%s", of->node->type);
  88         ++length;
  89         buffer_size -= length;
  90         if ((buffer_size <= 0) || (i >= num_envp))
  91                 return -ENOMEM;
  92         scratch += length;
  93
  94         /* Since the compatible field can contain pretty much anything
  95          * it's not really legal to split it out with commas. We split it
  96          * up using a number of environment variables instead. */
  97
  98         compat = (char *) get_property(of->node, "compatible", &cplen);
  99         compat2 = compat;
 100         cplen2= cplen;
 101         while (compat && cplen > 0) {
 102                 envp[i++] = scratch;
 103                 length = scnprintf (scratch, buffer_size,
 104                                      "OF_COMPATIBLE_%d=%s", seen, compat);
 105                 ++length;
 106                 buffer_size -= length;
 107                 if ((buffer_size <= 0) || (i >= num_envp))
 108                         return -ENOMEM;
 109                 scratch += length;
 110                 length = strlen (compat) + 1;
 111                 compat += length;
 112                 cplen -= length;
 113                 seen++;
 114         }
 115
 116         envp[i++] = scratch;
 117         length = scnprintf (scratch, buffer_size, "OF_COMPATIBLE_N=%d", seen);
 118         ++length;
 119         buffer_size -= length;
 120         if ((buffer_size <= 0) || (i >= num_envp))
 121                 return -ENOMEM;
 122         scratch += length;
 123
 124         envp[i++] = scratch;
 125         length = scnprintf (scratch, buffer_size, "MODALIAS=%s",
 126                         soundbus_dev->modalias);
 127
 128         buffer_size -= length;
 129         if ((buffer_size <= 0) || (i >= num_envp))
 130                 return -ENOMEM;
 131
 132         envp[i] = NULL;
 133
 134         return 0;
 135 }
 136
 137 static int soundbus_device_remove(struct device *dev)
 138 {
 139         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
 140         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
 141
 142         if (dev->driver && drv->remove)
 143                 drv->remove(soundbus_dev);
 144         soundbus_dev_put(soundbus_dev);
 145
 146         return 0;
 147 }
 148
 149 static void soundbus_device_shutdown(struct device *dev)
 150 {
 151         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
 152         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
 153
 154         if (dev->driver && drv->shutdown)
 155                 drv->shutdown(soundbus_dev);
 156 }
 157
 158 #ifdef CONFIG_PM
 159
 160 static int soundbus_device_suspend(struct device *dev, pm_message_t state)
 161 {
 162         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
 163         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
 164
 165         if (dev->driver && drv->suspend)
 166                 return drv->suspend(soundbus_dev, state);
 167         return 0;
 168 }
 169
 170 static int soundbus_device_resume(struct device * dev)
 171 {
 172         struct soundbus_dev * soundbus_dev = to_soundbus_device(dev);
 173         struct soundbus_driver * drv = to_soundbus_driver(dev->driver);
 174
 175         if (dev->driver && drv->resume)
 176                 return drv->resume(soundbus_dev);
 177         return 0;
 178 }
 179
 180 #endif /* CONFIG_PM */
 181
 182 extern struct device_attribute soundbus_dev_attrs[];
 183
 184 static struct bus_type soundbus_bus_type = {
 185         .name           = "aoa-soundbus",
 186         .probe          = soundbus_probe,
 187         .uevent         = soundbus_uevent,
 188         .remove         = soundbus_device_remove,
 189         .shutdown       = soundbus_device_shutdown,
 190 #ifdef CONFIG_PM
 191         .suspend        = soundbus_device_suspend,
 192         .resume         = soundbus_device_resume,
 193 #endif
 194         .dev_attrs      = soundbus_dev_attrs,
 195 };
 196
 197 static int __init soundbus_init(void)
 198 {
 199         return bus_register(&soundbus_bus_type);
 200 }
 201
 202 static void __exit soundbus_exit(void)
 203 {
 204         bus_unregister(&soundbus_bus_type);
 205 }
 206
 207 int soundbus_add_one(struct soundbus_dev *dev)
 208 {
 209         static int devcount;
 210
 211         /* sanity checks */
 212         if (!dev->attach_codec ||
 213             !dev->ofdev.node ||
 214             dev->pcmname ||
 215             dev->pcmid != -1) {
 216                 printk(KERN_ERR "soundbus: adding device failed sanity check!\n");
 217                 return -EINVAL;
 218         }
 219
 220         snprintf(dev->ofdev.dev.bus_id, BUS_ID_SIZE, "soundbus:%x", ++devcount);
 221         dev->ofdev.dev.bus = &soundbus_bus_type;
 222         return of_device_register(&dev->ofdev);
 223 }
 224 EXPORT_SYMBOL_GPL(soundbus_add_one);
 225
 226 void soundbus_remove_one(struct soundbus_dev *dev)
 227 {
 228         of_device_unregister(&dev->ofdev);
 229 }
 230 EXPORT_SYMBOL_GPL(soundbus_remove_one);
 231
 232 int soundbus_register_driver(struct soundbus_driver *drv)
 233 {
 234         /* initialize common driver fields */
 235         drv->driver.name = drv->name;
 236         drv->driver.bus = &soundbus_bus_type;
 237
 238         /* register with core */
 239         return driver_register(&drv->driver);
 240 }
 241 EXPORT_SYMBOL_GPL(soundbus_register_driver);
 242
 243 void soundbus_unregister_driver(struct soundbus_driver *drv)
 244 {
 245         driver_unregister(&drv->driver);
 246 }
 247 EXPORT_SYMBOL_GPL(soundbus_unregister_driver);
 248
 249 module_init(soundbus_init);
 250 module_exit(soundbus_exit);