1 /* 2 * Copyright (C) 2016 Robert Jarzmik <robert.jarzmik@free.fr> 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 as 6 * published by the Free Software Foundation. 7 */ 8 9 #include <linux/module.h> 10 #include <linux/bitops.h> 11 #include <linux/clk.h> 12 #include <linux/device.h> 13 #include <linux/idr.h> 14 #include <linux/list.h> 15 #include <linux/mutex.h> 16 #include <linux/pm.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/slab.h> 19 #include <linux/sysfs.h> 20 #include <sound/ac97/codec.h> 21 #include <sound/ac97/controller.h> 22 #include <sound/ac97/regs.h> 23 24 #include "ac97_core.h" 25 26 /* 27 * Protects ac97_controllers and each ac97_controller structure. 28 */ 29 static DEFINE_MUTEX(ac97_controllers_mutex); 30 static DEFINE_IDR(ac97_adapter_idr); 31 static LIST_HEAD(ac97_controllers); 32 33 static struct bus_type ac97_bus_type; 34 35 static inline struct ac97_controller* 36 to_ac97_controller(struct device *ac97_adapter) 37 { 38 return container_of(ac97_adapter, struct ac97_controller, adap); 39 } 40 41 static int ac97_unbound_ctrl_write(struct ac97_controller *adrv, int slot, 42 unsigned short reg, unsigned short val) 43 { 44 return -ENODEV; 45 } 46 47 static int ac97_unbound_ctrl_read(struct ac97_controller *adrv, int slot, 48 unsigned short reg) 49 { 50 return -ENODEV; 51 } 52 53 static const struct ac97_controller_ops ac97_unbound_ctrl_ops = { 54 .write = ac97_unbound_ctrl_write, 55 .read = ac97_unbound_ctrl_read, 56 }; 57 58 static struct ac97_controller ac97_unbound_ctrl = { 59 .ops = &ac97_unbound_ctrl_ops, 60 }; 61 62 static struct ac97_codec_device * 63 ac97_codec_find(struct ac97_controller *ac97_ctrl, unsigned int codec_num) 64 { 65 if (codec_num >= AC97_BUS_MAX_CODECS) 66 return ERR_PTR(-EINVAL); 67 68 return ac97_ctrl->codecs[codec_num]; 69 } 70 71 static void ac97_codec_release(struct device *dev) 72 { 73 struct ac97_codec_device *adev; 74 struct ac97_controller *ac97_ctrl; 75 76 adev = to_ac97_device(dev); 77 ac97_ctrl = adev->ac97_ctrl; 78 ac97_ctrl->codecs[adev->num] = NULL; 79 kfree(adev); 80 } 81 82 static int ac97_codec_add(struct ac97_controller *ac97_ctrl, int idx, 83 unsigned int vendor_id) 84 { 85 struct ac97_codec_device *codec; 86 int ret; 87 88 codec = kzalloc(sizeof(*codec), GFP_KERNEL); 89 if (!codec) 90 return -ENOMEM; 91 ac97_ctrl->codecs[idx] = codec; 92 codec->vendor_id = vendor_id; 93 codec->dev.release = ac97_codec_release; 94 codec->dev.bus = &ac97_bus_type; 95 codec->dev.parent = &ac97_ctrl->adap; 96 codec->num = idx; 97 codec->ac97_ctrl = ac97_ctrl; 98 99 device_initialize(&codec->dev); 100 dev_set_name(&codec->dev, "%s:%u", dev_name(ac97_ctrl->parent), idx); 101 102 ret = device_add(&codec->dev); 103 if (ret) 104 goto err_free_codec; 105 106 return 0; 107 err_free_codec: 108 put_device(&codec->dev); 109 kfree(codec); 110 ac97_ctrl->codecs[idx] = NULL; 111 112 return ret; 113 } 114 115 unsigned int snd_ac97_bus_scan_one(struct ac97_controller *adrv, 116 unsigned int codec_num) 117 { 118 unsigned short vid1, vid2; 119 int ret; 120 121 ret = adrv->ops->read(adrv, codec_num, AC97_VENDOR_ID1); 122 vid1 = (ret & 0xffff); 123 if (ret < 0) 124 return 0; 125 126 ret = adrv->ops->read(adrv, codec_num, AC97_VENDOR_ID2); 127 vid2 = (ret & 0xffff); 128 if (ret < 0) 129 return 0; 130 131 dev_dbg(&adrv->adap, "%s(codec_num=%u): vendor_id=0x%08x\n", 132 __func__, codec_num, AC97_ID(vid1, vid2)); 133 return AC97_ID(vid1, vid2); 134 } 135 136 static int ac97_bus_scan(struct ac97_controller *ac97_ctrl) 137 { 138 int ret, i; 139 unsigned int vendor_id; 140 141 for (i = 0; i < AC97_BUS_MAX_CODECS; i++) { 142 if (ac97_codec_find(ac97_ctrl, i)) 143 continue; 144 if (!(ac97_ctrl->slots_available & BIT(i))) 145 continue; 146 vendor_id = snd_ac97_bus_scan_one(ac97_ctrl, i); 147 if (!vendor_id) 148 continue; 149 150 ret = ac97_codec_add(ac97_ctrl, i, vendor_id); 151 if (ret < 0) 152 return ret; 153 } 154 return 0; 155 } 156 157 static int ac97_bus_reset(struct ac97_controller *ac97_ctrl) 158 { 159 ac97_ctrl->ops->reset(ac97_ctrl); 160 161 return 0; 162 } 163 164 /** 165 * snd_ac97_codec_driver_register - register an AC97 codec driver 166 * @dev: AC97 driver codec to register 167 * 168 * Register an AC97 codec driver to the ac97 bus driver, aka. the AC97 digital 169 * controller. 170 * 171 * Returns 0 on success or error code 172 */ 173 int snd_ac97_codec_driver_register(struct ac97_codec_driver *drv) 174 { 175 drv->driver.bus = &ac97_bus_type; 176 return driver_register(&drv->driver); 177 } 178 EXPORT_SYMBOL_GPL(snd_ac97_codec_driver_register); 179 180 /** 181 * snd_ac97_codec_driver_unregister - unregister an AC97 codec driver 182 * @dev: AC97 codec driver to unregister 183 * 184 * Unregister a previously registered ac97 codec driver. 185 */ 186 void snd_ac97_codec_driver_unregister(struct ac97_codec_driver *drv) 187 { 188 driver_unregister(&drv->driver); 189 } 190 EXPORT_SYMBOL_GPL(snd_ac97_codec_driver_unregister); 191 192 /** 193 * snd_ac97_codec_get_platdata - get platform_data 194 * @adev: the ac97 codec device 195 * 196 * For legacy platforms, in order to have platform_data in codec drivers 197 * available, while ac97 device are auto-created upon probe, this retrieves the 198 * platdata which was setup on ac97 controller registration. 199 * 200 * Returns the platform data pointer 201 */ 202 void *snd_ac97_codec_get_platdata(const struct ac97_codec_device *adev) 203 { 204 struct ac97_controller *ac97_ctrl = adev->ac97_ctrl; 205 206 return ac97_ctrl->codecs_pdata[adev->num]; 207 } 208 EXPORT_SYMBOL_GPL(snd_ac97_codec_get_platdata); 209 210 static void ac97_ctrl_codecs_unregister(struct ac97_controller *ac97_ctrl) 211 { 212 int i; 213 214 for (i = 0; i < AC97_BUS_MAX_CODECS; i++) 215 if (ac97_ctrl->codecs[i]) { 216 ac97_ctrl->codecs[i]->ac97_ctrl = &ac97_unbound_ctrl; 217 device_unregister(&ac97_ctrl->codecs[i]->dev); 218 } 219 } 220 221 static ssize_t cold_reset_store(struct device *dev, 222 struct device_attribute *attr, const char *buf, 223 size_t len) 224 { 225 struct ac97_controller *ac97_ctrl; 226 227 mutex_lock(&ac97_controllers_mutex); 228 ac97_ctrl = to_ac97_controller(dev); 229 ac97_ctrl->ops->reset(ac97_ctrl); 230 mutex_unlock(&ac97_controllers_mutex); 231 return len; 232 } 233 static DEVICE_ATTR_WO(cold_reset); 234 235 static ssize_t warm_reset_store(struct device *dev, 236 struct device_attribute *attr, const char *buf, 237 size_t len) 238 { 239 struct ac97_controller *ac97_ctrl; 240 241 if (!dev) 242 return -ENODEV; 243 244 mutex_lock(&ac97_controllers_mutex); 245 ac97_ctrl = to_ac97_controller(dev); 246 ac97_ctrl->ops->warm_reset(ac97_ctrl); 247 mutex_unlock(&ac97_controllers_mutex); 248 return len; 249 } 250 static DEVICE_ATTR_WO(warm_reset); 251 252 static struct attribute *ac97_controller_device_attrs[] = { 253 &dev_attr_cold_reset.attr, 254 &dev_attr_warm_reset.attr, 255 NULL 256 }; 257 258 static struct attribute_group ac97_adapter_attr_group = { 259 .name = "ac97_operations", 260 .attrs = ac97_controller_device_attrs, 261 }; 262 263 static const struct attribute_group *ac97_adapter_groups[] = { 264 &ac97_adapter_attr_group, 265 NULL, 266 }; 267 268 static void ac97_del_adapter(struct ac97_controller *ac97_ctrl) 269 { 270 mutex_lock(&ac97_controllers_mutex); 271 ac97_ctrl_codecs_unregister(ac97_ctrl); 272 list_del(&ac97_ctrl->controllers); 273 mutex_unlock(&ac97_controllers_mutex); 274 275 device_unregister(&ac97_ctrl->adap); 276 } 277 278 static void ac97_adapter_release(struct device *dev) 279 { 280 struct ac97_controller *ac97_ctrl; 281 282 ac97_ctrl = to_ac97_controller(dev); 283 idr_remove(&ac97_adapter_idr, ac97_ctrl->nr); 284 dev_dbg(&ac97_ctrl->adap, "adapter unregistered by %s\n", 285 dev_name(ac97_ctrl->parent)); 286 } 287 288 static const struct device_type ac97_adapter_type = { 289 .groups = ac97_adapter_groups, 290 .release = ac97_adapter_release, 291 }; 292 293 static int ac97_add_adapter(struct ac97_controller *ac97_ctrl) 294 { 295 int ret; 296 297 mutex_lock(&ac97_controllers_mutex); 298 ret = idr_alloc(&ac97_adapter_idr, ac97_ctrl, 0, 0, GFP_KERNEL); 299 ac97_ctrl->nr = ret; 300 if (ret >= 0) { 301 dev_set_name(&ac97_ctrl->adap, "ac97-%d", ret); 302 ac97_ctrl->adap.type = &ac97_adapter_type; 303 ac97_ctrl->adap.parent = ac97_ctrl->parent; 304 ret = device_register(&ac97_ctrl->adap); 305 if (ret) 306 put_device(&ac97_ctrl->adap); 307 } 308 if (!ret) 309 list_add(&ac97_ctrl->controllers, &ac97_controllers); 310 mutex_unlock(&ac97_controllers_mutex); 311 312 if (!ret) 313 dev_dbg(&ac97_ctrl->adap, "adapter registered by %s\n", 314 dev_name(ac97_ctrl->parent)); 315 return ret; 316 } 317 318 /** 319 * snd_ac97_controller_register - register an ac97 controller 320 * @ops: the ac97 bus operations 321 * @dev: the device providing the ac97 DC function 322 * @slots_available: mask of the ac97 codecs that can be scanned and probed 323 * bit0 => codec 0, bit1 => codec 1 ... bit 3 => codec 3 324 * 325 * Register a digital controller which can control up to 4 ac97 codecs. This is 326 * the controller side of the AC97 AC-link, while the slave side are the codecs. 327 * 328 * Returns a valid controller upon success, negative pointer value upon error 329 */ 330 struct ac97_controller *snd_ac97_controller_register( 331 const struct ac97_controller_ops *ops, struct device *dev, 332 unsigned short slots_available, void **codecs_pdata) 333 { 334 struct ac97_controller *ac97_ctrl; 335 int ret, i; 336 337 ac97_ctrl = kzalloc(sizeof(*ac97_ctrl), GFP_KERNEL); 338 if (!ac97_ctrl) 339 return ERR_PTR(-ENOMEM); 340 341 for (i = 0; i < AC97_BUS_MAX_CODECS && codecs_pdata; i++) 342 ac97_ctrl->codecs_pdata[i] = codecs_pdata[i]; 343 344 ac97_ctrl->ops = ops; 345 ac97_ctrl->slots_available = slots_available; 346 ac97_ctrl->parent = dev; 347 ret = ac97_add_adapter(ac97_ctrl); 348 349 if (ret) 350 goto err; 351 ac97_bus_reset(ac97_ctrl); 352 ac97_bus_scan(ac97_ctrl); 353 354 return ac97_ctrl; 355 err: 356 kfree(ac97_ctrl); 357 return ERR_PTR(ret); 358 } 359 EXPORT_SYMBOL_GPL(snd_ac97_controller_register); 360 361 /** 362 * snd_ac97_controller_unregister - unregister an ac97 controller 363 * @ac97_ctrl: the device previously provided to ac97_controller_register() 364 * 365 */ 366 void snd_ac97_controller_unregister(struct ac97_controller *ac97_ctrl) 367 { 368 ac97_del_adapter(ac97_ctrl); 369 } 370 EXPORT_SYMBOL_GPL(snd_ac97_controller_unregister); 371 372 #ifdef CONFIG_PM 373 static int ac97_pm_runtime_suspend(struct device *dev) 374 { 375 struct ac97_codec_device *codec = to_ac97_device(dev); 376 int ret = pm_generic_runtime_suspend(dev); 377 378 if (ret == 0 && dev->driver) { 379 if (pm_runtime_is_irq_safe(dev)) 380 clk_disable(codec->clk); 381 else 382 clk_disable_unprepare(codec->clk); 383 } 384 385 return ret; 386 } 387 388 static int ac97_pm_runtime_resume(struct device *dev) 389 { 390 struct ac97_codec_device *codec = to_ac97_device(dev); 391 int ret; 392 393 if (dev->driver) { 394 if (pm_runtime_is_irq_safe(dev)) 395 ret = clk_enable(codec->clk); 396 else 397 ret = clk_prepare_enable(codec->clk); 398 if (ret) 399 return ret; 400 } 401 402 return pm_generic_runtime_resume(dev); 403 } 404 #endif /* CONFIG_PM */ 405 406 static const struct dev_pm_ops ac97_pm = { 407 .suspend = pm_generic_suspend, 408 .resume = pm_generic_resume, 409 .freeze = pm_generic_freeze, 410 .thaw = pm_generic_thaw, 411 .poweroff = pm_generic_poweroff, 412 .restore = pm_generic_restore, 413 SET_RUNTIME_PM_OPS( 414 ac97_pm_runtime_suspend, 415 ac97_pm_runtime_resume, 416 NULL) 417 }; 418 419 static int ac97_get_enable_clk(struct ac97_codec_device *adev) 420 { 421 int ret; 422 423 adev->clk = clk_get(&adev->dev, "ac97_clk"); 424 if (IS_ERR(adev->clk)) 425 return PTR_ERR(adev->clk); 426 427 ret = clk_prepare_enable(adev->clk); 428 if (ret) 429 clk_put(adev->clk); 430 431 return ret; 432 } 433 434 static void ac97_put_disable_clk(struct ac97_codec_device *adev) 435 { 436 clk_disable_unprepare(adev->clk); 437 clk_put(adev->clk); 438 } 439 440 static ssize_t vendor_id_show(struct device *dev, 441 struct device_attribute *attr, char *buf) 442 { 443 struct ac97_codec_device *codec = to_ac97_device(dev); 444 445 return sprintf(buf, "%08x", codec->vendor_id); 446 } 447 DEVICE_ATTR_RO(vendor_id); 448 449 static struct attribute *ac97_dev_attrs[] = { 450 &dev_attr_vendor_id.attr, 451 NULL, 452 }; 453 ATTRIBUTE_GROUPS(ac97_dev); 454 455 static int ac97_bus_match(struct device *dev, struct device_driver *drv) 456 { 457 struct ac97_codec_device *adev = to_ac97_device(dev); 458 struct ac97_codec_driver *adrv = to_ac97_driver(drv); 459 const struct ac97_id *id = adrv->id_table; 460 int i = 0; 461 462 if (adev->vendor_id == 0x0 || adev->vendor_id == 0xffffffff) 463 return false; 464 465 do { 466 if (ac97_ids_match(id[i].id, adev->vendor_id, id[i].mask)) 467 return true; 468 } while (id[i++].id); 469 470 return false; 471 } 472 473 static int ac97_bus_probe(struct device *dev) 474 { 475 struct ac97_codec_device *adev = to_ac97_device(dev); 476 struct ac97_codec_driver *adrv = to_ac97_driver(dev->driver); 477 int ret; 478 479 ret = ac97_get_enable_clk(adev); 480 if (ret) 481 return ret; 482 483 pm_runtime_get_noresume(dev); 484 pm_runtime_set_active(dev); 485 pm_runtime_enable(dev); 486 487 ret = adrv->probe(adev); 488 if (ret == 0) 489 return 0; 490 491 pm_runtime_disable(dev); 492 pm_runtime_set_suspended(dev); 493 pm_runtime_put_noidle(dev); 494 ac97_put_disable_clk(adev); 495 496 return ret; 497 } 498 499 static int ac97_bus_remove(struct device *dev) 500 { 501 struct ac97_codec_device *adev = to_ac97_device(dev); 502 struct ac97_codec_driver *adrv = to_ac97_driver(dev->driver); 503 int ret; 504 505 ret = pm_runtime_get_sync(dev); 506 if (ret) 507 return ret; 508 509 ret = adrv->remove(adev); 510 pm_runtime_put_noidle(dev); 511 if (ret == 0) 512 ac97_put_disable_clk(adev); 513 514 return ret; 515 } 516 517 static struct bus_type ac97_bus_type = { 518 .name = "ac97bus", 519 .dev_groups = ac97_dev_groups, 520 .match = ac97_bus_match, 521 .pm = &ac97_pm, 522 .probe = ac97_bus_probe, 523 .remove = ac97_bus_remove, 524 }; 525 526 static int __init ac97_bus_init(void) 527 { 528 return bus_register(&ac97_bus_type); 529 } 530 subsys_initcall(ac97_bus_init); 531 532 static void __exit ac97_bus_exit(void) 533 { 534 bus_unregister(&ac97_bus_type); 535 } 536 module_exit(ac97_bus_exit); 537 538 MODULE_LICENSE("GPL"); 539 MODULE_AUTHOR("Robert Jarzmik <robert.jarzmik@free.fr>"); 540