sound/ac97/bus.c

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