sound/ac97/bus.c

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