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