staging/greybus/audio_gb.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Greybus Audio Device Class Protocol helpers
0004  *
0005  * Copyright 2015-2016 Google Inc.
0006  */
0007
0008 #include <linux/greybus.h>
0009 #include "audio_codec.h"
0010
0011 /* TODO: Split into separate calls */
0012 int gb_audio_gb_get_topology(struct gb_connection *connection,
0013                  struct gb_audio_topology **topology)
0014 {
0015     struct gb_audio_get_topology_size_response size_resp;
0016     struct gb_audio_topology *topo;
0017     u16 size;
0018     int ret;
0019
0020     ret = gb_operation_sync(connection, GB_AUDIO_TYPE_GET_TOPOLOGY_SIZE,
0021                 NULL, 0, &size_resp, sizeof(size_resp));
0022     if (ret)
0023         return ret;
0024
0025     size = le16_to_cpu(size_resp.size);
0026     if (size < sizeof(*topo))
0027         return -ENODATA;
0028
0029     topo = kzalloc(size, GFP_KERNEL);
0030     if (!topo)
0031         return -ENOMEM;
0032
0033     ret = gb_operation_sync(connection, GB_AUDIO_TYPE_GET_TOPOLOGY, NULL, 0,
0034                 topo, size);
0035     if (ret) {
0036         kfree(topo);
0037         return ret;
0038     }
0039
0040     *topology = topo;
0041
0042     return 0;
0043 }
0044 EXPORT_SYMBOL_GPL(gb_audio_gb_get_topology);
0045
0046 int gb_audio_gb_get_control(struct gb_connection *connection,
0047                 u8 control_id, u8 index,
0048                 struct gb_audio_ctl_elem_value *value)
0049 {
0050     struct gb_audio_get_control_request req;
0051     struct gb_audio_get_control_response resp;
0052     int ret;
0053
0054     req.control_id = control_id;
0055     req.index = index;
0056
0057     ret = gb_operation_sync(connection, GB_AUDIO_TYPE_GET_CONTROL,
0058                 &req, sizeof(req), &resp, sizeof(resp));
0059     if (ret)
0060         return ret;
0061
0062     memcpy(value, &resp.value, sizeof(*value));
0063
0064     return 0;
0065 }
0066 EXPORT_SYMBOL_GPL(gb_audio_gb_get_control);
0067
0068 int gb_audio_gb_set_control(struct gb_connection *connection,
0069                 u8 control_id, u8 index,
0070                 struct gb_audio_ctl_elem_value *value)
0071 {
0072     struct gb_audio_set_control_request req;
0073
0074     req.control_id = control_id;
0075     req.index = index;
0076     memcpy(&req.value, value, sizeof(req.value));
0077
0078     return gb_operation_sync(connection, GB_AUDIO_TYPE_SET_CONTROL,
0079                  &req, sizeof(req), NULL, 0);
0080 }
0081 EXPORT_SYMBOL_GPL(gb_audio_gb_set_control);
0082
0083 int gb_audio_gb_enable_widget(struct gb_connection *connection,
0084                   u8 widget_id)
0085 {
0086     struct gb_audio_enable_widget_request req;
0087
0088     req.widget_id = widget_id;
0089
0090     return gb_operation_sync(connection, GB_AUDIO_TYPE_ENABLE_WIDGET,
0091                  &req, sizeof(req), NULL, 0);
0092 }
0093 EXPORT_SYMBOL_GPL(gb_audio_gb_enable_widget);
0094
0095 int gb_audio_gb_disable_widget(struct gb_connection *connection,
0096                    u8 widget_id)
0097 {
0098     struct gb_audio_disable_widget_request req;
0099
0100     req.widget_id = widget_id;
0101
0102     return gb_operation_sync(connection, GB_AUDIO_TYPE_DISABLE_WIDGET,
0103                  &req, sizeof(req), NULL, 0);
0104 }
0105 EXPORT_SYMBOL_GPL(gb_audio_gb_disable_widget);
0106
0107 int gb_audio_gb_get_pcm(struct gb_connection *connection, u16 data_cport,
0108             u32 *format, u32 *rate, u8 *channels,
0109             u8 *sig_bits)
0110 {
0111     struct gb_audio_get_pcm_request req;
0112     struct gb_audio_get_pcm_response resp;
0113     int ret;
0114
0115     req.data_cport = cpu_to_le16(data_cport);
0116
0117     ret = gb_operation_sync(connection, GB_AUDIO_TYPE_GET_PCM,
0118                 &req, sizeof(req), &resp, sizeof(resp));
0119     if (ret)
0120         return ret;
0121
0122     *format = le32_to_cpu(resp.format);
0123     *rate = le32_to_cpu(resp.rate);
0124     *channels = resp.channels;
0125     *sig_bits = resp.sig_bits;
0126
0127     return 0;
0128 }
0129 EXPORT_SYMBOL_GPL(gb_audio_gb_get_pcm);
0130
0131 int gb_audio_gb_set_pcm(struct gb_connection *connection, u16 data_cport,
0132             u32 format, u32 rate, u8 channels,
0133             u8 sig_bits)
0134 {
0135     struct gb_audio_set_pcm_request req;
0136
0137     req.data_cport = cpu_to_le16(data_cport);
0138     req.format = cpu_to_le32(format);
0139     req.rate = cpu_to_le32(rate);
0140     req.channels = channels;
0141     req.sig_bits = sig_bits;
0142
0143     return gb_operation_sync(connection, GB_AUDIO_TYPE_SET_PCM,
0144                  &req, sizeof(req), NULL, 0);
0145 }
0146 EXPORT_SYMBOL_GPL(gb_audio_gb_set_pcm);
0147
0148 int gb_audio_gb_set_tx_data_size(struct gb_connection *connection,
0149                  u16 data_cport, u16 size)
0150 {
0151     struct gb_audio_set_tx_data_size_request req;
0152
0153     req.data_cport = cpu_to_le16(data_cport);
0154     req.size = cpu_to_le16(size);
0155
0156     return gb_operation_sync(connection, GB_AUDIO_TYPE_SET_TX_DATA_SIZE,
0157                  &req, sizeof(req), NULL, 0);
0158 }
0159 EXPORT_SYMBOL_GPL(gb_audio_gb_set_tx_data_size);
0160
0161 int gb_audio_gb_activate_tx(struct gb_connection *connection,
0162                 u16 data_cport)
0163 {
0164     struct gb_audio_activate_tx_request req;
0165
0166     req.data_cport = cpu_to_le16(data_cport);
0167
0168     return gb_operation_sync(connection, GB_AUDIO_TYPE_ACTIVATE_TX,
0169                  &req, sizeof(req), NULL, 0);
0170 }
0171 EXPORT_SYMBOL_GPL(gb_audio_gb_activate_tx);
0172
0173 int gb_audio_gb_deactivate_tx(struct gb_connection *connection,
0174                   u16 data_cport)
0175 {
0176     struct gb_audio_deactivate_tx_request req;
0177
0178     req.data_cport = cpu_to_le16(data_cport);
0179
0180     return gb_operation_sync(connection, GB_AUDIO_TYPE_DEACTIVATE_TX,
0181                  &req, sizeof(req), NULL, 0);
0182 }
0183 EXPORT_SYMBOL_GPL(gb_audio_gb_deactivate_tx);
0184
0185 int gb_audio_gb_set_rx_data_size(struct gb_connection *connection,
0186                  u16 data_cport, u16 size)
0187 {
0188     struct gb_audio_set_rx_data_size_request req;
0189
0190     req.data_cport = cpu_to_le16(data_cport);
0191     req.size = cpu_to_le16(size);
0192
0193     return gb_operation_sync(connection, GB_AUDIO_TYPE_SET_RX_DATA_SIZE,
0194                  &req, sizeof(req), NULL, 0);
0195 }
0196 EXPORT_SYMBOL_GPL(gb_audio_gb_set_rx_data_size);
0197
0198 int gb_audio_gb_activate_rx(struct gb_connection *connection,
0199                 u16 data_cport)
0200 {
0201     struct gb_audio_activate_rx_request req;
0202
0203     req.data_cport = cpu_to_le16(data_cport);
0204
0205     return gb_operation_sync(connection, GB_AUDIO_TYPE_ACTIVATE_RX,
0206                  &req, sizeof(req), NULL, 0);
0207 }
0208 EXPORT_SYMBOL_GPL(gb_audio_gb_activate_rx);
0209
0210 int gb_audio_gb_deactivate_rx(struct gb_connection *connection,
0211                   u16 data_cport)
0212 {
0213     struct gb_audio_deactivate_rx_request req;
0214
0215     req.data_cport = cpu_to_le16(data_cport);
0216
0217     return gb_operation_sync(connection, GB_AUDIO_TYPE_DEACTIVATE_RX,
0218                  &req, sizeof(req), NULL, 0);
0219 }
0220 EXPORT_SYMBOL_GPL(gb_audio_gb_deactivate_rx);
0221
0222 MODULE_LICENSE("GPL v2");
0223 MODULE_ALIAS("greybus:audio-gb");
0224 MODULE_DESCRIPTION("Greybus Audio Device Class Protocol library");
0225 MODULE_AUTHOR("Mark Greer <mgreer@animalcreek.com>");