1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * sysfs interface for HD-audio codec
4 *
5 * Copyright (c) 2014 Takashi Iwai <tiwai@suse.de>
6 *
7 * split from hda_hwdep.c
8 */
9
10 #include <linux/init.h>
11 #include <linux/slab.h>
12 #include <linux/compat.h>
13 #include <linux/mutex.h>
14 #include <linux/ctype.h>
15 #include <linux/string.h>
16 #include <linux/export.h>
17 #include <sound/core.h>
18 #include <sound/hda_codec.h>
19 #include "hda_local.h"
20 #include <sound/hda_hwdep.h>
21 #include <sound/minors.h>
22
23 /* hint string pair */
24 struct hda_hint {
25 const char *key;
26 const char *val; /* contained in the same alloc as key */
27 };
28
29 #ifdef CONFIG_PM
power_on_acct_show(struct device * dev,struct device_attribute * attr,char * buf)30 static ssize_t power_on_acct_show(struct device *dev,
31 struct device_attribute *attr,
32 char *buf)
33 {
34 struct hda_codec *codec = dev_get_drvdata(dev);
35 snd_hda_update_power_acct(codec);
36 return sysfs_emit(buf, "%u\n", jiffies_to_msecs(codec->power_on_acct));
37 }
38
power_off_acct_show(struct device * dev,struct device_attribute * attr,char * buf)39 static ssize_t power_off_acct_show(struct device *dev,
40 struct device_attribute *attr,
41 char *buf)
42 {
43 struct hda_codec *codec = dev_get_drvdata(dev);
44 snd_hda_update_power_acct(codec);
45 return sysfs_emit(buf, "%u\n", jiffies_to_msecs(codec->power_off_acct));
46 }
47
48 static DEVICE_ATTR_RO(power_on_acct);
49 static DEVICE_ATTR_RO(power_off_acct);
50 #endif /* CONFIG_PM */
51
52 #define CODEC_INFO_SHOW(type, field) \
53 static ssize_t type##_show(struct device *dev, \
54 struct device_attribute *attr, \
55 char *buf) \
56 { \
57 struct hda_codec *codec = dev_get_drvdata(dev); \
58 return sysfs_emit(buf, "0x%x\n", codec->field); \
59 }
60
61 #define CODEC_INFO_STR_SHOW(type, field) \
62 static ssize_t type##_show(struct device *dev, \
63 struct device_attribute *attr, \
64 char *buf) \
65 { \
66 struct hda_codec *codec = dev_get_drvdata(dev); \
67 return sysfs_emit(buf, "%s\n", \
68 codec->field ? codec->field : ""); \
69 }
70
71 CODEC_INFO_SHOW(vendor_id, core.vendor_id);
72 CODEC_INFO_SHOW(subsystem_id, core.subsystem_id);
73 CODEC_INFO_SHOW(revision_id, core.revision_id);
74 CODEC_INFO_SHOW(afg, core.afg);
75 CODEC_INFO_SHOW(mfg, core.mfg);
76 CODEC_INFO_STR_SHOW(vendor_name, core.vendor_name);
77 CODEC_INFO_STR_SHOW(chip_name, core.chip_name);
78 CODEC_INFO_STR_SHOW(modelname, modelname);
79
pin_configs_show(struct hda_codec * codec,struct snd_array * list,char * buf)80 static ssize_t pin_configs_show(struct hda_codec *codec,
81 struct snd_array *list,
82 char *buf)
83 {
84 const struct hda_pincfg *pin;
85 int i, len = 0;
86 mutex_lock(&codec->user_mutex);
87 snd_array_for_each(list, i, pin) {
88 len += sysfs_emit_at(buf, len, "0x%02x 0x%08x\n",
89 pin->nid, pin->cfg);
90 }
91 mutex_unlock(&codec->user_mutex);
92 return len;
93 }
94
init_pin_configs_show(struct device * dev,struct device_attribute * attr,char * buf)95 static ssize_t init_pin_configs_show(struct device *dev,
96 struct device_attribute *attr,
97 char *buf)
98 {
99 struct hda_codec *codec = dev_get_drvdata(dev);
100 return pin_configs_show(codec, &codec->init_pins, buf);
101 }
102
driver_pin_configs_show(struct device * dev,struct device_attribute * attr,char * buf)103 static ssize_t driver_pin_configs_show(struct device *dev,
104 struct device_attribute *attr,
105 char *buf)
106 {
107 struct hda_codec *codec = dev_get_drvdata(dev);
108 return pin_configs_show(codec, &codec->driver_pins, buf);
109 }
110
111 #ifdef CONFIG_SND_HDA_RECONFIG
112
113 /*
114 * sysfs interface
115 */
116
clear_codec(struct hda_codec * codec)117 static int clear_codec(struct hda_codec *codec)
118 {
119 int err;
120
121 err = snd_hda_codec_reset(codec);
122 if (err < 0) {
123 codec_err(codec, "The codec is being used, can't free.\n");
124 return err;
125 }
126 snd_hda_sysfs_clear(codec);
127 return 0;
128 }
129
reconfig_codec(struct hda_codec * codec)130 static int reconfig_codec(struct hda_codec *codec)
131 {
132 int err;
133
134 snd_hda_power_up(codec);
135 codec_info(codec, "hda-codec: reconfiguring\n");
136 err = snd_hda_codec_reset(codec);
137 if (err < 0) {
138 codec_err(codec,
139 "The codec is being used, can't reconfigure.\n");
140 goto error;
141 }
142 err = device_reprobe(hda_codec_dev(codec));
143 if (err < 0)
144 goto error;
145 err = snd_card_register(codec->card);
146 error:
147 snd_hda_power_down(codec);
148 return err;
149 }
150
151 /*
152 * allocate a string at most len chars, and remove the trailing EOL
153 */
kstrndup_noeol(const char * src,size_t len)154 static char *kstrndup_noeol(const char *src, size_t len)
155 {
156 char *s = kstrndup(src, len, GFP_KERNEL);
157 char *p;
158 if (!s)
159 return NULL;
160 p = strchr(s, '\n');
161 if (p)
162 *p = 0;
163 return s;
164 }
165
166 #define CODEC_INFO_STORE(type, field) \
167 static ssize_t type##_store(struct device *dev, \
168 struct device_attribute *attr, \
169 const char *buf, size_t count) \
170 { \
171 struct hda_codec *codec = dev_get_drvdata(dev); \
172 unsigned long val; \
173 int err = kstrtoul(buf, 0, &val); \
174 if (err < 0) \
175 return err; \
176 codec->field = val; \
177 return count; \
178 }
179
180 #define CODEC_INFO_STR_STORE(type, field) \
181 static ssize_t type##_store(struct device *dev, \
182 struct device_attribute *attr, \
183 const char *buf, size_t count) \
184 { \
185 struct hda_codec *codec = dev_get_drvdata(dev); \
186 char *s = kstrndup_noeol(buf, 64); \
187 if (!s) \
188 return -ENOMEM; \
189 kfree(codec->field); \
190 codec->field = s; \
191 return count; \
192 }
193
194 CODEC_INFO_STORE(vendor_id, core.vendor_id);
195 CODEC_INFO_STORE(subsystem_id, core.subsystem_id);
196 CODEC_INFO_STORE(revision_id, core.revision_id);
197 CODEC_INFO_STR_STORE(vendor_name, core.vendor_name);
198 CODEC_INFO_STR_STORE(chip_name, core.chip_name);
199 CODEC_INFO_STR_STORE(modelname, modelname);
200
201 #define CODEC_ACTION_STORE(type) \
202 static ssize_t type##_store(struct device *dev, \
203 struct device_attribute *attr, \
204 const char *buf, size_t count) \
205 { \
206 struct hda_codec *codec = dev_get_drvdata(dev); \
207 int err = 0; \
208 if (*buf) \
209 err = type##_codec(codec); \
210 return err < 0 ? err : count; \
211 }
212
213 CODEC_ACTION_STORE(reconfig);
214 CODEC_ACTION_STORE(clear);
215
init_verbs_show(struct device * dev,struct device_attribute * attr,char * buf)216 static ssize_t init_verbs_show(struct device *dev,
217 struct device_attribute *attr,
218 char *buf)
219 {
220 struct hda_codec *codec = dev_get_drvdata(dev);
221 const struct hda_verb *v;
222 int i, len = 0;
223 mutex_lock(&codec->user_mutex);
224 snd_array_for_each(&codec->init_verbs, i, v) {
225 len += sysfs_emit_at(buf, len, "0x%02x 0x%03x 0x%04x\n",
226 v->nid, v->verb, v->param);
227 }
228 mutex_unlock(&codec->user_mutex);
229 return len;
230 }
231
parse_init_verbs(struct hda_codec * codec,const char * buf)232 static int parse_init_verbs(struct hda_codec *codec, const char *buf)
233 {
234 struct hda_verb *v;
235 int nid, verb, param;
236
237 if (sscanf(buf, "%i %i %i", &nid, &verb, ¶m) != 3)
238 return -EINVAL;
239 if (!nid || !verb)
240 return -EINVAL;
241 mutex_lock(&codec->user_mutex);
242 v = snd_array_new(&codec->init_verbs);
243 if (!v) {
244 mutex_unlock(&codec->user_mutex);
245 return -ENOMEM;
246 }
247 v->nid = nid;
248 v->verb = verb;
249 v->param = param;
250 mutex_unlock(&codec->user_mutex);
251 return 0;
252 }
253
init_verbs_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)254 static ssize_t init_verbs_store(struct device *dev,
255 struct device_attribute *attr,
256 const char *buf, size_t count)
257 {
258 struct hda_codec *codec = dev_get_drvdata(dev);
259 int err = parse_init_verbs(codec, buf);
260 if (err < 0)
261 return err;
262 return count;
263 }
264
hints_show(struct device * dev,struct device_attribute * attr,char * buf)265 static ssize_t hints_show(struct device *dev,
266 struct device_attribute *attr,
267 char *buf)
268 {
269 struct hda_codec *codec = dev_get_drvdata(dev);
270 const struct hda_hint *hint;
271 int i, len = 0;
272 mutex_lock(&codec->user_mutex);
273 snd_array_for_each(&codec->hints, i, hint) {
274 len += sysfs_emit_at(buf, len, "%s = %s\n",
275 hint->key, hint->val);
276 }
277 mutex_unlock(&codec->user_mutex);
278 return len;
279 }
280
get_hint(struct hda_codec * codec,const char * key)281 static struct hda_hint *get_hint(struct hda_codec *codec, const char *key)
282 {
283 struct hda_hint *hint;
284 int i;
285
286 snd_array_for_each(&codec->hints, i, hint) {
287 if (!strcmp(hint->key, key))
288 return hint;
289 }
290 return NULL;
291 }
292
remove_trail_spaces(char * str)293 static void remove_trail_spaces(char *str)
294 {
295 char *p;
296 if (!*str)
297 return;
298 p = str + strlen(str) - 1;
299 for (; isspace(*p); p--) {
300 *p = 0;
301 if (p == str)
302 return;
303 }
304 }
305
306 #define MAX_HINTS 1024
307
parse_hints(struct hda_codec * codec,const char * buf)308 static int parse_hints(struct hda_codec *codec, const char *buf)
309 {
310 char *key, *val;
311 struct hda_hint *hint;
312 int err = 0;
313
314 buf = skip_spaces(buf);
315 if (!*buf || *buf == '#' || *buf == '\n')
316 return 0;
317 if (*buf == '=')
318 return -EINVAL;
319 key = kstrndup_noeol(buf, 1024);
320 if (!key)
321 return -ENOMEM;
322 /* extract key and val */
323 val = strchr(key, '=');
324 if (!val) {
325 kfree(key);
326 return -EINVAL;
327 }
328 *val++ = 0;
329 val = skip_spaces(val);
330 remove_trail_spaces(key);
331 remove_trail_spaces(val);
332 mutex_lock(&codec->user_mutex);
333 hint = get_hint(codec, key);
334 if (hint) {
335 /* replace */
336 kfree(hint->key);
337 hint->key = key;
338 hint->val = val;
339 goto unlock;
340 }
341 /* allocate a new hint entry */
342 if (codec->hints.used >= MAX_HINTS)
343 hint = NULL;
344 else
345 hint = snd_array_new(&codec->hints);
346 if (hint) {
347 hint->key = key;
348 hint->val = val;
349 } else {
350 err = -ENOMEM;
351 }
352 unlock:
353 mutex_unlock(&codec->user_mutex);
354 if (err)
355 kfree(key);
356 return err;
357 }
358
hints_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)359 static ssize_t hints_store(struct device *dev,
360 struct device_attribute *attr,
361 const char *buf, size_t count)
362 {
363 struct hda_codec *codec = dev_get_drvdata(dev);
364 int err = parse_hints(codec, buf);
365 if (err < 0)
366 return err;
367 return count;
368 }
369
user_pin_configs_show(struct device * dev,struct device_attribute * attr,char * buf)370 static ssize_t user_pin_configs_show(struct device *dev,
371 struct device_attribute *attr,
372 char *buf)
373 {
374 struct hda_codec *codec = dev_get_drvdata(dev);
375 return pin_configs_show(codec, &codec->user_pins, buf);
376 }
377
parse_user_pin_configs(struct hda_codec * codec,const char * buf)378 static int parse_user_pin_configs(struct hda_codec *codec, const char *buf)
379 {
380 int nid, cfg, err;
381
382 if (sscanf(buf, "%i %i", &nid, &cfg) != 2)
383 return -EINVAL;
384 if (!nid)
385 return -EINVAL;
386 mutex_lock(&codec->user_mutex);
387 err = snd_hda_add_pincfg(codec, &codec->user_pins, nid, cfg);
388 mutex_unlock(&codec->user_mutex);
389 return err;
390 }
391
user_pin_configs_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)392 static ssize_t user_pin_configs_store(struct device *dev,
393 struct device_attribute *attr,
394 const char *buf, size_t count)
395 {
396 struct hda_codec *codec = dev_get_drvdata(dev);
397 int err = parse_user_pin_configs(codec, buf);
398 if (err < 0)
399 return err;
400 return count;
401 }
402
403 /* sysfs attributes exposed only when CONFIG_SND_HDA_RECONFIG=y */
404 static DEVICE_ATTR_RW(init_verbs);
405 static DEVICE_ATTR_RW(hints);
406 static DEVICE_ATTR_RW(user_pin_configs);
407 static DEVICE_ATTR_WO(reconfig);
408 static DEVICE_ATTR_WO(clear);
409
410 /**
411 * snd_hda_get_hint - Look for hint string
412 * @codec: the HDA codec
413 * @key: the hint key string
414 *
415 * Look for a hint key/value pair matching with the given key string
416 * and returns the value string. If nothing found, returns NULL.
417 */
snd_hda_get_hint(struct hda_codec * codec,const char * key)418 const char *snd_hda_get_hint(struct hda_codec *codec, const char *key)
419 {
420 struct hda_hint *hint = get_hint(codec, key);
421 return hint ? hint->val : NULL;
422 }
423 EXPORT_SYMBOL_GPL(snd_hda_get_hint);
424
425 /**
426 * snd_hda_get_bool_hint - Get a boolean hint value
427 * @codec: the HDA codec
428 * @key: the hint key string
429 *
430 * Look for a hint key/value pair matching with the given key string
431 * and returns a boolean value parsed from the value. If no matching
432 * key is found, return a negative value.
433 */
snd_hda_get_bool_hint(struct hda_codec * codec,const char * key)434 int snd_hda_get_bool_hint(struct hda_codec *codec, const char *key)
435 {
436 const char *p;
437 int ret;
438
439 mutex_lock(&codec->user_mutex);
440 p = snd_hda_get_hint(codec, key);
441 if (!p || !*p)
442 ret = -ENOENT;
443 else {
444 switch (toupper(*p)) {
445 case 'T': /* true */
446 case 'Y': /* yes */
447 case '1':
448 ret = 1;
449 break;
450 default:
451 ret = 0;
452 break;
453 }
454 }
455 mutex_unlock(&codec->user_mutex);
456 return ret;
457 }
458 EXPORT_SYMBOL_GPL(snd_hda_get_bool_hint);
459
460 /**
461 * snd_hda_get_int_hint - Get an integer hint value
462 * @codec: the HDA codec
463 * @key: the hint key string
464 * @valp: pointer to store a value
465 *
466 * Look for a hint key/value pair matching with the given key string
467 * and stores the integer value to @valp. If no matching key is found,
468 * return a negative error code. Otherwise it returns zero.
469 */
snd_hda_get_int_hint(struct hda_codec * codec,const char * key,int * valp)470 int snd_hda_get_int_hint(struct hda_codec *codec, const char *key, int *valp)
471 {
472 const char *p;
473 unsigned long val;
474 int ret;
475
476 mutex_lock(&codec->user_mutex);
477 p = snd_hda_get_hint(codec, key);
478 if (!p)
479 ret = -ENOENT;
480 else if (kstrtoul(p, 0, &val))
481 ret = -EINVAL;
482 else {
483 *valp = val;
484 ret = 0;
485 }
486 mutex_unlock(&codec->user_mutex);
487 return ret;
488 }
489 EXPORT_SYMBOL_GPL(snd_hda_get_int_hint);
490 #endif /* CONFIG_SND_HDA_RECONFIG */
491
492 /*
493 * common sysfs attributes
494 */
495 #ifdef CONFIG_SND_HDA_RECONFIG
496 #define RECONFIG_DEVICE_ATTR(name) DEVICE_ATTR_RW(name)
497 #else
498 #define RECONFIG_DEVICE_ATTR(name) DEVICE_ATTR_RO(name)
499 #endif
500 static RECONFIG_DEVICE_ATTR(vendor_id);
501 static RECONFIG_DEVICE_ATTR(subsystem_id);
502 static RECONFIG_DEVICE_ATTR(revision_id);
503 static DEVICE_ATTR_RO(afg);
504 static DEVICE_ATTR_RO(mfg);
505 static RECONFIG_DEVICE_ATTR(vendor_name);
506 static RECONFIG_DEVICE_ATTR(chip_name);
507 static RECONFIG_DEVICE_ATTR(modelname);
508 static DEVICE_ATTR_RO(init_pin_configs);
509 static DEVICE_ATTR_RO(driver_pin_configs);
510
511
512 #ifdef CONFIG_SND_HDA_PATCH_LOADER
513
514 /* parser mode */
515 enum {
516 LINE_MODE_NONE,
517 LINE_MODE_CODEC,
518 LINE_MODE_MODEL,
519 LINE_MODE_PINCFG,
520 LINE_MODE_VERB,
521 LINE_MODE_HINT,
522 LINE_MODE_VENDOR_ID,
523 LINE_MODE_SUBSYSTEM_ID,
524 LINE_MODE_REVISION_ID,
525 LINE_MODE_CHIP_NAME,
526 NUM_LINE_MODES,
527 };
528
strmatch(const char * a,const char * b)529 static inline int strmatch(const char *a, const char *b)
530 {
531 return strncasecmp(a, b, strlen(b)) == 0;
532 }
533
534 /* parse the contents after the line "[codec]"
535 * accept only the line with three numbers, and assign the current codec
536 */
parse_codec_mode(char * buf,struct hda_bus * bus,struct hda_codec ** codecp)537 static void parse_codec_mode(char *buf, struct hda_bus *bus,
538 struct hda_codec **codecp)
539 {
540 int vendorid, subid, caddr;
541 struct hda_codec *codec;
542
543 *codecp = NULL;
544 if (sscanf(buf, "%i %i %i", &vendorid, &subid, &caddr) == 3) {
545 list_for_each_codec(codec, bus) {
546 if ((vendorid <= 0 || codec->core.vendor_id == vendorid) &&
547 (subid <= 0 || codec->core.subsystem_id == subid) &&
548 codec->core.addr == caddr) {
549 *codecp = codec;
550 break;
551 }
552 }
553 }
554 }
555
556 /* parse the contents after the other command tags, [pincfg], [verb],
557 * [vendor_id], [subsystem_id], [revision_id], [chip_name], [hint] and [model]
558 * just pass to the sysfs helper (only when any codec was specified)
559 */
parse_pincfg_mode(char * buf,struct hda_bus * bus,struct hda_codec ** codecp)560 static void parse_pincfg_mode(char *buf, struct hda_bus *bus,
561 struct hda_codec **codecp)
562 {
563 parse_user_pin_configs(*codecp, buf);
564 }
565
parse_verb_mode(char * buf,struct hda_bus * bus,struct hda_codec ** codecp)566 static void parse_verb_mode(char *buf, struct hda_bus *bus,
567 struct hda_codec **codecp)
568 {
569 parse_init_verbs(*codecp, buf);
570 }
571
parse_hint_mode(char * buf,struct hda_bus * bus,struct hda_codec ** codecp)572 static void parse_hint_mode(char *buf, struct hda_bus *bus,
573 struct hda_codec **codecp)
574 {
575 parse_hints(*codecp, buf);
576 }
577
parse_model_mode(char * buf,struct hda_bus * bus,struct hda_codec ** codecp)578 static void parse_model_mode(char *buf, struct hda_bus *bus,
579 struct hda_codec **codecp)
580 {
581 kfree((*codecp)->modelname);
582 (*codecp)->modelname = kstrdup(buf, GFP_KERNEL);
583 }
584
parse_chip_name_mode(char * buf,struct hda_bus * bus,struct hda_codec ** codecp)585 static void parse_chip_name_mode(char *buf, struct hda_bus *bus,
586 struct hda_codec **codecp)
587 {
588 snd_hda_codec_set_name(*codecp, buf);
589 }
590
591 #define DEFINE_PARSE_ID_MODE(name) \
592 static void parse_##name##_mode(char *buf, struct hda_bus *bus, \
593 struct hda_codec **codecp) \
594 { \
595 unsigned long val; \
596 if (!kstrtoul(buf, 0, &val)) \
597 (*codecp)->core.name = val; \
598 }
599
600 DEFINE_PARSE_ID_MODE(vendor_id);
601 DEFINE_PARSE_ID_MODE(subsystem_id);
602 DEFINE_PARSE_ID_MODE(revision_id);
603
604
605 struct hda_patch_item {
606 const char *tag;
607 const char *alias;
608 void (*parser)(char *buf, struct hda_bus *bus, struct hda_codec **retc);
609 };
610
611 static const struct hda_patch_item patch_items[NUM_LINE_MODES] = {
612 [LINE_MODE_CODEC] = {
613 .tag = "[codec]",
614 .parser = parse_codec_mode,
615 },
616 [LINE_MODE_MODEL] = {
617 .tag = "[model]",
618 .parser = parse_model_mode,
619 },
620 [LINE_MODE_VERB] = {
621 .tag = "[verb]",
622 .alias = "[init_verbs]",
623 .parser = parse_verb_mode,
624 },
625 [LINE_MODE_PINCFG] = {
626 .tag = "[pincfg]",
627 .alias = "[user_pin_configs]",
628 .parser = parse_pincfg_mode,
629 },
630 [LINE_MODE_HINT] = {
631 .tag = "[hint]",
632 .alias = "[hints]",
633 .parser = parse_hint_mode
634 },
635 [LINE_MODE_VENDOR_ID] = {
636 .tag = "[vendor_id]",
637 .parser = parse_vendor_id_mode,
638 },
639 [LINE_MODE_SUBSYSTEM_ID] = {
640 .tag = "[subsystem_id]",
641 .parser = parse_subsystem_id_mode,
642 },
643 [LINE_MODE_REVISION_ID] = {
644 .tag = "[revision_id]",
645 .parser = parse_revision_id_mode,
646 },
647 [LINE_MODE_CHIP_NAME] = {
648 .tag = "[chip_name]",
649 .parser = parse_chip_name_mode,
650 },
651 };
652
653 /* check the line starting with '[' -- change the parser mode accodingly */
parse_line_mode(char * buf,struct hda_bus * bus)654 static int parse_line_mode(char *buf, struct hda_bus *bus)
655 {
656 int i;
657 for (i = 0; i < ARRAY_SIZE(patch_items); i++) {
658 if (!patch_items[i].tag)
659 continue;
660 if (strmatch(buf, patch_items[i].tag))
661 return i;
662 if (patch_items[i].alias && strmatch(buf, patch_items[i].alias))
663 return i;
664 }
665 return LINE_MODE_NONE;
666 }
667
668 /* copy one line from the buffer in fw, and update the fields in fw
669 * return zero if it reaches to the end of the buffer, or non-zero
670 * if successfully copied a line
671 *
672 * the spaces at the beginning and the end of the line are stripped
673 */
get_line_from_fw(char * buf,int size,size_t * fw_size_p,const void ** fw_data_p)674 static int get_line_from_fw(char *buf, int size, size_t *fw_size_p,
675 const void **fw_data_p)
676 {
677 int len;
678 size_t fw_size = *fw_size_p;
679 const char *p = *fw_data_p;
680
681 while (isspace(*p) && fw_size) {
682 p++;
683 fw_size--;
684 }
685 if (!fw_size)
686 return 0;
687
688 for (len = 0; len < fw_size; len++) {
689 if (!*p)
690 break;
691 if (*p == '\n') {
692 p++;
693 len++;
694 break;
695 }
696 if (len < size)
697 *buf++ = *p++;
698 }
699 *buf = 0;
700 *fw_size_p = fw_size - len;
701 *fw_data_p = p;
702 remove_trail_spaces(buf);
703 return 1;
704 }
705
706 /**
707 * snd_hda_load_patch - load a "patch" firmware file and parse it
708 * @bus: HD-audio bus
709 * @fw_size: the firmware byte size
710 * @fw_buf: the firmware data
711 */
snd_hda_load_patch(struct hda_bus * bus,size_t fw_size,const void * fw_buf)712 int snd_hda_load_patch(struct hda_bus *bus, size_t fw_size, const void *fw_buf)
713 {
714 char buf[128];
715 struct hda_codec *codec;
716 int line_mode;
717
718 line_mode = LINE_MODE_NONE;
719 codec = NULL;
720 while (get_line_from_fw(buf, sizeof(buf) - 1, &fw_size, &fw_buf)) {
721 if (!*buf || *buf == '#' || *buf == '\n')
722 continue;
723 if (*buf == '[')
724 line_mode = parse_line_mode(buf, bus);
725 else if (patch_items[line_mode].parser &&
726 (codec || line_mode <= LINE_MODE_CODEC))
727 patch_items[line_mode].parser(buf, bus, &codec);
728 }
729 return 0;
730 }
731 EXPORT_SYMBOL_GPL(snd_hda_load_patch);
732 #endif /* CONFIG_SND_HDA_PATCH_LOADER */
733
734 /*
735 * sysfs entries
736 */
737 static struct attribute *hda_dev_attrs[] = {
738 &dev_attr_vendor_id.attr,
739 &dev_attr_subsystem_id.attr,
740 &dev_attr_revision_id.attr,
741 &dev_attr_afg.attr,
742 &dev_attr_mfg.attr,
743 &dev_attr_vendor_name.attr,
744 &dev_attr_chip_name.attr,
745 &dev_attr_modelname.attr,
746 &dev_attr_init_pin_configs.attr,
747 &dev_attr_driver_pin_configs.attr,
748 #ifdef CONFIG_PM
749 &dev_attr_power_on_acct.attr,
750 &dev_attr_power_off_acct.attr,
751 #endif
752 #ifdef CONFIG_SND_HDA_RECONFIG
753 &dev_attr_init_verbs.attr,
754 &dev_attr_hints.attr,
755 &dev_attr_user_pin_configs.attr,
756 &dev_attr_reconfig.attr,
757 &dev_attr_clear.attr,
758 #endif
759 NULL
760 };
761
762 static const struct attribute_group hda_dev_attr_group = {
763 .attrs = hda_dev_attrs,
764 };
765
766 const struct attribute_group *snd_hda_dev_attr_groups[] = {
767 &hda_dev_attr_group,
768 NULL
769 };
770
snd_hda_sysfs_init(struct hda_codec * codec)771 void snd_hda_sysfs_init(struct hda_codec *codec)
772 {
773 mutex_init(&codec->user_mutex);
774 #ifdef CONFIG_SND_HDA_RECONFIG
775 snd_array_init(&codec->init_verbs, sizeof(struct hda_verb), 32);
776 snd_array_init(&codec->hints, sizeof(struct hda_hint), 32);
777 snd_array_init(&codec->user_pins, sizeof(struct hda_pincfg), 16);
778 #endif
779 }
780
snd_hda_sysfs_clear(struct hda_codec * codec)781 void snd_hda_sysfs_clear(struct hda_codec *codec)
782 {
783 #ifdef CONFIG_SND_HDA_RECONFIG
784 struct hda_hint *hint;
785 int i;
786
787 /* clear init verbs */
788 snd_array_free(&codec->init_verbs);
789 /* clear hints */
790 snd_array_for_each(&codec->hints, i, hint) {
791 kfree(hint->key); /* we don't need to free hint->val */
792 }
793 snd_array_free(&codec->hints);
794 snd_array_free(&codec->user_pins);
795 #endif
796 }
797
