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