sound/hda/hdac_sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * sysfs support for HD-audio core device
   4  */
   5
   6 #include <linux/slab.h>
   7 #include <linux/sysfs.h>
   8 #include <linux/device.h>
   9 #include <sound/core.h>
  10 #include <sound/hdaudio.h>
  11 #include "local.h"
  12
  13 struct hdac_widget_tree {
  14         struct kobject *root;
  15         struct kobject *afg;
  16         struct kobject **nodes;
  17 };
  18
  19 #define CODEC_ATTR(type)                                        \
  20 static ssize_t type##_show(struct device *dev,                  \
  21                            struct device_attribute *attr,       \
  22                            char *buf)                           \
  23 {                                                               \
  24         struct hdac_device *codec = dev_to_hdac_dev(dev);       \
  25         return sprintf(buf, "0x%x\n", codec->type);             \
  26 } \
  27 static DEVICE_ATTR_RO(type)
  28
  29 #define CODEC_ATTR_STR(type)                                    \
  30 static ssize_t type##_show(struct device *dev,                  \
  31                              struct device_attribute *attr,     \
  32                                         char *buf)              \
  33 {                                                               \
  34         struct hdac_device *codec = dev_to_hdac_dev(dev);       \
  35         return sprintf(buf, "%s\n",                             \
  36                        codec->type ? codec->type : "");         \
  37 } \
  38 static DEVICE_ATTR_RO(type)
  39
  40 CODEC_ATTR(type);
  41 CODEC_ATTR(vendor_id);
  42 CODEC_ATTR(subsystem_id);
  43 CODEC_ATTR(revision_id);
  44 CODEC_ATTR(afg);
  45 CODEC_ATTR(mfg);
  46 CODEC_ATTR_STR(vendor_name);
  47 CODEC_ATTR_STR(chip_name);
  48
  49 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
  50                              char *buf)
  51 {
  52         return snd_hdac_codec_modalias(dev_to_hdac_dev(dev), buf, 256);
  53 }
  54 static DEVICE_ATTR_RO(modalias);
  55
  56 static struct attribute *hdac_dev_attrs[] = {
  57         &dev_attr_type.attr,
  58         &dev_attr_vendor_id.attr,
  59         &dev_attr_subsystem_id.attr,
  60         &dev_attr_revision_id.attr,
  61         &dev_attr_afg.attr,
  62         &dev_attr_mfg.attr,
  63         &dev_attr_vendor_name.attr,
  64         &dev_attr_chip_name.attr,
  65         &dev_attr_modalias.attr,
  66         NULL
  67 };
  68
  69 static struct attribute_group hdac_dev_attr_group = {
  70         .attrs  = hdac_dev_attrs,
  71 };
  72
  73 const struct attribute_group *hdac_dev_attr_groups[] = {
  74         &hdac_dev_attr_group,
  75         NULL
  76 };
  77
  78 /*
  79  * Widget tree sysfs
  80  *
  81  * This is a tree showing the attributes of each widget.  It appears like
  82  * /sys/bus/hdaudioC0D0/widgets/04/caps
  83  */
  84
  85 struct widget_attribute;
  86
  87 struct widget_attribute {
  88         struct attribute        attr;
  89         ssize_t (*show)(struct hdac_device *codec, hda_nid_t nid,
  90                         struct widget_attribute *attr, char *buf);
  91         ssize_t (*store)(struct hdac_device *codec, hda_nid_t nid,
  92                          struct widget_attribute *attr,
  93                          const char *buf, size_t count);
  94 };
  95
  96 static int get_codec_nid(struct kobject *kobj, struct hdac_device **codecp)
  97 {
  98         struct device *dev = kobj_to_dev(kobj->parent->parent);
  99         int nid;
 100         ssize_t ret;
 101
 102         ret = kstrtoint(kobj->name, 16, &nid);
 103         if (ret < 0)
 104                 return ret;
 105         *codecp = dev_to_hdac_dev(dev);
 106         return nid;
 107 }
 108
 109 static ssize_t widget_attr_show(struct kobject *kobj, struct attribute *attr,
 110                                 char *buf)
 111 {
 112         struct widget_attribute *wid_attr =
 113                 container_of(attr, struct widget_attribute, attr);
 114         struct hdac_device *codec;
 115         int nid;
 116
 117         if (!wid_attr->show)
 118                 return -EIO;
 119         nid = get_codec_nid(kobj, &codec);
 120         if (nid < 0)
 121                 return nid;
 122         return wid_attr->show(codec, nid, wid_attr, buf);
 123 }
 124
 125 static ssize_t widget_attr_store(struct kobject *kobj, struct attribute *attr,
 126                                  const char *buf, size_t count)
 127 {
 128         struct widget_attribute *wid_attr =
 129                 container_of(attr, struct widget_attribute, attr);
 130         struct hdac_device *codec;
 131         int nid;
 132
 133         if (!wid_attr->store)
 134                 return -EIO;
 135         nid = get_codec_nid(kobj, &codec);
 136         if (nid < 0)
 137                 return nid;
 138         return wid_attr->store(codec, nid, wid_attr, buf, count);
 139 }
 140
 141 static const struct sysfs_ops widget_sysfs_ops = {
 142         .show   = widget_attr_show,
 143         .store  = widget_attr_store,
 144 };
 145
 146 static void widget_release(struct kobject *kobj)
 147 {
 148         kfree(kobj);
 149 }
 150
 151 static struct kobj_type widget_ktype = {
 152         .release        = widget_release,
 153         .sysfs_ops      = &widget_sysfs_ops,
 154 };
 155
 156 #define WIDGET_ATTR_RO(_name) \
 157         struct widget_attribute wid_attr_##_name = __ATTR_RO(_name)
 158 #define WIDGET_ATTR_RW(_name) \
 159         struct widget_attribute wid_attr_##_name = __ATTR_RW(_name)
 160
 161 static ssize_t caps_show(struct hdac_device *codec, hda_nid_t nid,
 162                         struct widget_attribute *attr, char *buf)
 163 {
 164         return sprintf(buf, "0x%08x\n", get_wcaps(codec, nid));
 165 }
 166
 167 static ssize_t pin_caps_show(struct hdac_device *codec, hda_nid_t nid,
 168                              struct widget_attribute *attr, char *buf)
 169 {
 170         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 171                 return 0;
 172         return sprintf(buf, "0x%08x\n",
 173                        snd_hdac_read_parm(codec, nid, AC_PAR_PIN_CAP));
 174 }
 175
 176 static ssize_t pin_cfg_show(struct hdac_device *codec, hda_nid_t nid,
 177                             struct widget_attribute *attr, char *buf)
 178 {
 179         unsigned int val;
 180
 181         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
 182                 return 0;
 183         if (snd_hdac_read(codec, nid, AC_VERB_GET_CONFIG_DEFAULT, 0, &val))
 184                 return 0;
 185         return sprintf(buf, "0x%08x\n", val);
 186 }
 187
 188 static bool has_pcm_cap(struct hdac_device *codec, hda_nid_t nid)
 189 {
 190         if (nid == codec->afg || nid == codec->mfg)
 191                 return true;
 192         switch (get_wcaps_type(get_wcaps(codec, nid))) {
 193         case AC_WID_AUD_OUT:
 194         case AC_WID_AUD_IN:
 195                 return true;
 196         default:
 197                 return false;
 198         }
 199 }
 200
 201 static ssize_t pcm_caps_show(struct hdac_device *codec, hda_nid_t nid,
 202                              struct widget_attribute *attr, char *buf)
 203 {
 204         if (!has_pcm_cap(codec, nid))
 205                 return 0;
 206         return sprintf(buf, "0x%08x\n",
 207                        snd_hdac_read_parm(codec, nid, AC_PAR_PCM));
 208 }
 209
 210 static ssize_t pcm_formats_show(struct hdac_device *codec, hda_nid_t nid,
 211                                 struct widget_attribute *attr, char *buf)
 212 {
 213         if (!has_pcm_cap(codec, nid))
 214                 return 0;
 215         return sprintf(buf, "0x%08x\n",
 216                        snd_hdac_read_parm(codec, nid, AC_PAR_STREAM));
 217 }
 218
 219 static ssize_t amp_in_caps_show(struct hdac_device *codec, hda_nid_t nid,
 220                                 struct widget_attribute *attr, char *buf)
 221 {
 222         if (nid != codec->afg && !(get_wcaps(codec, nid) & AC_WCAP_IN_AMP))
 223                 return 0;
 224         return sprintf(buf, "0x%08x\n",
 225                        snd_hdac_read_parm(codec, nid, AC_PAR_AMP_IN_CAP));
 226 }
 227
 228 static ssize_t amp_out_caps_show(struct hdac_device *codec, hda_nid_t nid,
 229                                  struct widget_attribute *attr, char *buf)
 230 {
 231         if (nid != codec->afg && !(get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
 232                 return 0;
 233         return sprintf(buf, "0x%08x\n",
 234                        snd_hdac_read_parm(codec, nid, AC_PAR_AMP_OUT_CAP));
 235 }
 236
 237 static ssize_t power_caps_show(struct hdac_device *codec, hda_nid_t nid,
 238                                struct widget_attribute *attr, char *buf)
 239 {
 240         if (nid != codec->afg && !(get_wcaps(codec, nid) & AC_WCAP_POWER))
 241                 return 0;
 242         return sprintf(buf, "0x%08x\n",
 243                        snd_hdac_read_parm(codec, nid, AC_PAR_POWER_STATE));
 244 }
 245
 246 static ssize_t gpio_caps_show(struct hdac_device *codec, hda_nid_t nid,
 247                               struct widget_attribute *attr, char *buf)
 248 {
 249         return sprintf(buf, "0x%08x\n",
 250                        snd_hdac_read_parm(codec, nid, AC_PAR_GPIO_CAP));
 251 }
 252
 253 static ssize_t connections_show(struct hdac_device *codec, hda_nid_t nid,
 254                                 struct widget_attribute *attr, char *buf)
 255 {
 256         hda_nid_t list[32];
 257         int i, nconns;
 258         ssize_t ret = 0;
 259
 260         nconns = snd_hdac_get_connections(codec, nid, list, ARRAY_SIZE(list));
 261         if (nconns <= 0)
 262                 return nconns;
 263         for (i = 0; i < nconns; i++)
 264                 ret += sprintf(buf + ret, "%s0x%02x", i ? " " : "", list[i]);
 265         ret += sprintf(buf + ret, "\n");
 266         return ret;
 267 }
 268
 269 static WIDGET_ATTR_RO(caps);
 270 static WIDGET_ATTR_RO(pin_caps);
 271 static WIDGET_ATTR_RO(pin_cfg);
 272 static WIDGET_ATTR_RO(pcm_caps);
 273 static WIDGET_ATTR_RO(pcm_formats);
 274 static WIDGET_ATTR_RO(amp_in_caps);
 275 static WIDGET_ATTR_RO(amp_out_caps);
 276 static WIDGET_ATTR_RO(power_caps);
 277 static WIDGET_ATTR_RO(gpio_caps);
 278 static WIDGET_ATTR_RO(connections);
 279
 280 static struct attribute *widget_node_attrs[] = {
 281         &wid_attr_caps.attr,
 282         &wid_attr_pin_caps.attr,
 283         &wid_attr_pin_cfg.attr,
 284         &wid_attr_pcm_caps.attr,
 285         &wid_attr_pcm_formats.attr,
 286         &wid_attr_amp_in_caps.attr,
 287         &wid_attr_amp_out_caps.attr,
 288         &wid_attr_power_caps.attr,
 289         &wid_attr_connections.attr,
 290         NULL,
 291 };
 292
 293 static struct attribute *widget_afg_attrs[] = {
 294         &wid_attr_pcm_caps.attr,
 295         &wid_attr_pcm_formats.attr,
 296         &wid_attr_amp_in_caps.attr,
 297         &wid_attr_amp_out_caps.attr,
 298         &wid_attr_power_caps.attr,
 299         &wid_attr_gpio_caps.attr,
 300         NULL,
 301 };
 302
 303 static const struct attribute_group widget_node_group = {
 304         .attrs = widget_node_attrs,
 305 };
 306
 307 static const struct attribute_group widget_afg_group = {
 308         .attrs = widget_afg_attrs,
 309 };
 310
 311 static void free_widget_node(struct kobject *kobj,
 312                              const struct attribute_group *group)
 313 {
 314         if (kobj) {
 315                 sysfs_remove_group(kobj, group);
 316                 kobject_put(kobj);
 317         }
 318 }
 319
 320 static void widget_tree_free(struct hdac_device *codec)
 321 {
 322         struct hdac_widget_tree *tree = codec->widgets;
 323         struct kobject **p;
 324
 325         if (!tree)
 326                 return;
 327         free_widget_node(tree->afg, &widget_afg_group);
 328         if (tree->nodes) {
 329                 for (p = tree->nodes; *p; p++)
 330                         free_widget_node(*p, &widget_node_group);
 331                 kfree(tree->nodes);
 332         }
 333         kobject_put(tree->root);
 334         kfree(tree);
 335         codec->widgets = NULL;
 336 }
 337
 338 static int add_widget_node(struct kobject *parent, hda_nid_t nid,
 339                            const struct attribute_group *group,
 340                            struct kobject **res)
 341 {
 342         struct kobject *kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
 343         int err;
 344
 345         if (!kobj)
 346                 return -ENOMEM;
 347         kobject_init(kobj, &widget_ktype);
 348         err = kobject_add(kobj, parent, "%02x", nid);
 349         if (err < 0)
 350                 return err;
 351         err = sysfs_create_group(kobj, group);
 352         if (err < 0) {
 353                 kobject_put(kobj);
 354                 return err;
 355         }
 356
 357         *res = kobj;
 358         return 0;
 359 }
 360
 361 static int widget_tree_create(struct hdac_device *codec)
 362 {
 363         struct hdac_widget_tree *tree;
 364         int i, err;
 365         hda_nid_t nid;
 366
 367         tree = codec->widgets = kzalloc(sizeof(*tree), GFP_KERNEL);
 368         if (!tree)
 369                 return -ENOMEM;
 370
 371         tree->root = kobject_create_and_add("widgets", &codec->dev.kobj);
 372         if (!tree->root)
 373                 return -ENOMEM;
 374
 375         tree->nodes = kcalloc(codec->num_nodes + 1, sizeof(*tree->nodes),
 376                               GFP_KERNEL);
 377         if (!tree->nodes)
 378                 return -ENOMEM;
 379
 380         for (i = 0, nid = codec->start_nid; i < codec->num_nodes; i++, nid++) {
 381                 err = add_widget_node(tree->root, nid, &widget_node_group,
 382                                       &tree->nodes[i]);
 383                 if (err < 0)
 384                         return err;
 385         }
 386
 387         if (codec->afg) {
 388                 err = add_widget_node(tree->root, codec->afg,
 389                                       &widget_afg_group, &tree->afg);
 390                 if (err < 0)
 391                         return err;
 392         }
 393
 394         kobject_uevent(tree->root, KOBJ_CHANGE);
 395         return 0;
 396 }
 397
 398 /* call with codec->widget_lock held */
 399 int hda_widget_sysfs_init(struct hdac_device *codec)
 400 {
 401         int err;
 402
 403         if (codec->widgets)
 404                 return 0; /* already created */
 405
 406         err = widget_tree_create(codec);
 407         if (err < 0) {
 408                 widget_tree_free(codec);
 409                 return err;
 410         }
 411
 412         return 0;
 413 }
 414
 415 /* call with codec->widget_lock held */
 416 void hda_widget_sysfs_exit(struct hdac_device *codec)
 417 {
 418         widget_tree_free(codec);
 419 }
 420
 421 /* call with codec->widget_lock held */
 422 int hda_widget_sysfs_reinit(struct hdac_device *codec,
 423                             hda_nid_t start_nid, int num_nodes)
 424 {
 425         struct hdac_widget_tree *tree;
 426         hda_nid_t end_nid = start_nid + num_nodes;
 427         hda_nid_t nid;
 428         int i;
 429
 430         if (!codec->widgets)
 431                 return 0;
 432
 433         tree = kmemdup(codec->widgets, sizeof(*tree), GFP_KERNEL);
 434         if (!tree)
 435                 return -ENOMEM;
 436
 437         tree->nodes = kcalloc(num_nodes + 1, sizeof(*tree->nodes), GFP_KERNEL);
 438         if (!tree->nodes) {
 439                 kfree(tree);
 440                 return -ENOMEM;
 441         }
 442
 443         /* prune non-existing nodes */
 444         for (i = 0, nid = codec->start_nid; i < codec->num_nodes; i++, nid++) {
 445                 if (nid < start_nid || nid >= end_nid)
 446                         free_widget_node(codec->widgets->nodes[i],
 447                                          &widget_node_group);
 448         }
 449
 450         /* add new nodes */
 451         for (i = 0, nid = start_nid; i < num_nodes; i++, nid++) {
 452                 if (nid < codec->start_nid || nid >= codec->end_nid)
 453                         add_widget_node(tree->root, nid, &widget_node_group,
 454                                         &tree->nodes[i]);
 455                 else
 456                         tree->nodes[i] =
 457                                 codec->widgets->nodes[nid - codec->start_nid];
 458         }
 459
 460         /* replace with the new tree */
 461         kfree(codec->widgets->nodes);
 462         kfree(codec->widgets);
 463         codec->widgets = tree;
 464
 465         kobject_uevent(tree->root, KOBJ_CHANGE);
 466         return 0;
 467 }