1172 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * HD-audio codec core device4 */5 6#include <linux/init.h>7#include <linux/delay.h>8#include <linux/device.h>9#include <linux/slab.h>10#include <linux/module.h>11#include <linux/export.h>12#include <linux/pm_runtime.h>13#include <sound/hdaudio.h>14#include <sound/hda_regmap.h>15#include <sound/pcm.h>16#include <sound/pcm_params.h>17#include "local.h"18 19static void setup_fg_nodes(struct hdac_device *codec);20static int get_codec_vendor_name(struct hdac_device *codec);21 22static void default_release(struct device *dev)23{24 snd_hdac_device_exit(dev_to_hdac_dev(dev));25}26 27/**28 * snd_hdac_device_init - initialize the HD-audio codec base device29 * @codec: device to initialize30 * @bus: but to attach31 * @name: device name string32 * @addr: codec address33 *34 * Returns zero for success or a negative error code.35 *36 * This function increments the runtime PM counter and marks it active.37 * The caller needs to turn it off appropriately later.38 *39 * The caller needs to set the device's release op properly by itself.40 */41int snd_hdac_device_init(struct hdac_device *codec, struct hdac_bus *bus,42 const char *name, unsigned int addr)43{44 struct device *dev;45 hda_nid_t fg;46 int err;47 48 dev = &codec->dev;49 device_initialize(dev);50 dev->parent = bus->dev;51 dev->bus = &snd_hda_bus_type;52 dev->release = default_release;53 dev->groups = hdac_dev_attr_groups;54 dev_set_name(dev, "%s", name);55 device_enable_async_suspend(dev);56 57 codec->bus = bus;58 codec->addr = addr;59 codec->type = HDA_DEV_CORE;60 mutex_init(&codec->widget_lock);61 mutex_init(&codec->regmap_lock);62 pm_runtime_set_active(&codec->dev);63 pm_runtime_get_noresume(&codec->dev);64 atomic_set(&codec->in_pm, 0);65 66 err = snd_hdac_bus_add_device(bus, codec);67 if (err < 0)68 goto error;69 70 /* fill parameters */71 codec->vendor_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,72 AC_PAR_VENDOR_ID);73 if (codec->vendor_id == -1) {74 /* read again, hopefully the access method was corrected75 * in the last read...76 */77 codec->vendor_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,78 AC_PAR_VENDOR_ID);79 }80 81 codec->subsystem_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,82 AC_PAR_SUBSYSTEM_ID);83 codec->revision_id = snd_hdac_read_parm(codec, AC_NODE_ROOT,84 AC_PAR_REV_ID);85 86 setup_fg_nodes(codec);87 if (!codec->afg && !codec->mfg) {88 dev_err(dev, "no AFG or MFG node found\n");89 err = -ENODEV;90 goto error;91 }92 93 fg = codec->afg ? codec->afg : codec->mfg;94 95 err = snd_hdac_refresh_widgets(codec);96 if (err < 0)97 goto error;98 99 codec->power_caps = snd_hdac_read_parm(codec, fg, AC_PAR_POWER_STATE);100 /* reread ssid if not set by parameter */101 if (codec->subsystem_id == -1 || codec->subsystem_id == 0)102 snd_hdac_read(codec, fg, AC_VERB_GET_SUBSYSTEM_ID, 0,103 &codec->subsystem_id);104 105 err = get_codec_vendor_name(codec);106 if (err < 0)107 goto error;108 109 codec->chip_name = kasprintf(GFP_KERNEL, "ID %x",110 codec->vendor_id & 0xffff);111 if (!codec->chip_name) {112 err = -ENOMEM;113 goto error;114 }115 116 return 0;117 118 error:119 put_device(&codec->dev);120 return err;121}122EXPORT_SYMBOL_GPL(snd_hdac_device_init);123 124/**125 * snd_hdac_device_exit - clean up the HD-audio codec base device126 * @codec: device to clean up127 */128void snd_hdac_device_exit(struct hdac_device *codec)129{130 pm_runtime_put_noidle(&codec->dev);131 /* keep balance of runtime PM child_count in parent device */132 pm_runtime_set_suspended(&codec->dev);133 snd_hdac_bus_remove_device(codec->bus, codec);134 kfree(codec->vendor_name);135 kfree(codec->chip_name);136}137EXPORT_SYMBOL_GPL(snd_hdac_device_exit);138 139/**140 * snd_hdac_device_register - register the hd-audio codec base device141 * @codec: the device to register142 */143int snd_hdac_device_register(struct hdac_device *codec)144{145 int err;146 147 err = device_add(&codec->dev);148 if (err < 0)149 return err;150 mutex_lock(&codec->widget_lock);151 err = hda_widget_sysfs_init(codec);152 mutex_unlock(&codec->widget_lock);153 if (err < 0) {154 device_del(&codec->dev);155 return err;156 }157 158 return 0;159}160EXPORT_SYMBOL_GPL(snd_hdac_device_register);161 162/**163 * snd_hdac_device_unregister - unregister the hd-audio codec base device164 * @codec: the device to unregister165 */166void snd_hdac_device_unregister(struct hdac_device *codec)167{168 if (device_is_registered(&codec->dev)) {169 mutex_lock(&codec->widget_lock);170 hda_widget_sysfs_exit(codec);171 mutex_unlock(&codec->widget_lock);172 device_del(&codec->dev);173 snd_hdac_bus_remove_device(codec->bus, codec);174 }175}176EXPORT_SYMBOL_GPL(snd_hdac_device_unregister);177 178/**179 * snd_hdac_device_set_chip_name - set/update the codec name180 * @codec: the HDAC device181 * @name: name string to set182 *183 * Returns 0 if the name is set or updated, or a negative error code.184 */185int snd_hdac_device_set_chip_name(struct hdac_device *codec, const char *name)186{187 char *newname;188 189 if (!name)190 return 0;191 newname = kstrdup(name, GFP_KERNEL);192 if (!newname)193 return -ENOMEM;194 kfree(codec->chip_name);195 codec->chip_name = newname;196 return 0;197}198EXPORT_SYMBOL_GPL(snd_hdac_device_set_chip_name);199 200/**201 * snd_hdac_codec_modalias - give the module alias name202 * @codec: HDAC device203 * @buf: string buffer to store204 * @size: string buffer size205 *206 * Returns the size of string, like snprintf(), or a negative error code.207 */208int snd_hdac_codec_modalias(const struct hdac_device *codec, char *buf, size_t size)209{210 return scnprintf(buf, size, "hdaudio:v%08Xr%08Xa%02X\n",211 codec->vendor_id, codec->revision_id, codec->type);212}213EXPORT_SYMBOL_GPL(snd_hdac_codec_modalias);214 215/**216 * snd_hdac_make_cmd - compose a 32bit command word to be sent to the217 * HD-audio controller218 * @codec: the codec object219 * @nid: NID to encode220 * @verb: verb to encode221 * @parm: parameter to encode222 *223 * Return an encoded command verb or -1 for error.224 */225static unsigned int snd_hdac_make_cmd(struct hdac_device *codec, hda_nid_t nid,226 unsigned int verb, unsigned int parm)227{228 u32 val, addr;229 230 addr = codec->addr;231 if ((addr & ~0xf) || (nid & ~0x7f) ||232 (verb & ~0xfff) || (parm & ~0xffff)) {233 dev_err(&codec->dev, "out of range cmd %x:%x:%x:%x\n",234 addr, nid, verb, parm);235 return -1;236 }237 238 val = addr << 28;239 val |= (u32)nid << 20;240 val |= verb << 8;241 val |= parm;242 return val;243}244 245/**246 * snd_hdac_exec_verb - execute an encoded verb247 * @codec: the codec object248 * @cmd: encoded verb to execute249 * @flags: optional flags, pass zero for default250 * @res: the pointer to store the result, NULL if running async251 *252 * Returns zero if successful, or a negative error code.253 *254 * This calls the exec_verb op when set in hdac_codec. If not,255 * call the default snd_hdac_bus_exec_verb().256 */257int snd_hdac_exec_verb(struct hdac_device *codec, unsigned int cmd,258 unsigned int flags, unsigned int *res)259{260 if (codec->exec_verb)261 return codec->exec_verb(codec, cmd, flags, res);262 return snd_hdac_bus_exec_verb(codec->bus, codec->addr, cmd, res);263}264 265 266/**267 * snd_hdac_read - execute a verb268 * @codec: the codec object269 * @nid: NID to execute a verb270 * @verb: verb to execute271 * @parm: parameter for a verb272 * @res: the pointer to store the result, NULL if running async273 *274 * Returns zero if successful, or a negative error code.275 */276int snd_hdac_read(struct hdac_device *codec, hda_nid_t nid,277 unsigned int verb, unsigned int parm, unsigned int *res)278{279 unsigned int cmd = snd_hdac_make_cmd(codec, nid, verb, parm);280 281 return snd_hdac_exec_verb(codec, cmd, 0, res);282}283EXPORT_SYMBOL_GPL(snd_hdac_read);284 285/**286 * _snd_hdac_read_parm - read a parmeter287 * @codec: the codec object288 * @nid: NID to read a parameter289 * @parm: parameter to read290 * @res: pointer to store the read value291 *292 * This function returns zero or an error unlike snd_hdac_read_parm().293 */294int _snd_hdac_read_parm(struct hdac_device *codec, hda_nid_t nid, int parm,295 unsigned int *res)296{297 unsigned int cmd;298 299 cmd = snd_hdac_regmap_encode_verb(nid, AC_VERB_PARAMETERS) | parm;300 return snd_hdac_regmap_read_raw(codec, cmd, res);301}302EXPORT_SYMBOL_GPL(_snd_hdac_read_parm);303 304/**305 * snd_hdac_read_parm_uncached - read a codec parameter without caching306 * @codec: the codec object307 * @nid: NID to read a parameter308 * @parm: parameter to read309 *310 * Returns -1 for error. If you need to distinguish the error more311 * strictly, use snd_hdac_read() directly.312 */313int snd_hdac_read_parm_uncached(struct hdac_device *codec, hda_nid_t nid,314 int parm)315{316 unsigned int cmd, val;317 318 cmd = snd_hdac_regmap_encode_verb(nid, AC_VERB_PARAMETERS) | parm;319 if (snd_hdac_regmap_read_raw_uncached(codec, cmd, &val) < 0)320 return -1;321 return val;322}323EXPORT_SYMBOL_GPL(snd_hdac_read_parm_uncached);324 325/**326 * snd_hdac_override_parm - override read-only parameters327 * @codec: the codec object328 * @nid: NID for the parameter329 * @parm: the parameter to change330 * @val: the parameter value to overwrite331 */332int snd_hdac_override_parm(struct hdac_device *codec, hda_nid_t nid,333 unsigned int parm, unsigned int val)334{335 unsigned int verb = (AC_VERB_PARAMETERS << 8) | (nid << 20) | parm;336 int err;337 338 if (!codec->regmap)339 return -EINVAL;340 341 codec->caps_overwriting = true;342 err = snd_hdac_regmap_write_raw(codec, verb, val);343 codec->caps_overwriting = false;344 return err;345}346EXPORT_SYMBOL_GPL(snd_hdac_override_parm);347 348/**349 * snd_hdac_get_sub_nodes - get start NID and number of subtree nodes350 * @codec: the codec object351 * @nid: NID to inspect352 * @start_id: the pointer to store the starting NID353 *354 * Returns the number of subtree nodes or zero if not found.355 * This function reads parameters always without caching.356 */357int snd_hdac_get_sub_nodes(struct hdac_device *codec, hda_nid_t nid,358 hda_nid_t *start_id)359{360 unsigned int parm;361 362 parm = snd_hdac_read_parm_uncached(codec, nid, AC_PAR_NODE_COUNT);363 if (parm == -1) {364 *start_id = 0;365 return 0;366 }367 *start_id = (parm >> 16) & 0x7fff;368 return (int)(parm & 0x7fff);369}370EXPORT_SYMBOL_GPL(snd_hdac_get_sub_nodes);371 372/*373 * look for an AFG and MFG nodes374 */375static void setup_fg_nodes(struct hdac_device *codec)376{377 int i, total_nodes, function_id;378 hda_nid_t nid;379 380 total_nodes = snd_hdac_get_sub_nodes(codec, AC_NODE_ROOT, &nid);381 for (i = 0; i < total_nodes; i++, nid++) {382 function_id = snd_hdac_read_parm(codec, nid,383 AC_PAR_FUNCTION_TYPE);384 switch (function_id & 0xff) {385 case AC_GRP_AUDIO_FUNCTION:386 codec->afg = nid;387 codec->afg_function_id = function_id & 0xff;388 codec->afg_unsol = (function_id >> 8) & 1;389 break;390 case AC_GRP_MODEM_FUNCTION:391 codec->mfg = nid;392 codec->mfg_function_id = function_id & 0xff;393 codec->mfg_unsol = (function_id >> 8) & 1;394 break;395 default:396 break;397 }398 }399}400 401/**402 * snd_hdac_refresh_widgets - Reset the widget start/end nodes403 * @codec: the codec object404 */405int snd_hdac_refresh_widgets(struct hdac_device *codec)406{407 hda_nid_t start_nid;408 int nums, err = 0;409 410 /*411 * Serialize against multiple threads trying to update the sysfs412 * widgets array.413 */414 mutex_lock(&codec->widget_lock);415 nums = snd_hdac_get_sub_nodes(codec, codec->afg, &start_nid);416 if (!start_nid || nums <= 0 || nums >= 0xff) {417 dev_err(&codec->dev, "cannot read sub nodes for FG 0x%02x\n",418 codec->afg);419 err = -EINVAL;420 goto unlock;421 }422 423 err = hda_widget_sysfs_reinit(codec, start_nid, nums);424 if (err < 0)425 goto unlock;426 427 codec->num_nodes = nums;428 codec->start_nid = start_nid;429 codec->end_nid = start_nid + nums;430unlock:431 mutex_unlock(&codec->widget_lock);432 return err;433}434EXPORT_SYMBOL_GPL(snd_hdac_refresh_widgets);435 436/* return CONNLIST_LEN parameter of the given widget */437static unsigned int get_num_conns(struct hdac_device *codec, hda_nid_t nid)438{439 unsigned int wcaps = get_wcaps(codec, nid);440 unsigned int parm;441 442 if (!(wcaps & AC_WCAP_CONN_LIST) &&443 get_wcaps_type(wcaps) != AC_WID_VOL_KNB)444 return 0;445 446 parm = snd_hdac_read_parm(codec, nid, AC_PAR_CONNLIST_LEN);447 if (parm == -1)448 parm = 0;449 return parm;450}451 452/**453 * snd_hdac_get_connections - get a widget connection list454 * @codec: the codec object455 * @nid: NID456 * @conn_list: the array to store the results, can be NULL457 * @max_conns: the max size of the given array458 *459 * Returns the number of connected widgets, zero for no connection, or a460 * negative error code. When the number of elements don't fit with the461 * given array size, it returns -ENOSPC.462 *463 * When @conn_list is NULL, it just checks the number of connections.464 */465int snd_hdac_get_connections(struct hdac_device *codec, hda_nid_t nid,466 hda_nid_t *conn_list, int max_conns)467{468 unsigned int parm;469 int i, conn_len, conns, err;470 unsigned int shift, num_elems, mask;471 hda_nid_t prev_nid;472 int null_count = 0;473 474 parm = get_num_conns(codec, nid);475 if (!parm)476 return 0;477 478 if (parm & AC_CLIST_LONG) {479 /* long form */480 shift = 16;481 num_elems = 2;482 } else {483 /* short form */484 shift = 8;485 num_elems = 4;486 }487 conn_len = parm & AC_CLIST_LENGTH;488 mask = (1 << (shift-1)) - 1;489 490 if (!conn_len)491 return 0; /* no connection */492 493 if (conn_len == 1) {494 /* single connection */495 err = snd_hdac_read(codec, nid, AC_VERB_GET_CONNECT_LIST, 0,496 &parm);497 if (err < 0)498 return err;499 if (conn_list)500 conn_list[0] = parm & mask;501 return 1;502 }503 504 /* multi connection */505 conns = 0;506 prev_nid = 0;507 for (i = 0; i < conn_len; i++) {508 int range_val;509 hda_nid_t val, n;510 511 if (i % num_elems == 0) {512 err = snd_hdac_read(codec, nid,513 AC_VERB_GET_CONNECT_LIST, i,514 &parm);515 if (err < 0)516 return -EIO;517 }518 range_val = !!(parm & (1 << (shift-1))); /* ranges */519 val = parm & mask;520 if (val == 0 && null_count++) { /* no second chance */521 dev_dbg(&codec->dev,522 "invalid CONNECT_LIST verb %x[%i]:%x\n",523 nid, i, parm);524 return 0;525 }526 parm >>= shift;527 if (range_val) {528 /* ranges between the previous and this one */529 if (!prev_nid || prev_nid >= val) {530 dev_warn(&codec->dev,531 "invalid dep_range_val %x:%x\n",532 prev_nid, val);533 continue;534 }535 for (n = prev_nid + 1; n <= val; n++) {536 if (conn_list) {537 if (conns >= max_conns)538 return -ENOSPC;539 conn_list[conns] = n;540 }541 conns++;542 }543 } else {544 if (conn_list) {545 if (conns >= max_conns)546 return -ENOSPC;547 conn_list[conns] = val;548 }549 conns++;550 }551 prev_nid = val;552 }553 return conns;554}555EXPORT_SYMBOL_GPL(snd_hdac_get_connections);556 557#ifdef CONFIG_PM558/**559 * snd_hdac_power_up - power up the codec560 * @codec: the codec object561 *562 * This function calls the runtime PM helper to power up the given codec.563 * Unlike snd_hdac_power_up_pm(), you should call this only for the code564 * path that isn't included in PM path. Otherwise it gets stuck.565 *566 * Returns zero if successful, or a negative error code.567 */568int snd_hdac_power_up(struct hdac_device *codec)569{570 return pm_runtime_get_sync(&codec->dev);571}572EXPORT_SYMBOL_GPL(snd_hdac_power_up);573 574/**575 * snd_hdac_power_down - power down the codec576 * @codec: the codec object577 *578 * Returns zero if successful, or a negative error code.579 */580int snd_hdac_power_down(struct hdac_device *codec)581{582 struct device *dev = &codec->dev;583 584 pm_runtime_mark_last_busy(dev);585 return pm_runtime_put_autosuspend(dev);586}587EXPORT_SYMBOL_GPL(snd_hdac_power_down);588 589/**590 * snd_hdac_power_up_pm - power up the codec591 * @codec: the codec object592 *593 * This function can be called in a recursive code path like init code594 * which may be called by PM suspend/resume again. OTOH, if a power-up595 * call must wake up the sleeper (e.g. in a kctl callback), use596 * snd_hdac_power_up() instead.597 *598 * Returns zero if successful, or a negative error code.599 */600int snd_hdac_power_up_pm(struct hdac_device *codec)601{602 if (!atomic_inc_not_zero(&codec->in_pm))603 return snd_hdac_power_up(codec);604 return 0;605}606EXPORT_SYMBOL_GPL(snd_hdac_power_up_pm);607 608/* like snd_hdac_power_up_pm(), but only increment the pm count when609 * already powered up. Returns -1 if not powered up, 1 if incremented610 * or 0 if unchanged. Only used in hdac_regmap.c611 */612int snd_hdac_keep_power_up(struct hdac_device *codec)613{614 if (!atomic_inc_not_zero(&codec->in_pm)) {615 int ret = pm_runtime_get_if_active(&codec->dev);616 if (!ret)617 return -1;618 if (ret < 0)619 return 0;620 }621 return 1;622}623 624/**625 * snd_hdac_power_down_pm - power down the codec626 * @codec: the codec object627 *628 * Like snd_hdac_power_up_pm(), this function is used in a recursive629 * code path like init code which may be called by PM suspend/resume again.630 *631 * Returns zero if successful, or a negative error code.632 */633int snd_hdac_power_down_pm(struct hdac_device *codec)634{635 if (atomic_dec_if_positive(&codec->in_pm) < 0)636 return snd_hdac_power_down(codec);637 return 0;638}639EXPORT_SYMBOL_GPL(snd_hdac_power_down_pm);640#endif641 642/* codec vendor labels */643struct hda_vendor_id {644 unsigned int id;645 const char *name;646};647 648static const struct hda_vendor_id hda_vendor_ids[] = {649 { 0x0014, "Loongson" },650 { 0x1002, "ATI" },651 { 0x1013, "Cirrus Logic" },652 { 0x1057, "Motorola" },653 { 0x1095, "Silicon Image" },654 { 0x10de, "Nvidia" },655 { 0x10ec, "Realtek" },656 { 0x1102, "Creative" },657 { 0x1106, "VIA" },658 { 0x111d, "IDT" },659 { 0x11c1, "LSI" },660 { 0x11d4, "Analog Devices" },661 { 0x13f6, "C-Media" },662 { 0x14f1, "Conexant" },663 { 0x17e8, "Chrontel" },664 { 0x1854, "LG" },665 { 0x19e5, "Huawei" },666 { 0x1aec, "Wolfson Microelectronics" },667 { 0x1af4, "QEMU" },668 { 0x1fa8, "Senarytech" },669 { 0x434d, "C-Media" },670 { 0x8086, "Intel" },671 { 0x8384, "SigmaTel" },672 {} /* terminator */673};674 675/* store the codec vendor name */676static int get_codec_vendor_name(struct hdac_device *codec)677{678 const struct hda_vendor_id *c;679 u16 vendor_id = codec->vendor_id >> 16;680 681 for (c = hda_vendor_ids; c->id; c++) {682 if (c->id == vendor_id) {683 codec->vendor_name = kstrdup(c->name, GFP_KERNEL);684 return codec->vendor_name ? 0 : -ENOMEM;685 }686 }687 688 codec->vendor_name = kasprintf(GFP_KERNEL, "Generic %04x", vendor_id);689 return codec->vendor_name ? 0 : -ENOMEM;690}691 692/*693 * stream formats694 */695struct hda_rate_tbl {696 unsigned int hz;697 unsigned int alsa_bits;698 unsigned int hda_fmt;699};700 701/* rate = base * mult / div */702#define HDA_RATE(base, mult, div) \703 (AC_FMT_BASE_##base##K | (((mult) - 1) << AC_FMT_MULT_SHIFT) | \704 (((div) - 1) << AC_FMT_DIV_SHIFT))705 706static const struct hda_rate_tbl rate_bits[] = {707 /* rate in Hz, ALSA rate bitmask, HDA format value */708 709 /* autodetected value used in snd_hda_query_supported_pcm */710 { 8000, SNDRV_PCM_RATE_8000, HDA_RATE(48, 1, 6) },711 { 11025, SNDRV_PCM_RATE_11025, HDA_RATE(44, 1, 4) },712 { 16000, SNDRV_PCM_RATE_16000, HDA_RATE(48, 1, 3) },713 { 22050, SNDRV_PCM_RATE_22050, HDA_RATE(44, 1, 2) },714 { 32000, SNDRV_PCM_RATE_32000, HDA_RATE(48, 2, 3) },715 { 44100, SNDRV_PCM_RATE_44100, HDA_RATE(44, 1, 1) },716 { 48000, SNDRV_PCM_RATE_48000, HDA_RATE(48, 1, 1) },717 { 88200, SNDRV_PCM_RATE_88200, HDA_RATE(44, 2, 1) },718 { 96000, SNDRV_PCM_RATE_96000, HDA_RATE(48, 2, 1) },719 { 176400, SNDRV_PCM_RATE_176400, HDA_RATE(44, 4, 1) },720 { 192000, SNDRV_PCM_RATE_192000, HDA_RATE(48, 4, 1) },721#define AC_PAR_PCM_RATE_BITS 11722 /* up to bits 10, 384kHZ isn't supported properly */723 724 /* not autodetected value */725 { 9600, SNDRV_PCM_RATE_KNOT, HDA_RATE(48, 1, 5) },726 727 { 0 } /* terminator */728};729 730static snd_pcm_format_t snd_hdac_format_normalize(snd_pcm_format_t format)731{732 switch (format) {733 case SNDRV_PCM_FORMAT_S20_LE:734 case SNDRV_PCM_FORMAT_S24_LE:735 return SNDRV_PCM_FORMAT_S32_LE;736 737 case SNDRV_PCM_FORMAT_U20_LE:738 case SNDRV_PCM_FORMAT_U24_LE:739 return SNDRV_PCM_FORMAT_U32_LE;740 741 case SNDRV_PCM_FORMAT_S20_BE:742 case SNDRV_PCM_FORMAT_S24_BE:743 return SNDRV_PCM_FORMAT_S32_BE;744 745 case SNDRV_PCM_FORMAT_U20_BE:746 case SNDRV_PCM_FORMAT_U24_BE:747 return SNDRV_PCM_FORMAT_U32_BE;748 749 default:750 return format;751 }752}753 754/**755 * snd_hdac_stream_format_bits - obtain bits per sample value.756 * @format: the PCM format.757 * @subformat: the PCM subformat.758 * @maxbits: the maximum bits per sample.759 *760 * Return: The number of bits per sample.761 */762unsigned int snd_hdac_stream_format_bits(snd_pcm_format_t format, snd_pcm_subformat_t subformat,763 unsigned int maxbits)764{765 struct snd_pcm_hw_params params;766 unsigned int bits;767 768 memset(¶ms, 0, sizeof(params));769 770 params_set_format(¶ms, snd_hdac_format_normalize(format));771 snd_mask_set(hw_param_mask(¶ms, SNDRV_PCM_HW_PARAM_SUBFORMAT),772 (__force unsigned int)subformat);773 774 bits = snd_pcm_hw_params_bits(¶ms);775 if (maxbits)776 return min(bits, maxbits);777 return bits;778}779EXPORT_SYMBOL_GPL(snd_hdac_stream_format_bits);780 781/**782 * snd_hdac_stream_format - convert format parameters to SDxFMT value.783 * @channels: the number of channels.784 * @bits: bits per sample.785 * @rate: the sample rate.786 *787 * Return: The format bitset or zero if invalid.788 */789unsigned int snd_hdac_stream_format(unsigned int channels, unsigned int bits, unsigned int rate)790{791 unsigned int val = 0;792 int i;793 794 for (i = 0; rate_bits[i].hz; i++) {795 if (rate_bits[i].hz == rate) {796 val = rate_bits[i].hda_fmt;797 break;798 }799 }800 801 if (!rate_bits[i].hz)802 return 0;803 804 if (channels == 0 || channels > 8)805 return 0;806 val |= channels - 1;807 808 switch (bits) {809 case 8:810 val |= AC_FMT_BITS_8;811 break;812 case 16:813 val |= AC_FMT_BITS_16;814 break;815 case 20:816 val |= AC_FMT_BITS_20;817 break;818 case 24:819 val |= AC_FMT_BITS_24;820 break;821 case 32:822 val |= AC_FMT_BITS_32;823 break;824 default:825 return 0;826 }827 828 return val;829}830EXPORT_SYMBOL_GPL(snd_hdac_stream_format);831 832/**833 * snd_hdac_spdif_stream_format - convert format parameters to SDxFMT value.834 * @channels: the number of channels.835 * @bits: bits per sample.836 * @rate: the sample rate.837 * @spdif_ctls: HD-audio SPDIF status bits (0 if irrelevant).838 *839 * Return: The format bitset or zero if invalid.840 */841unsigned int snd_hdac_spdif_stream_format(unsigned int channels, unsigned int bits,842 unsigned int rate, unsigned short spdif_ctls)843{844 unsigned int val = snd_hdac_stream_format(channels, bits, rate);845 846 if (val && spdif_ctls & AC_DIG1_NONAUDIO)847 val |= AC_FMT_TYPE_NON_PCM;848 849 return val;850}851EXPORT_SYMBOL_GPL(snd_hdac_spdif_stream_format);852 853static unsigned int query_pcm_param(struct hdac_device *codec, hda_nid_t nid)854{855 unsigned int val = 0;856 857 if (nid != codec->afg &&858 (get_wcaps(codec, nid) & AC_WCAP_FORMAT_OVRD))859 val = snd_hdac_read_parm(codec, nid, AC_PAR_PCM);860 if (!val || val == -1)861 val = snd_hdac_read_parm(codec, codec->afg, AC_PAR_PCM);862 if (!val || val == -1)863 return 0;864 return val;865}866 867static unsigned int query_stream_param(struct hdac_device *codec, hda_nid_t nid)868{869 unsigned int streams = snd_hdac_read_parm(codec, nid, AC_PAR_STREAM);870 871 if (!streams || streams == -1)872 streams = snd_hdac_read_parm(codec, codec->afg, AC_PAR_STREAM);873 if (!streams || streams == -1)874 return 0;875 return streams;876}877 878/**879 * snd_hdac_query_supported_pcm - query the supported PCM rates and formats880 * @codec: the codec object881 * @nid: NID to query882 * @ratesp: the pointer to store the detected rate bitflags883 * @formatsp: the pointer to store the detected formats884 * @subformatsp: the pointer to store the detected subformats for S32_LE format885 * @bpsp: the pointer to store the detected format widths886 *887 * Queries the supported PCM rates and formats. The NULL @ratesp, @formatsp,888 * @subformatsp or @bpsp argument is ignored.889 *890 * Returns 0 if successful, otherwise a negative error code.891 */892int snd_hdac_query_supported_pcm(struct hdac_device *codec, hda_nid_t nid,893 u32 *ratesp, u64 *formatsp, u32 *subformatsp,894 unsigned int *bpsp)895{896 unsigned int i, val, wcaps;897 898 wcaps = get_wcaps(codec, nid);899 val = query_pcm_param(codec, nid);900 901 if (ratesp) {902 u32 rates = 0;903 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++) {904 if (val & (1 << i))905 rates |= rate_bits[i].alsa_bits;906 }907 if (rates == 0) {908 dev_err(&codec->dev,909 "rates == 0 (nid=0x%x, val=0x%x, ovrd=%i)\n",910 nid, val,911 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0);912 return -EIO;913 }914 *ratesp = rates;915 }916 917 if (formatsp || subformatsp || bpsp) {918 unsigned int streams, bps;919 u32 subformats = 0;920 u64 formats = 0;921 922 streams = query_stream_param(codec, nid);923 if (!streams)924 return -EIO;925 926 bps = 0;927 if (streams & AC_SUPFMT_PCM) {928 if (val & AC_SUPPCM_BITS_8) {929 formats |= SNDRV_PCM_FMTBIT_U8;930 bps = 8;931 }932 if (val & AC_SUPPCM_BITS_16) {933 formats |= SNDRV_PCM_FMTBIT_S16_LE;934 bps = 16;935 }936 if (val & AC_SUPPCM_BITS_20) {937 formats |= SNDRV_PCM_FMTBIT_S32_LE;938 subformats |= SNDRV_PCM_SUBFMTBIT_MSBITS_20;939 bps = 20;940 }941 if (val & AC_SUPPCM_BITS_24) {942 formats |= SNDRV_PCM_FMTBIT_S32_LE;943 subformats |= SNDRV_PCM_SUBFMTBIT_MSBITS_24;944 bps = 24;945 }946 if (val & AC_SUPPCM_BITS_32) {947 if (wcaps & AC_WCAP_DIGITAL) {948 formats |= SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;949 } else {950 formats |= SNDRV_PCM_FMTBIT_S32_LE;951 subformats |= SNDRV_PCM_SUBFMTBIT_MSBITS_MAX;952 bps = 32;953 }954 }955 }956#if 0 /* FIXME: CS4206 doesn't work, which is the only codec supporting float */957 if (streams & AC_SUPFMT_FLOAT32) {958 formats |= SNDRV_PCM_FMTBIT_FLOAT_LE;959 if (!bps)960 bps = 32;961 }962#endif963 if (streams == AC_SUPFMT_AC3) {964 /* should be exclusive */965 /* temporary hack: we have still no proper support966 * for the direct AC3 stream...967 */968 formats |= SNDRV_PCM_FMTBIT_U8;969 bps = 8;970 }971 if (formats == 0) {972 dev_err(&codec->dev,973 "formats == 0 (nid=0x%x, val=0x%x, ovrd=%i, streams=0x%x)\n",974 nid, val,975 (wcaps & AC_WCAP_FORMAT_OVRD) ? 1 : 0,976 streams);977 return -EIO;978 }979 if (formatsp)980 *formatsp = formats;981 if (subformatsp)982 *subformatsp = subformats;983 if (bpsp)984 *bpsp = bps;985 }986 987 return 0;988}989EXPORT_SYMBOL_GPL(snd_hdac_query_supported_pcm);990 991/**992 * snd_hdac_is_supported_format - Check the validity of the format993 * @codec: the codec object994 * @nid: NID to check995 * @format: the HD-audio format value to check996 *997 * Check whether the given node supports the format value.998 *999 * Returns true if supported, false if not.1000 */1001bool snd_hdac_is_supported_format(struct hdac_device *codec, hda_nid_t nid,1002 unsigned int format)1003{1004 int i;1005 unsigned int val = 0, rate, stream;1006 1007 val = query_pcm_param(codec, nid);1008 if (!val)1009 return false;1010 1011 rate = format & 0xff00;1012 for (i = 0; i < AC_PAR_PCM_RATE_BITS; i++)1013 if (rate_bits[i].hda_fmt == rate) {1014 if (val & (1 << i))1015 break;1016 return false;1017 }1018 if (i >= AC_PAR_PCM_RATE_BITS)1019 return false;1020 1021 stream = query_stream_param(codec, nid);1022 if (!stream)1023 return false;1024 1025 if (stream & AC_SUPFMT_PCM) {1026 switch (format & 0xf0) {1027 case 0x00:1028 if (!(val & AC_SUPPCM_BITS_8))1029 return false;1030 break;1031 case 0x10:1032 if (!(val & AC_SUPPCM_BITS_16))1033 return false;1034 break;1035 case 0x20:1036 if (!(val & AC_SUPPCM_BITS_20))1037 return false;1038 break;1039 case 0x30:1040 if (!(val & AC_SUPPCM_BITS_24))1041 return false;1042 break;1043 case 0x40:1044 if (!(val & AC_SUPPCM_BITS_32))1045 return false;1046 break;1047 default:1048 return false;1049 }1050 } else {1051 /* FIXME: check for float32 and AC3? */1052 }1053 1054 return true;1055}1056EXPORT_SYMBOL_GPL(snd_hdac_is_supported_format);1057 1058static unsigned int codec_read(struct hdac_device *hdac, hda_nid_t nid,1059 int flags, unsigned int verb, unsigned int parm)1060{1061 unsigned int cmd = snd_hdac_make_cmd(hdac, nid, verb, parm);1062 unsigned int res;1063 1064 if (snd_hdac_exec_verb(hdac, cmd, flags, &res))1065 return -1;1066 1067 return res;1068}1069 1070static int codec_write(struct hdac_device *hdac, hda_nid_t nid,1071 int flags, unsigned int verb, unsigned int parm)1072{1073 unsigned int cmd = snd_hdac_make_cmd(hdac, nid, verb, parm);1074 1075 return snd_hdac_exec_verb(hdac, cmd, flags, NULL);1076}1077 1078/**1079 * snd_hdac_codec_read - send a command and get the response1080 * @hdac: the HDAC device1081 * @nid: NID to send the command1082 * @flags: optional bit flags1083 * @verb: the verb to send1084 * @parm: the parameter for the verb1085 *1086 * Send a single command and read the corresponding response.1087 *1088 * Returns the obtained response value, or -1 for an error.1089 */1090int snd_hdac_codec_read(struct hdac_device *hdac, hda_nid_t nid,1091 int flags, unsigned int verb, unsigned int parm)1092{1093 return codec_read(hdac, nid, flags, verb, parm);1094}1095EXPORT_SYMBOL_GPL(snd_hdac_codec_read);1096 1097/**1098 * snd_hdac_codec_write - send a single command without waiting for response1099 * @hdac: the HDAC device1100 * @nid: NID to send the command1101 * @flags: optional bit flags1102 * @verb: the verb to send1103 * @parm: the parameter for the verb1104 *1105 * Send a single command without waiting for response.1106 *1107 * Returns 0 if successful, or a negative error code.1108 */1109int snd_hdac_codec_write(struct hdac_device *hdac, hda_nid_t nid,1110 int flags, unsigned int verb, unsigned int parm)1111{1112 return codec_write(hdac, nid, flags, verb, parm);1113}1114EXPORT_SYMBOL_GPL(snd_hdac_codec_write);1115 1116/**1117 * snd_hdac_check_power_state - check whether the actual power state matches1118 * with the target state1119 *1120 * @hdac: the HDAC device1121 * @nid: NID to send the command1122 * @target_state: target state to check for1123 *1124 * Return true if state matches, false if not1125 */1126bool snd_hdac_check_power_state(struct hdac_device *hdac,1127 hda_nid_t nid, unsigned int target_state)1128{1129 unsigned int state = codec_read(hdac, nid, 0,1130 AC_VERB_GET_POWER_STATE, 0);1131 1132 if (state & AC_PWRST_ERROR)1133 return true;1134 state = (state >> 4) & 0x0f;1135 return (state == target_state);1136}1137EXPORT_SYMBOL_GPL(snd_hdac_check_power_state);1138/**1139 * snd_hdac_sync_power_state - wait until actual power state matches1140 * with the target state1141 *1142 * @codec: the HDAC device1143 * @nid: NID to send the command1144 * @power_state: target power state to wait for1145 *1146 * Return power state or PS_ERROR if codec rejects GET verb.1147 */1148unsigned int snd_hdac_sync_power_state(struct hdac_device *codec,1149 hda_nid_t nid, unsigned int power_state)1150{1151 unsigned long end_time = jiffies + msecs_to_jiffies(500);1152 unsigned int state, actual_state, count;1153 1154 for (count = 0; count < 500; count++) {1155 state = snd_hdac_codec_read(codec, nid, 0,1156 AC_VERB_GET_POWER_STATE, 0);1157 if (state & AC_PWRST_ERROR) {1158 msleep(20);1159 break;1160 }1161 actual_state = (state >> 4) & 0x0f;1162 if (actual_state == power_state)1163 break;1164 if (time_after_eq(jiffies, end_time))1165 break;1166 /* wait until the codec reachs to the target state */1167 msleep(1);1168 }1169 return state;1170}1171EXPORT_SYMBOL_GPL(snd_hdac_sync_power_state);1172