soundwire.c

Go to the documentation of this file.

/* SPDX-License-Identifier: GPL-2.0-only */
 
#include <acpi/acpigen.h>
#include <acpi/acpi_device.h>
#include <acpi/acpi_soundwire.h>
#include <commonlib/helpers.h>
#include <device/soundwire.h>
#include <stddef.h>
 
/* Specification-defined prefix for SoundWire properties. */
#define SDW_PFX "mipi-sdw-"
 
/* Generate SoundWire property for integer. */
#define SDW_INT(__key, __val) \
        acpi_dp_add_integer(dsd, SDW_PFX __key, __val)
 
/* Generate SoundWire property for integer array. */
#define SDW_INT_ARRAY(__key, __val) \
        acpi_dp_add_integer_array(dsd, SDW_PFX __key, __val, __val##_count)
 
/**
 * struct soundwire_name_map - Map ACPI name to SoundWire property name.
 * @acpi_name: ACPI compatible name string.
 * @sdw_name: MIPI SoundWire property name string.
 */
struct soundwire_name_map {
        const char *acpi_name;
        const char *sdw_name;
};
 
static const struct soundwire_name_map bra_mode_names[] = {
        { "BRA0", SDW_PFX "port-bra-mode-0" },
        { "BRA1", SDW_PFX "port-bra-mode-1" },
        { "BRA2", SDW_PFX "port-bra-mode-2" },
        { "BRA3", SDW_PFX "port-bra-mode-3" },
};
 
static const struct soundwire_name_map audio_mode_names[] = {
        { "MOD0", SDW_PFX "port-audio-mode-0" },
        { "MOD1", SDW_PFX "port-audio-mode-1" },
        { "MOD2", SDW_PFX "port-audio-mode-2" },
        { "MOD3", SDW_PFX "port-audio-mode-3" },
};
 
static const struct soundwire_name_map dpn_source_names[] = {
        { "DP0",  SDW_PFX "dp-0-subproperties" },
        { "SRC1", SDW_PFX "dp-1-source-subproperties" },
        { "SRC2", SDW_PFX "dp-2-source-subproperties" },
        { "SRC3", SDW_PFX "dp-3-source-subproperties" },
        { "SRC4", SDW_PFX "dp-4-source-subproperties" },
        { "SRC5", SDW_PFX "dp-5-source-subproperties" },
        { "SRC6", SDW_PFX "dp-6-source-subproperties" },
        { "SRC7", SDW_PFX "dp-7-source-subproperties" },
        { "SRC8", SDW_PFX "dp-8-source-subproperties" },
        { "SRC9", SDW_PFX "dp-9-source-subproperties" },
        { "SRCA", SDW_PFX "dp-10-source-subproperties" },
        { "SRCB", SDW_PFX "dp-11-source-subproperties" },
        { "SRCC", SDW_PFX "dp-12-source-subproperties" },
        { "SRCD", SDW_PFX "dp-13-source-subproperties" }
};
 
static const struct soundwire_name_map dpn_sink_names[] = {
        { "DP0",  SDW_PFX "dp-0-subproperties" },
        { "SNK1", SDW_PFX "dp-1-sink-subproperties" },
        { "SNK2", SDW_PFX "dp-2-sink-subproperties" },
        { "SNK3", SDW_PFX "dp-3-sink-subproperties" },
        { "SNK4", SDW_PFX "dp-4-sink-subproperties" },
        { "SNK5", SDW_PFX "dp-5-sink-subproperties" },
        { "SNK6", SDW_PFX "dp-6-sink-subproperties" },
        { "SNK7", SDW_PFX "dp-7-sink-subproperties" },
        { "SNK8", SDW_PFX "dp-8-sink-subproperties" },
        { "SNK9", SDW_PFX "dp-9-sink-subproperties" },
        { "SNKA", SDW_PFX "dp-10-sink-subproperties" },
        { "SNKB", SDW_PFX "dp-11-sink-subproperties" },
        { "SNKC", SDW_PFX "dp-12-sink-subproperties" },
        { "SNKD", SDW_PFX "dp-13-sink-subproperties" }
};
 
static const struct soundwire_name_map link_names[] = {
        { "LNK0", SDW_PFX "link-0-subproperties" },
        { "LNK1", SDW_PFX "link-1-subproperties" },
        { "LNK2", SDW_PFX "link-2-subproperties" },
        { "LNK3", SDW_PFX "link-3-subproperties" },
        { "LNK4", SDW_PFX "link-4-subproperties" },
        { "LNK5", SDW_PFX "link-5-subproperties" },
        { "LNK6", SDW_PFX "link-6-subproperties" },
        { "LNK7", SDW_PFX "link-7-subproperties" }
};
 
static const char * const multilane_names[] = {
        SDW_PFX "lane-1-mapping",
        SDW_PFX "lane-2-mapping",
        SDW_PFX "lane-3-mapping",
        SDW_PFX "lane-4-mapping",
        SDW_PFX "lane-5-mapping",
        SDW_PFX "lane-6-mapping",
        SDW_PFX "lane-7-mapping",
        SDW_PFX "lane-8-mapping"
};
 
static const char * const multilane_master_lane_names[] = {
        SDW_PFX "master-lane-1",
        SDW_PFX "master-lane-2",
        SDW_PFX "master-lane-3",
        SDW_PFX "master-lane-4",
        SDW_PFX "master-lane-5",
        SDW_PFX "master-lane-6",
        SDW_PFX "master-lane-7",
        SDW_PFX "master-lane-8"
};
 
static const char * const multilane_slave_link_names[] = {
        SDW_PFX "slave-link-A",
        SDW_PFX "slave-link-B",
        SDW_PFX "slave-link-C",
        SDW_PFX "slave-link-D",
        SDW_PFX "slave-link-E",
        SDW_PFX "slave-link-F",
        SDW_PFX "slave-link-G",
        SDW_PFX "slave-link-I"
};
 
static const char * const multilane_bus_holder_names[] = {
        SDW_PFX "lane-1-bus-holder",
        SDW_PFX "lane-2-bus-holder",
        SDW_PFX "lane-3-bus-holder",
        SDW_PFX "lane-4-bus-holder",
        SDW_PFX "lane-5-bus-holder",
        SDW_PFX "lane-6-bus-holder",
        SDW_PFX "lane-7-bus-holder",
        SDW_PFX "lane-8-bus-holder"
};
 
static void soundwire_gen_interface_revision(struct acpi_dp *dsd)
{
        acpi_dp_add_integer(dsd, SDW_PFX "sw-interface-revision", SOUNDWIRE_SW_VERSION_1_0);
}
 
static void soundwire_gen_slave(struct acpi_dp *dsd, const struct soundwire_slave *prop)
{
        soundwire_gen_interface_revision(dsd);
        SDW_INT("wake-up-unavailable", prop->wake_up_unavailable);
        SDW_INT("test-mode-supported", prop->test_mode_supported);
        SDW_INT("clock-stop-mode1-supported", prop->clock_stop_mode1_supported);
 
        /* Clock Stop Prepare Timeout only used without simplified Clock Stop Prepare. */
        SDW_INT("simplified-clockstopprepare-sm-supported",
                prop->simplified_clockstopprepare_sm_supported);
        if (!prop->simplified_clockstopprepare_sm_supported)
                SDW_INT("clockstopprepare-timeout", prop->clockstopprepare_timeout);
 
        SDW_INT("clockstopprepare-hard-reset-behavior",
                prop->clockstopprepare_hard_reset_behavior);
        SDW_INT("slave-channelprepare-timeout", prop->slave_channelprepare_timeout);
        SDW_INT("highPHY-capable", prop->highPHY_capable);
        SDW_INT("paging-supported", prop->paging_supported);
        SDW_INT("bank-delay-supported", prop->bank_delay_supported);
        SDW_INT("port15-read-behavior", prop->port15_read_behavior);
        SDW_INT("master-count", prop->master_count);
        SDW_INT("source-port-list", prop->source_port_list);
        SDW_INT("sink-port-list", prop->sink_port_list);
}
 
static void soundwire_gen_multilane(struct acpi_dp *dsd, const struct soundwire_multilane *prop)
{
        size_t i;
 
        soundwire_gen_interface_revision(dsd);
 
        /* Fill out multilane map based on master/slave links. */
        for (i = 0; i < prop->lane_mapping_count && i < SOUNDWIRE_MAX_LANE; i++) {
                const struct soundwire_multilane_map *map = &prop->lane_mapping[i];
                const char *name;
 
                /* Get the name of this connection */
                if (map->direction == MASTER_LANE)
                        name = multilane_master_lane_names[map->connection.master_lane];
                else
                        name = multilane_slave_link_names[map->connection.slave_link];
 
                acpi_dp_add_string(dsd, multilane_names[map->lane], name);
        }
 
        /* Add bus holder properties. */
        for (i = 0; i < prop->lane_bus_holder_count; i++)
                acpi_dp_add_integer(dsd, multilane_bus_holder_names[i],
                                    prop->lane_bus_holder[i]);
}
 
static void soundwire_gen_link(struct acpi_dp *dsd, const struct soundwire_link *prop)
{
        SDW_INT("clock-stop-mode0-supported", prop->clock_stop_mode0_supported);
        SDW_INT("clock-stop-mode1-supported", prop->clock_stop_mode1_supported);
        if (prop->clock_frequencies_supported_count > 0 &&
            prop->clock_frequencies_supported_count < SOUNDWIRE_MAX) {
                SDW_INT_ARRAY("clock-frequencies-supported",
                              prop->clock_frequencies_supported);
        }
        SDW_INT("default-frame-rate", prop->default_frame_rate);
        SDW_INT("default-frame-row-size", prop->default_frame_row_size);
        SDW_INT("default-frame-col-size", prop->default_frame_col_size);
        SDW_INT("dynamic-frame-shape", prop->dynamic_frame_shape);
        SDW_INT("command-error-threshold", prop->command_error_threshold);
}
 
static void soundwire_gen_bra_mode(struct acpi_dp *dsd, const struct soundwire_bra_mode *prop)
{
        /* Bus frequency configs used if min/max not supported. */
        if (prop->bus_frequency_configs_count > 0 &&
            prop->bus_frequency_configs_count < SOUNDWIRE_MAX) {
                SDW_INT_ARRAY("bra-mode-bus-frequency-configs", prop->bus_frequency_configs);
        } else {
                SDW_INT("bra-mode-min-bus-frequency", prop->min_bus_frequency);
                SDW_INT("bra-mode-max-bus-frequency", prop->max_bus_frequency);
        }
        SDW_INT("bra-mode-max-data-per-frame", prop->max_data_per_frame);
        SDW_INT("bra-mode-min-us-between-transactions", prop->min_us_between_transactions);
}
 
static void soundwire_gen_audio_mode(struct acpi_dp *dsd,
                                     const struct soundwire_audio_mode *prop)
{
        /* Bus frequency configs used if min/max not supported. */
        if (prop->bus_frequency_configs_count > 0 &&
            prop->bus_frequency_configs_count < SOUNDWIRE_MAX) {
                SDW_INT_ARRAY("audio-mode-bus-frequency-configs", prop->bus_frequency_configs);
        } else {
                SDW_INT("audio-mode-min-bus-frequency", prop->min_bus_frequency);
                SDW_INT("audio-mode-max-bus-frequency", prop->max_bus_frequency);
        }
 
        /* Sampling frequency configs used if min/max not supported. */
        if (prop->sampling_frequency_configs_count > 0 &&
            prop->sampling_frequency_configs_count < SOUNDWIRE_MAX) {
                SDW_INT_ARRAY("audio-mode-sampling-frequency-configs",
                              prop->sampling_frequency_configs);
        } else {
                SDW_INT("audio-mode-max-sampling-frequency", prop->max_sampling_frequency);
                SDW_INT("audio-mode-min-sampling-frequency", prop->min_sampling_frequency);
        }
 
        SDW_INT("audio-mode-prepare-channel-behavior", prop->prepare_channel_behavior);
        SDW_INT("audio-mode-glitchless-transitions", prop->glitchless_transitions);
}
 
static void soundwire_gen_dp0(struct acpi_dp *dsd, const struct soundwire_dp0 *prop)
{
        size_t i;
 
        /* Max wordlength configs used if min/max not supported. */
        if (prop->port_wordlength_configs_count > 0 &&
            prop->port_wordlength_configs_count < SOUNDWIRE_MAX) {
                SDW_INT_ARRAY("port-wordlength-configs", prop->port_wordlength_configs);
        } else {
                SDW_INT("port-max-wordlength", prop->port_max_wordlength);
                SDW_INT("port-min-wordlength", prop->port_min_wordlength);
        }
        SDW_INT("bra-flow-controlled", prop->bra_flow_controlled);
        SDW_INT("bra-imp-def-response-supported", prop->bra_imp_def_response_supported);
        SDW_INT("bra-role-supported", prop->bra_role_supported);
        SDW_INT("simplified-channel-prepare-sm", prop->simplified_channel_prepare_sm);
        SDW_INT("imp-def-dp0-interrupts-supported", prop->imp_def_dp0_interrupts_supported);
        SDW_INT("imp-def-bpt-supported", prop->imp_def_bpt_supported);
 
        /* Add bulk register access mode property pointers. */
        for (i = 0; i < prop->bra_mode_count && i < SOUNDWIRE_MAX_MODE; i++) {
                struct acpi_dp *bra = acpi_dp_new_table(bra_mode_names[i].acpi_name);
                acpi_dp_add_child(dsd, bra_mode_names[i].sdw_name, bra);
        }
}
 
static void soundwire_gen_dpn(struct acpi_dp *dsd, const struct soundwire_dpn *prop)
{
        size_t i;
 
        SDW_INT("data-port-type", prop->data_port_type);
        SDW_INT("max-grouping-supported", prop->max_grouping_supported);
        SDW_INT("imp-def-dpn-interrupts-supported", prop->imp_def_dpn_interrupts_supported);
        SDW_INT("modes-supported", prop->modes_supported);
        SDW_INT("max-async-buffer", prop->max_async_buffer);
        SDW_INT("block-packing-mode", prop->block_packing_mode);
        SDW_INT("port-encoding-type", prop->port_encoding_type);
 
        /* Max wordlength configs used if min/max not supported. */
        if (prop->port_wordlength_configs_count > 0 &&
            prop->port_wordlength_configs_count < SOUNDWIRE_MAX) {
                SDW_INT_ARRAY("port-wordlength-configs", prop->port_wordlength_configs);
        } else {
                SDW_INT("port-max-wordlength", prop->port_max_wordlength);
                SDW_INT("port-min-wordlength", prop->port_min_wordlength);
        }
 
        /* Channel Prepare Timeout only used without simplified Channel Prepare. */
        SDW_INT("simplified-channelprepare-sm", prop->simplified_channelprepare_sm);
        if (!prop->simplified_channelprepare_sm)
                SDW_INT("port-channelprepare-timeout", prop->port_channelprepare_timeout);
 
        /* Channel number list used if min/max not supported. */
        if (prop->channel_number_list_count > 0 &&
            prop->channel_number_list_count < SOUNDWIRE_MAX) {
                SDW_INT_ARRAY("channel-number-list", prop->channel_number_list);
        } else {
                SDW_INT("min-channel-number", prop->min_channel_number);
                SDW_INT("max-channel-number", prop->max_channel_number);
        }
        if (prop->channel_combination_list_count > 0 &&
            prop->channel_combination_list_count < SOUNDWIRE_MAX) {
                SDW_INT_ARRAY("channel-combination-list", prop->channel_combination_list);
        }
 
        /* Add reference to Audio Mode properties. */
        for (i = 0; i < prop->port_audio_mode_count && i < SOUNDWIRE_MAX_MODE; i++) {
                struct acpi_dp *am = acpi_dp_new_table(audio_mode_names[i].acpi_name);
                acpi_dp_add_child(dsd, audio_mode_names[i].sdw_name, am);
        }
}
 
void soundwire_gen_controller(struct acpi_dp *dsd, const struct soundwire_controller *prop,
                              soundwire_link_prop_cb link_prop_cb)
{
        size_t i;
 
        soundwire_gen_interface_revision(dsd);
        SDW_INT("master-count", prop->master_list_count);
 
        /* Generate properties for each master link on the controller. */
        for (i = 0; i < prop->master_list_count && i < SOUNDWIRE_MAX_LINK; i++) {
                struct acpi_dp *link = acpi_dp_new_table(link_names[i].acpi_name);
                soundwire_gen_link(link, &prop->master_list[i]);
 
                /* Callback for custom link properties from the controller. */
                if (link_prop_cb)
                        link_prop_cb(link, i, prop);
                acpi_dp_add_child(dsd, link_names[i].sdw_name, link);
        }
}
 
void soundwire_gen_codec(struct acpi_dp *dsd, const struct soundwire_codec *codec,
                         soundwire_dp_prop_cb dp_prop_cb)
{
        const struct soundwire_dpn_entry *entry;
        const struct soundwire_name_map *name;
        size_t i;
 
        /* Generate slave properties for this codec. */
        soundwire_gen_slave(dsd, codec->slave);
 
        /* Generate properties for multilane config, if provided. */
        if (codec->multilane)
                soundwire_gen_multilane(dsd, codec->multilane);
 
        /* Generate properties for data port 0, if provided. */
        if (codec->dp0) {
                struct acpi_dp *dp0;
 
                /* First generate any Bulk Register Access mode properties. */
                for (i = 0; i < SOUNDWIRE_MAX_MODE; i++) {
                        const struct soundwire_bra_mode *prop = codec->dp0_bra_mode[i];
                        struct acpi_dp *bra;
 
                        /* Stop processing at the first undefined BRA mode. */
                        if (!prop)
                                break;
                        name = &bra_mode_names[i];
                        bra = acpi_dp_new_table(name->acpi_name);
                        soundwire_gen_bra_mode(bra, prop);
                        acpi_dp_add_child(dsd, name->sdw_name, bra);
                }
 
                name = &dpn_source_names[0];
                dp0 = acpi_dp_new_table(name->acpi_name);
                soundwire_gen_dp0(dp0, codec->dp0);
 
                /* Callback for custom properties from the codec. */
                if (dp_prop_cb)
                        dp_prop_cb(dp0, 0, codec);
                acpi_dp_add_child(dsd, name->sdw_name, dp0);
        }
 
        /*
         * First generate audio modes for the data ports.  This results in unnecessary
         * (but harmless) references to the audio modes at the codec level, but it allows
         * the data ports to use these objects without duplication.
         */
        for (i = 0; i < SOUNDWIRE_MAX_MODE; i++) {
                const struct soundwire_audio_mode *prop = codec->audio_mode[i];
                struct acpi_dp *am;
 
                /* Stop processing at the first undefined audio mode. */
                if (!prop)
                        break;
                name = &audio_mode_names[i];
                am = acpi_dp_new_table(name->acpi_name);
                soundwire_gen_audio_mode(am, prop);
                acpi_dp_add_child(dsd, name->sdw_name, am);
        }
 
        /* Now generate properties for source/slave on each defined data port. */
        for (entry = codec->dpn; entry; entry++) {
                struct acpi_dp *dpn;
 
                /* Stop processing at the first invalid data port. */
                if (entry->port < SOUNDWIRE_MIN_DPN || entry->port > SOUNDWIRE_MAX_DPN)
                        break;
 
                if (entry->source) {
                        name = &dpn_source_names[entry->port];
                        dpn = acpi_dp_new_table(name->acpi_name);
                        soundwire_gen_dpn(dpn, entry->source);
 
                        /* Callback for custom properties from the codec. */
                        if (dp_prop_cb)
                                dp_prop_cb(dpn, entry->port, codec);
                        acpi_dp_add_child(dsd, name->sdw_name, dpn);
                }
                if (entry->sink) {
                        name = &dpn_sink_names[entry->port];
                        dpn = acpi_dp_new_table(name->acpi_name);
                        soundwire_gen_dpn(dpn, entry->sink);
 
                        /* Callback for custom properties from the codec. */
                        if (dp_prop_cb)
                                dp_prop_cb(dpn, entry->port, codec);
                        acpi_dp_add_child(dsd, name->sdw_name, dpn);
                }
        }
}