drivers/staging/greybus/audio_apbridgea.c

   1 /*
   2  * Greybus Audio Device Class Protocol helpers
   3  *
   4  * Copyright 2015-2016 Google Inc.
   5  *
   6  * Released under the GPLv2 only.
   7  */
   8
   9 #include "greybus.h"
  10 #include "greybus_protocols.h"
  11 #include "audio_apbridgea.h"
  12 #include "audio_codec.h"
  13
  14 int gb_audio_apbridgea_set_config(struct gb_connection *connection,
  15                                   __u16 i2s_port, __u32 format, __u32 rate,
  16                                   __u32 mclk_freq)
  17 {
  18         struct audio_apbridgea_set_config_request req;
  19
  20         req.hdr.type = AUDIO_APBRIDGEA_TYPE_SET_CONFIG;
  21         req.hdr.i2s_port = cpu_to_le16(i2s_port);
  22         req.format = cpu_to_le32(format);
  23         req.rate = cpu_to_le32(rate);
  24         req.mclk_freq = cpu_to_le32(mclk_freq);
  25
  26         return gb_hd_output(connection->hd, &req, sizeof(req),
  27                             GB_APB_REQUEST_AUDIO_CONTROL, true);
  28 }
  29 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_set_config);
  30
  31 int gb_audio_apbridgea_register_cport(struct gb_connection *connection,
  32                                       __u16 i2s_port, __u16 cportid,
  33                                       __u8 direction)
  34 {
  35         struct audio_apbridgea_register_cport_request req;
  36
  37         req.hdr.type = AUDIO_APBRIDGEA_TYPE_REGISTER_CPORT;
  38         req.hdr.i2s_port = cpu_to_le16(i2s_port);
  39         req.cport = cpu_to_le16(cportid);
  40         req.direction = direction;
  41
  42         return gb_hd_output(connection->hd, &req, sizeof(req),
  43                             GB_APB_REQUEST_AUDIO_CONTROL, true);
  44 }
  45 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_register_cport);
  46
  47 int gb_audio_apbridgea_unregister_cport(struct gb_connection *connection,
  48                                         __u16 i2s_port, __u16 cportid,
  49                                         __u8 direction)
  50 {
  51         struct audio_apbridgea_unregister_cport_request req;
  52
  53         req.hdr.type = AUDIO_APBRIDGEA_TYPE_UNREGISTER_CPORT;
  54         req.hdr.i2s_port = cpu_to_le16(i2s_port);
  55         req.cport = cpu_to_le16(cportid);
  56         req.direction = direction;
  57
  58         return gb_hd_output(connection->hd, &req, sizeof(req),
  59                             GB_APB_REQUEST_AUDIO_CONTROL, true);
  60 }
  61 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_unregister_cport);
  62
  63 int gb_audio_apbridgea_set_tx_data_size(struct gb_connection *connection,
  64                                         __u16 i2s_port, __u16 size)
  65 {
  66         struct audio_apbridgea_set_tx_data_size_request req;
  67
  68         req.hdr.type = AUDIO_APBRIDGEA_TYPE_SET_TX_DATA_SIZE;
  69         req.hdr.i2s_port = cpu_to_le16(i2s_port);
  70         req.size = cpu_to_le16(size);
  71
  72         return gb_hd_output(connection->hd, &req, sizeof(req),
  73                             GB_APB_REQUEST_AUDIO_CONTROL, true);
  74 }
  75 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_set_tx_data_size);
  76
  77 int gb_audio_apbridgea_get_tx_delay(struct gb_connection *connection,
  78                                     __u16 i2s_port, __u32 *delay)
  79 {
  80         /* TODO: implement */
  81         return -ENOSYS;
  82 }
  83 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_get_tx_delay);
  84
  85 int gb_audio_apbridgea_prepare_tx(struct gb_connection *connection,
  86                                   __u16 i2s_port)
  87 {
  88         struct audio_apbridgea_prepare_tx_request req;
  89
  90         req.hdr.type = AUDIO_APBRIDGEA_TYPE_PREPARE_TX;
  91         req.hdr.i2s_port = cpu_to_le16(i2s_port);
  92
  93         return gb_hd_output(connection->hd, &req, sizeof(req),
  94                             GB_APB_REQUEST_AUDIO_CONTROL, true);
  95 }
  96 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_prepare_tx);
  97
  98 int gb_audio_apbridgea_start_tx(struct gb_connection *connection,
  99                                 __u16 i2s_port, __u64 timestamp)
 100 {
 101         struct audio_apbridgea_start_tx_request req;
 102
 103         req.hdr.type = AUDIO_APBRIDGEA_TYPE_START_TX;
 104         req.hdr.i2s_port = cpu_to_le16(i2s_port);
 105         req.timestamp = cpu_to_le64(timestamp);
 106
 107         return gb_hd_output(connection->hd, &req, sizeof(req),
 108                             GB_APB_REQUEST_AUDIO_CONTROL, true);
 109 }
 110 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_start_tx);
 111
 112 int gb_audio_apbridgea_stop_tx(struct gb_connection *connection, __u16 i2s_port)
 113 {
 114         struct audio_apbridgea_stop_tx_request req;
 115
 116         req.hdr.type = AUDIO_APBRIDGEA_TYPE_STOP_TX;
 117         req.hdr.i2s_port = cpu_to_le16(i2s_port);
 118
 119         return gb_hd_output(connection->hd, &req, sizeof(req),
 120                             GB_APB_REQUEST_AUDIO_CONTROL, true);
 121 }
 122 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_stop_tx);
 123
 124 int gb_audio_apbridgea_shutdown_tx(struct gb_connection *connection,
 125                                    __u16 i2s_port)
 126 {
 127         struct audio_apbridgea_shutdown_tx_request req;
 128
 129         req.hdr.type = AUDIO_APBRIDGEA_TYPE_SHUTDOWN_TX;
 130         req.hdr.i2s_port = cpu_to_le16(i2s_port);
 131
 132         return gb_hd_output(connection->hd, &req, sizeof(req),
 133                             GB_APB_REQUEST_AUDIO_CONTROL, true);
 134 }
 135 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_shutdown_tx);
 136
 137 int gb_audio_apbridgea_set_rx_data_size(struct gb_connection *connection,
 138                                         __u16 i2s_port, __u16 size)
 139 {
 140         struct audio_apbridgea_set_rx_data_size_request req;
 141
 142         req.hdr.type = AUDIO_APBRIDGEA_TYPE_SET_RX_DATA_SIZE;
 143         req.hdr.i2s_port = cpu_to_le16(i2s_port);
 144         req.size = cpu_to_le16(size);
 145
 146         return gb_hd_output(connection->hd, &req, sizeof(req),
 147                             GB_APB_REQUEST_AUDIO_CONTROL, true);
 148 }
 149 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_set_rx_data_size);
 150
 151 int gb_audio_apbridgea_get_rx_delay(struct gb_connection *connection,
 152                                     __u16 i2s_port, __u32 *delay)
 153 {
 154         /* TODO: implement */
 155         return -ENOSYS;
 156 }
 157 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_get_rx_delay);
 158
 159 int gb_audio_apbridgea_prepare_rx(struct gb_connection *connection,
 160                                   __u16 i2s_port)
 161 {
 162         struct audio_apbridgea_prepare_rx_request req;
 163
 164         req.hdr.type = AUDIO_APBRIDGEA_TYPE_PREPARE_RX;
 165         req.hdr.i2s_port = cpu_to_le16(i2s_port);
 166
 167         return gb_hd_output(connection->hd, &req, sizeof(req),
 168                             GB_APB_REQUEST_AUDIO_CONTROL, true);
 169 }
 170 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_prepare_rx);
 171
 172 int gb_audio_apbridgea_start_rx(struct gb_connection *connection,
 173                                 __u16 i2s_port)
 174 {
 175         struct audio_apbridgea_start_rx_request req;
 176
 177         req.hdr.type = AUDIO_APBRIDGEA_TYPE_START_RX;
 178         req.hdr.i2s_port = cpu_to_le16(i2s_port);
 179
 180         return gb_hd_output(connection->hd, &req, sizeof(req),
 181                             GB_APB_REQUEST_AUDIO_CONTROL, true);
 182 }
 183 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_start_rx);
 184
 185 int gb_audio_apbridgea_stop_rx(struct gb_connection *connection, __u16 i2s_port)
 186 {
 187         struct audio_apbridgea_stop_rx_request req;
 188
 189         req.hdr.type = AUDIO_APBRIDGEA_TYPE_STOP_RX;
 190         req.hdr.i2s_port = cpu_to_le16(i2s_port);
 191
 192         return gb_hd_output(connection->hd, &req, sizeof(req),
 193                             GB_APB_REQUEST_AUDIO_CONTROL, true);
 194 }
 195 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_stop_rx);
 196
 197 int gb_audio_apbridgea_shutdown_rx(struct gb_connection *connection,
 198                                    __u16 i2s_port)
 199 {
 200         struct audio_apbridgea_shutdown_rx_request req;
 201
 202         req.hdr.type = AUDIO_APBRIDGEA_TYPE_SHUTDOWN_RX;
 203         req.hdr.i2s_port = cpu_to_le16(i2s_port);
 204
 205         return gb_hd_output(connection->hd, &req, sizeof(req),
 206                             GB_APB_REQUEST_AUDIO_CONTROL, true);
 207 }
 208 EXPORT_SYMBOL_GPL(gb_audio_apbridgea_shutdown_rx);
 209
 210 MODULE_LICENSE("GPL v2");
 211 MODULE_ALIAS("greybus:audio-apbridgea");
 212 MODULE_DESCRIPTION("Greybus Special APBridgeA Audio Protocol library");
 213 MODULE_AUTHOR("Mark Greer <mgreer@animalcreek.com>");