| // SPDX-License-Identifier: GPL-2.0 |
| // Copyright (c) 2018, Linaro Limited |
| |
| #include <linux/kernel.h> |
| #include <linux/errno.h> |
| #include <linux/slab.h> |
| #include <linux/list.h> |
| #include <linux/slimbus.h> |
| #include <uapi/sound/asound.h> |
| #include "slimbus.h" |
| |
| /** |
| * struct segdist_code - Segment Distributions code from |
| * Table 20 of SLIMbus Specs Version 2.0 |
| * |
| * @ratem: Channel Rate Multipler(Segments per Superframe) |
| * @seg_interval: Number of slots between the first Slot of Segment |
| * and the first slot of the next consecutive Segment. |
| * @segdist_code: Segment Distribution Code SD[11:0] |
| * @seg_offset_mask: Segment offset mask in SD[11:0] |
| * @segdist_codes: List of all possible Segmet Distribution codes. |
| */ |
| static const struct segdist_code { |
| int ratem; |
| int seg_interval; |
| int segdist_code; |
| u32 seg_offset_mask; |
| |
| } segdist_codes[] = { |
| {1, 1536, 0x200, 0xdff}, |
| {2, 768, 0x100, 0xcff}, |
| {4, 384, 0x080, 0xc7f}, |
| {8, 192, 0x040, 0xc3f}, |
| {16, 96, 0x020, 0xc1f}, |
| {32, 48, 0x010, 0xc0f}, |
| {64, 24, 0x008, 0xc07}, |
| {128, 12, 0x004, 0xc03}, |
| {256, 6, 0x002, 0xc01}, |
| {512, 3, 0x001, 0xc00}, |
| {3, 512, 0xe00, 0x1ff}, |
| {6, 256, 0xd00, 0x0ff}, |
| {12, 128, 0xc80, 0x07f}, |
| {24, 64, 0xc40, 0x03f}, |
| {48, 32, 0xc20, 0x01f}, |
| {96, 16, 0xc10, 0x00f}, |
| {192, 8, 0xc08, 0x007}, |
| {364, 4, 0xc04, 0x003}, |
| {768, 2, 0xc02, 0x001}, |
| }; |
| |
| /* |
| * Presence Rate table for all Natural Frequencies |
| * The Presence rate of a constant bitrate stream is mean flow rate of the |
| * stream expressed in occupied Segments of that Data Channel per second. |
| * Table 66 from SLIMbus 2.0 Specs |
| * |
| * Index of the table corresponds to Presence rate code for the respective rate |
| * in the table. |
| */ |
| static const int slim_presence_rate_table[] = { |
| 0, /* Not Indicated */ |
| 12000, |
| 24000, |
| 48000, |
| 96000, |
| 192000, |
| 384000, |
| 768000, |
| 0, /* Reserved */ |
| 11025, |
| 22050, |
| 44100, |
| 88200, |
| 176400, |
| 352800, |
| 705600, |
| 4000, |
| 8000, |
| 16000, |
| 32000, |
| 64000, |
| 128000, |
| 256000, |
| 512000, |
| }; |
| |
| /* |
| * slim_stream_allocate() - Allocate a new SLIMbus Stream |
| * @dev:Slim device to be associated with |
| * @name: name of the stream |
| * |
| * This is very first call for SLIMbus streaming, this API will allocate |
| * a new SLIMbus stream and return a valid stream runtime pointer for client |
| * to use it in subsequent stream apis. state of stream is set to ALLOCATED |
| * |
| * Return: valid pointer on success and error code on failure. |
| * From ASoC DPCM framework, this state is linked to startup() operation. |
| */ |
| struct slim_stream_runtime *slim_stream_allocate(struct slim_device *dev, |
| const char *name) |
| { |
| struct slim_stream_runtime *rt; |
| |
| rt = kzalloc(sizeof(*rt), GFP_KERNEL); |
| if (!rt) |
| return ERR_PTR(-ENOMEM); |
| |
| rt->name = kasprintf(GFP_KERNEL, "slim-%s", name); |
| if (!rt->name) { |
| kfree(rt); |
| return ERR_PTR(-ENOMEM); |
| } |
| |
| rt->dev = dev; |
| spin_lock(&dev->stream_list_lock); |
| list_add_tail(&rt->node, &dev->stream_list); |
| spin_unlock(&dev->stream_list_lock); |
| |
| return rt; |
| } |
| EXPORT_SYMBOL_GPL(slim_stream_allocate); |
| |
| static int slim_connect_port_channel(struct slim_stream_runtime *stream, |
| struct slim_port *port) |
| { |
| struct slim_device *sdev = stream->dev; |
| u8 wbuf[2]; |
| struct slim_val_inf msg = {0, 2, NULL, wbuf, NULL}; |
| u8 mc = SLIM_MSG_MC_CONNECT_SOURCE; |
| DEFINE_SLIM_LDEST_TXN(txn, mc, 6, stream->dev->laddr, &msg); |
| |
| if (port->direction == SLIM_PORT_SINK) |
| txn.mc = SLIM_MSG_MC_CONNECT_SINK; |
| |
| wbuf[0] = port->id; |
| wbuf[1] = port->ch.id; |
| port->ch.state = SLIM_CH_STATE_ASSOCIATED; |
| port->state = SLIM_PORT_UNCONFIGURED; |
| |
| return slim_do_transfer(sdev->ctrl, &txn); |
| } |
| |
| static int slim_disconnect_port(struct slim_stream_runtime *stream, |
| struct slim_port *port) |
| { |
| struct slim_device *sdev = stream->dev; |
| u8 wbuf[1]; |
| struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL}; |
| u8 mc = SLIM_MSG_MC_DISCONNECT_PORT; |
| DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg); |
| |
| wbuf[0] = port->id; |
| port->ch.state = SLIM_CH_STATE_DISCONNECTED; |
| port->state = SLIM_PORT_DISCONNECTED; |
| |
| return slim_do_transfer(sdev->ctrl, &txn); |
| } |
| |
| static int slim_deactivate_remove_channel(struct slim_stream_runtime *stream, |
| struct slim_port *port) |
| { |
| struct slim_device *sdev = stream->dev; |
| u8 wbuf[1]; |
| struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL}; |
| u8 mc = SLIM_MSG_MC_NEXT_DEACTIVATE_CHANNEL; |
| DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg); |
| int ret; |
| |
| wbuf[0] = port->ch.id; |
| ret = slim_do_transfer(sdev->ctrl, &txn); |
| if (ret) |
| return ret; |
| |
| txn.mc = SLIM_MSG_MC_NEXT_REMOVE_CHANNEL; |
| port->ch.state = SLIM_CH_STATE_REMOVED; |
| |
| return slim_do_transfer(sdev->ctrl, &txn); |
| } |
| |
| static int slim_get_prate_code(int rate) |
| { |
| int i; |
| |
| for (i = 0; i < ARRAY_SIZE(slim_presence_rate_table); i++) { |
| if (rate == slim_presence_rate_table[i]) |
| return i; |
| } |
| |
| return -EINVAL; |
| } |
| |
| /* |
| * slim_stream_prepare() - Prepare a SLIMbus Stream |
| * |
| * @rt: instance of slim stream runtime to configure |
| * @cfg: new configuration for the stream |
| * |
| * This API will configure SLIMbus stream with config parameters from cfg. |
| * return zero on success and error code on failure. From ASoC DPCM framework, |
| * this state is linked to hw_params() operation. |
| */ |
| int slim_stream_prepare(struct slim_stream_runtime *rt, |
| struct slim_stream_config *cfg) |
| { |
| struct slim_controller *ctrl = rt->dev->ctrl; |
| struct slim_port *port; |
| int num_ports, i, port_id; |
| |
| if (rt->ports) { |
| dev_err(&rt->dev->dev, "Stream already Prepared\n"); |
| return -EINVAL; |
| } |
| |
| num_ports = hweight32(cfg->port_mask); |
| rt->ports = kcalloc(num_ports, sizeof(*port), GFP_KERNEL); |
| if (!rt->ports) |
| return -ENOMEM; |
| |
| rt->num_ports = num_ports; |
| rt->rate = cfg->rate; |
| rt->bps = cfg->bps; |
| rt->direction = cfg->direction; |
| |
| if (cfg->rate % ctrl->a_framer->superfreq) { |
| /* |
| * data rate not exactly multiple of super frame, |
| * use PUSH/PULL protocol |
| */ |
| if (cfg->direction == SNDRV_PCM_STREAM_PLAYBACK) |
| rt->prot = SLIM_PROTO_PUSH; |
| else |
| rt->prot = SLIM_PROTO_PULL; |
| } else { |
| rt->prot = SLIM_PROTO_ISO; |
| } |
| |
| rt->ratem = cfg->rate/ctrl->a_framer->superfreq; |
| |
| i = 0; |
| for_each_set_bit(port_id, &cfg->port_mask, SLIM_DEVICE_MAX_PORTS) { |
| port = &rt->ports[i]; |
| port->state = SLIM_PORT_DISCONNECTED; |
| port->id = port_id; |
| port->ch.prrate = slim_get_prate_code(cfg->rate); |
| port->ch.id = cfg->chs[i]; |
| port->ch.data_fmt = SLIM_CH_DATA_FMT_NOT_DEFINED; |
| port->ch.aux_fmt = SLIM_CH_AUX_FMT_NOT_APPLICABLE; |
| port->ch.state = SLIM_CH_STATE_ALLOCATED; |
| |
| if (cfg->direction == SNDRV_PCM_STREAM_PLAYBACK) |
| port->direction = SLIM_PORT_SINK; |
| else |
| port->direction = SLIM_PORT_SOURCE; |
| |
| slim_connect_port_channel(rt, port); |
| i++; |
| } |
| |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(slim_stream_prepare); |
| |
| static int slim_define_channel_content(struct slim_stream_runtime *stream, |
| struct slim_port *port) |
| { |
| struct slim_device *sdev = stream->dev; |
| u8 wbuf[4]; |
| struct slim_val_inf msg = {0, 4, NULL, wbuf, NULL}; |
| u8 mc = SLIM_MSG_MC_NEXT_DEFINE_CONTENT; |
| DEFINE_SLIM_LDEST_TXN(txn, mc, 8, stream->dev->laddr, &msg); |
| |
| wbuf[0] = port->ch.id; |
| wbuf[1] = port->ch.prrate; |
| |
| /* Frequency Locked for ISO Protocol */ |
| if (stream->prot != SLIM_PROTO_ISO) |
| wbuf[1] |= SLIM_CHANNEL_CONTENT_FL; |
| |
| wbuf[2] = port->ch.data_fmt | (port->ch.aux_fmt << 4); |
| wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS; |
| port->ch.state = SLIM_CH_STATE_CONTENT_DEFINED; |
| |
| return slim_do_transfer(sdev->ctrl, &txn); |
| } |
| |
| static int slim_get_segdist_code(int ratem) |
| { |
| int i; |
| |
| for (i = 0; i < ARRAY_SIZE(segdist_codes); i++) { |
| if (segdist_codes[i].ratem == ratem) |
| return segdist_codes[i].segdist_code; |
| } |
| |
| return -EINVAL; |
| } |
| |
| static int slim_define_channel(struct slim_stream_runtime *stream, |
| struct slim_port *port) |
| { |
| struct slim_device *sdev = stream->dev; |
| u8 wbuf[4]; |
| struct slim_val_inf msg = {0, 4, NULL, wbuf, NULL}; |
| u8 mc = SLIM_MSG_MC_NEXT_DEFINE_CHANNEL; |
| DEFINE_SLIM_LDEST_TXN(txn, mc, 8, stream->dev->laddr, &msg); |
| |
| port->ch.seg_dist = slim_get_segdist_code(stream->ratem); |
| |
| wbuf[0] = port->ch.id; |
| wbuf[1] = port->ch.seg_dist & 0xFF; |
| wbuf[2] = (stream->prot << 4) | ((port->ch.seg_dist & 0xF00) >> 8); |
| if (stream->prot == SLIM_PROTO_ISO) |
| wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS; |
| else |
| wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS + 1; |
| |
| port->ch.state = SLIM_CH_STATE_DEFINED; |
| |
| return slim_do_transfer(sdev->ctrl, &txn); |
| } |
| |
| static int slim_activate_channel(struct slim_stream_runtime *stream, |
| struct slim_port *port) |
| { |
| struct slim_device *sdev = stream->dev; |
| u8 wbuf[1]; |
| struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL}; |
| u8 mc = SLIM_MSG_MC_NEXT_ACTIVATE_CHANNEL; |
| DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg); |
| |
| txn.msg->num_bytes = 1; |
| txn.msg->wbuf = wbuf; |
| wbuf[0] = port->ch.id; |
| port->ch.state = SLIM_CH_STATE_ACTIVE; |
| |
| return slim_do_transfer(sdev->ctrl, &txn); |
| } |
| |
| /* |
| * slim_stream_enable() - Enable a prepared SLIMbus Stream |
| * |
| * @stream: instance of slim stream runtime to enable |
| * |
| * This API will enable all the ports and channels associated with |
| * SLIMbus stream |
| * |
| * Return: zero on success and error code on failure. From ASoC DPCM framework, |
| * this state is linked to trigger() start operation. |
| */ |
| int slim_stream_enable(struct slim_stream_runtime *stream) |
| { |
| DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION, |
| 3, SLIM_LA_MANAGER, NULL); |
| struct slim_controller *ctrl = stream->dev->ctrl; |
| int ret, i; |
| |
| if (ctrl->enable_stream) { |
| ret = ctrl->enable_stream(stream); |
| if (ret) |
| return ret; |
| |
| for (i = 0; i < stream->num_ports; i++) |
| stream->ports[i].ch.state = SLIM_CH_STATE_ACTIVE; |
| |
| return ret; |
| } |
| |
| ret = slim_do_transfer(ctrl, &txn); |
| if (ret) |
| return ret; |
| |
| /* define channels first before activating them */ |
| for (i = 0; i < stream->num_ports; i++) { |
| struct slim_port *port = &stream->ports[i]; |
| |
| slim_define_channel(stream, port); |
| slim_define_channel_content(stream, port); |
| } |
| |
| for (i = 0; i < stream->num_ports; i++) { |
| struct slim_port *port = &stream->ports[i]; |
| |
| slim_activate_channel(stream, port); |
| port->state = SLIM_PORT_CONFIGURED; |
| } |
| txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW; |
| |
| return slim_do_transfer(ctrl, &txn); |
| } |
| EXPORT_SYMBOL_GPL(slim_stream_enable); |
| |
| /* |
| * slim_stream_disable() - Disable a SLIMbus Stream |
| * |
| * @stream: instance of slim stream runtime to disable |
| * |
| * This API will disable all the ports and channels associated with |
| * SLIMbus stream |
| * |
| * Return: zero on success and error code on failure. From ASoC DPCM framework, |
| * this state is linked to trigger() pause operation. |
| */ |
| int slim_stream_disable(struct slim_stream_runtime *stream) |
| { |
| DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION, |
| 3, SLIM_LA_MANAGER, NULL); |
| struct slim_controller *ctrl = stream->dev->ctrl; |
| int ret, i; |
| |
| if (ctrl->disable_stream) |
| ctrl->disable_stream(stream); |
| |
| ret = slim_do_transfer(ctrl, &txn); |
| if (ret) |
| return ret; |
| |
| for (i = 0; i < stream->num_ports; i++) |
| slim_deactivate_remove_channel(stream, &stream->ports[i]); |
| |
| txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW; |
| |
| return slim_do_transfer(ctrl, &txn); |
| } |
| EXPORT_SYMBOL_GPL(slim_stream_disable); |
| |
| /* |
| * slim_stream_unprepare() - Un-prepare a SLIMbus Stream |
| * |
| * @stream: instance of slim stream runtime to unprepare |
| * |
| * This API will un allocate all the ports and channels associated with |
| * SLIMbus stream |
| * |
| * Return: zero on success and error code on failure. From ASoC DPCM framework, |
| * this state is linked to trigger() stop operation. |
| */ |
| int slim_stream_unprepare(struct slim_stream_runtime *stream) |
| { |
| int i; |
| |
| for (i = 0; i < stream->num_ports; i++) |
| slim_disconnect_port(stream, &stream->ports[i]); |
| |
| kfree(stream->ports); |
| stream->ports = NULL; |
| stream->num_ports = 0; |
| |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(slim_stream_unprepare); |
| |
| /* |
| * slim_stream_free() - Free a SLIMbus Stream |
| * |
| * @stream: instance of slim stream runtime to free |
| * |
| * This API will un allocate all the memory associated with |
| * slim stream runtime, user is not allowed to make an dereference |
| * to stream after this call. |
| * |
| * Return: zero on success and error code on failure. From ASoC DPCM framework, |
| * this state is linked to shutdown() operation. |
| */ |
| int slim_stream_free(struct slim_stream_runtime *stream) |
| { |
| struct slim_device *sdev = stream->dev; |
| |
| spin_lock(&sdev->stream_list_lock); |
| list_del(&stream->node); |
| spin_unlock(&sdev->stream_list_lock); |
| |
| kfree(stream->name); |
| kfree(stream); |
| |
| return 0; |
| } |
| EXPORT_SYMBOL_GPL(slim_stream_free); |