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); 251