kernel_optimize_test/drivers/slimbus/stream.c
Srinivas Kandagatla abb9c9b8b5 slimbus: stream: add stream support
This patch adds support to SLIMbus stream apis for slimbus device.
SLIMbus streaming involves adding support to Data Channel Management and
channel Reconfiguration Messages to slim core plus few stream apis.
>From slim device side the apis are very simple mostly inline with other
stream apis.

Currently it only supports Isochronous and Push/Pull transport protocols,
which are sufficient for audio use cases.

Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2018-07-07 17:25:23 +02:00

478 lines
12 KiB
C

// 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 */
110250,
220500,
441000,
882000,
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);