drivers/slimbus/stream.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
slim_stream_allocate
slim_connect_port_channel
slim_disconnect_port
slim_deactivate_remove_channel
slim_get_prate_code
slim_stream_prepare
slim_define_channel_content
slim_get_segdist_code
slim_define_channel
slim_activate_channel
slim_stream_enable
slim_stream_disable
slim_stream_unprepare
slim_stream_free
   1 // SPDX-License-Identifier: GPL-2.0
   2 // Copyright (c) 2018, Linaro Limited
   3 
   4 #include <linux/kernel.h>
   5 #include <linux/errno.h>
   6 #include <linux/slab.h>
   7 #include <linux/list.h>
   8 #include <linux/slimbus.h>
   9 #include <uapi/sound/asound.h>
  10 #include "slimbus.h"
  11 
  12 /**
  13  * struct segdist_code - Segment Distributions code from
  14  *      Table 20 of SLIMbus Specs Version 2.0
  15  *
  16  * @ratem: Channel Rate Multipler(Segments per Superframe)
  17  * @seg_interval: Number of slots between the first Slot of Segment
  18  *              and the first slot of the next  consecutive Segment.
  19  * @segdist_code: Segment Distribution Code SD[11:0]
  20  * @seg_offset_mask: Segment offset mask in SD[11:0]
  21  * @segdist_codes: List of all possible Segmet Distribution codes.
  22  */
  23 static const struct segdist_code {
  24         int ratem;
  25         int seg_interval;
  26         int segdist_code;
  27         u32 seg_offset_mask;
  28 
  29 } segdist_codes[] = {
  30         {1,     1536,   0x200,   0xdff},
  31         {2,     768,    0x100,   0xcff},
  32         {4,     384,    0x080,   0xc7f},
  33         {8,     192,    0x040,   0xc3f},
  34         {16,    96,     0x020,   0xc1f},
  35         {32,    48,     0x010,   0xc0f},
  36         {64,    24,     0x008,   0xc07},
  37         {128,   12,     0x004,   0xc03},
  38         {256,   6,      0x002,   0xc01},
  39         {512,   3,      0x001,   0xc00},
  40         {3,     512,    0xe00,   0x1ff},
  41         {6,     256,    0xd00,   0x0ff},
  42         {12,    128,    0xc80,   0x07f},
  43         {24,    64,     0xc40,   0x03f},
  44         {48,    32,     0xc20,   0x01f},
  45         {96,    16,     0xc10,   0x00f},
  46         {192,   8,      0xc08,   0x007},
  47         {364,   4,      0xc04,   0x003},
  48         {768,   2,      0xc02,   0x001},
  49 };
  50 
  51 /*
  52  * Presence Rate table for all Natural Frequencies
  53  * The Presence rate of a constant bitrate stream is mean flow rate of the
  54  * stream expressed in occupied Segments of that Data Channel per second.
  55  * Table 66 from SLIMbus 2.0 Specs
  56  *
  57  * Index of the table corresponds to Presence rate code for the respective rate
  58  * in the table.
  59  */
  60 static const int slim_presence_rate_table[] = {
  61         0, /* Not Indicated */
  62         12000,
  63         24000,
  64         48000,
  65         96000,
  66         192000,
  67         384000,
  68         768000,
  69         0, /* Reserved */
  70         110250,
  71         220500,
  72         441000,
  73         882000,
  74         176400,
  75         352800,
  76         705600,
  77         4000,
  78         8000,
  79         16000,
  80         32000,
  81         64000,
  82         128000,
  83         256000,
  84         512000,
  85 };
  86 
  87 /**
  88  * slim_stream_allocate() - Allocate a new SLIMbus Stream
  89  * @dev:Slim device to be associated with
  90  * @name: name of the stream
  91  *
  92  * This is very first call for SLIMbus streaming, this API will allocate
  93  * a new SLIMbus stream and return a valid stream runtime pointer for client
  94  * to use it in subsequent stream apis. state of stream is set to ALLOCATED
  95  *
  96  * Return: valid pointer on success and error code on failure.
  97  * From ASoC DPCM framework, this state is linked to startup() operation.
  98  */
  99 struct slim_stream_runtime *slim_stream_allocate(struct slim_device *dev,
 100                                                  const char *name)
 101 {
 102         struct slim_stream_runtime *rt;
 103 
 104         rt = kzalloc(sizeof(*rt), GFP_KERNEL);
 105         if (!rt)
 106                 return ERR_PTR(-ENOMEM);
 107 
 108         rt->name = kasprintf(GFP_KERNEL, "slim-%s", name);
 109         if (!rt->name) {
 110                 kfree(rt);
 111                 return ERR_PTR(-ENOMEM);
 112         }
 113 
 114         rt->dev = dev;
 115         spin_lock(&dev->stream_list_lock);
 116         list_add_tail(&rt->node, &dev->stream_list);
 117         spin_unlock(&dev->stream_list_lock);
 118 
 119         return rt;
 120 }
 121 EXPORT_SYMBOL_GPL(slim_stream_allocate);
 122 
 123 static int slim_connect_port_channel(struct slim_stream_runtime *stream,
 124                                      struct slim_port *port)
 125 {
 126         struct slim_device *sdev = stream->dev;
 127         u8 wbuf[2];
 128         struct slim_val_inf msg = {0, 2, NULL, wbuf, NULL};
 129         u8 mc = SLIM_MSG_MC_CONNECT_SOURCE;
 130         DEFINE_SLIM_LDEST_TXN(txn, mc, 6, stream->dev->laddr, &msg);
 131 
 132         if (port->direction == SLIM_PORT_SINK)
 133                 txn.mc = SLIM_MSG_MC_CONNECT_SINK;
 134 
 135         wbuf[0] = port->id;
 136         wbuf[1] = port->ch.id;
 137         port->ch.state = SLIM_CH_STATE_ASSOCIATED;
 138         port->state = SLIM_PORT_UNCONFIGURED;
 139 
 140         return slim_do_transfer(sdev->ctrl, &txn);
 141 }
 142 
 143 static int slim_disconnect_port(struct slim_stream_runtime *stream,
 144                                 struct slim_port *port)
 145 {
 146         struct slim_device *sdev = stream->dev;
 147         u8 wbuf[1];
 148         struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL};
 149         u8 mc = SLIM_MSG_MC_DISCONNECT_PORT;
 150         DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg);
 151 
 152         wbuf[0] = port->id;
 153         port->ch.state = SLIM_CH_STATE_DISCONNECTED;
 154         port->state = SLIM_PORT_DISCONNECTED;
 155 
 156         return slim_do_transfer(sdev->ctrl, &txn);
 157 }
 158 
 159 static int slim_deactivate_remove_channel(struct slim_stream_runtime *stream,
 160                                           struct slim_port *port)
 161 {
 162         struct slim_device *sdev = stream->dev;
 163         u8 wbuf[1];
 164         struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL};
 165         u8 mc = SLIM_MSG_MC_NEXT_DEACTIVATE_CHANNEL;
 166         DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg);
 167         int ret;
 168 
 169         wbuf[0] = port->ch.id;
 170         ret = slim_do_transfer(sdev->ctrl, &txn);
 171         if (ret)
 172                 return ret;
 173 
 174         txn.mc = SLIM_MSG_MC_NEXT_REMOVE_CHANNEL;
 175         port->ch.state = SLIM_CH_STATE_REMOVED;
 176 
 177         return slim_do_transfer(sdev->ctrl, &txn);
 178 }
 179 
 180 static int slim_get_prate_code(int rate)
 181 {
 182         int i;
 183 
 184         for (i = 0; i < ARRAY_SIZE(slim_presence_rate_table); i++) {
 185                 if (rate == slim_presence_rate_table[i])
 186                         return i;
 187         }
 188 
 189         return -EINVAL;
 190 }
 191 
 192 /**
 193  * slim_stream_prepare() - Prepare a SLIMbus Stream
 194  *
 195  * @rt: instance of slim stream runtime to configure
 196  * @cfg: new configuration for the stream
 197  *
 198  * This API will configure SLIMbus stream with config parameters from cfg.
 199  * return zero on success and error code on failure. From ASoC DPCM framework,
 200  * this state is linked to hw_params() operation.
 201  */
 202 int slim_stream_prepare(struct slim_stream_runtime *rt,
 203                         struct slim_stream_config *cfg)
 204 {
 205         struct slim_controller *ctrl = rt->dev->ctrl;
 206         struct slim_port *port;
 207         int num_ports, i, port_id;
 208 
 209         if (rt->ports) {
 210                 dev_err(&rt->dev->dev, "Stream already Prepared\n");
 211                 return -EINVAL;
 212         }
 213 
 214         num_ports = hweight32(cfg->port_mask);
 215         rt->ports = kcalloc(num_ports, sizeof(*port), GFP_KERNEL);
 216         if (!rt->ports)
 217                 return -ENOMEM;
 218 
 219         rt->num_ports = num_ports;
 220         rt->rate = cfg->rate;
 221         rt->bps = cfg->bps;
 222         rt->direction = cfg->direction;
 223 
 224         if (cfg->rate % ctrl->a_framer->superfreq) {
 225                 /*
 226                  * data rate not exactly multiple of super frame,
 227                  * use PUSH/PULL protocol
 228                  */
 229                 if (cfg->direction == SNDRV_PCM_STREAM_PLAYBACK)
 230                         rt->prot = SLIM_PROTO_PUSH;
 231                 else
 232                         rt->prot = SLIM_PROTO_PULL;
 233         } else {
 234                 rt->prot = SLIM_PROTO_ISO;
 235         }
 236 
 237         rt->ratem = cfg->rate/ctrl->a_framer->superfreq;
 238 
 239         i = 0;
 240         for_each_set_bit(port_id, &cfg->port_mask, SLIM_DEVICE_MAX_PORTS) {
 241                 port = &rt->ports[i];
 242                 port->state = SLIM_PORT_DISCONNECTED;
 243                 port->id = port_id;
 244                 port->ch.prrate = slim_get_prate_code(cfg->rate);
 245                 port->ch.id = cfg->chs[i];
 246                 port->ch.data_fmt = SLIM_CH_DATA_FMT_NOT_DEFINED;
 247                 port->ch.aux_fmt = SLIM_CH_AUX_FMT_NOT_APPLICABLE;
 248                 port->ch.state = SLIM_CH_STATE_ALLOCATED;
 249 
 250                 if (cfg->direction == SNDRV_PCM_STREAM_PLAYBACK)
 251                         port->direction = SLIM_PORT_SINK;
 252                 else
 253                         port->direction = SLIM_PORT_SOURCE;
 254 
 255                 slim_connect_port_channel(rt, port);
 256                 i++;
 257         }
 258 
 259         return 0;
 260 }
 261 EXPORT_SYMBOL_GPL(slim_stream_prepare);
 262 
 263 static int slim_define_channel_content(struct slim_stream_runtime *stream,
 264                                        struct slim_port *port)
 265 {
 266         struct slim_device *sdev = stream->dev;
 267         u8 wbuf[4];
 268         struct slim_val_inf msg = {0, 4, NULL, wbuf, NULL};
 269         u8 mc = SLIM_MSG_MC_NEXT_DEFINE_CONTENT;
 270         DEFINE_SLIM_LDEST_TXN(txn, mc, 8, stream->dev->laddr, &msg);
 271 
 272         wbuf[0] = port->ch.id;
 273         wbuf[1] = port->ch.prrate;
 274 
 275         /* Frequency Locked for ISO Protocol */
 276         if (stream->prot != SLIM_PROTO_ISO)
 277                 wbuf[1] |= SLIM_CHANNEL_CONTENT_FL;
 278 
 279         wbuf[2] = port->ch.data_fmt | (port->ch.aux_fmt << 4);
 280         wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS;
 281         port->ch.state = SLIM_CH_STATE_CONTENT_DEFINED;
 282 
 283         return slim_do_transfer(sdev->ctrl, &txn);
 284 }
 285 
 286 static int slim_get_segdist_code(int ratem)
 287 {
 288         int i;
 289 
 290         for (i = 0; i < ARRAY_SIZE(segdist_codes); i++) {
 291                 if (segdist_codes[i].ratem == ratem)
 292                         return segdist_codes[i].segdist_code;
 293         }
 294 
 295         return -EINVAL;
 296 }
 297 
 298 static int slim_define_channel(struct slim_stream_runtime *stream,
 299                                        struct slim_port *port)
 300 {
 301         struct slim_device *sdev = stream->dev;
 302         u8 wbuf[4];
 303         struct slim_val_inf msg = {0, 4, NULL, wbuf, NULL};
 304         u8 mc = SLIM_MSG_MC_NEXT_DEFINE_CHANNEL;
 305         DEFINE_SLIM_LDEST_TXN(txn, mc, 8, stream->dev->laddr, &msg);
 306 
 307         port->ch.seg_dist = slim_get_segdist_code(stream->ratem);
 308 
 309         wbuf[0] = port->ch.id;
 310         wbuf[1] = port->ch.seg_dist & 0xFF;
 311         wbuf[2] = (stream->prot << 4) | ((port->ch.seg_dist & 0xF00) >> 8);
 312         if (stream->prot == SLIM_PROTO_ISO)
 313                 wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS;
 314         else
 315                 wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS + 1;
 316 
 317         port->ch.state = SLIM_CH_STATE_DEFINED;
 318 
 319         return slim_do_transfer(sdev->ctrl, &txn);
 320 }
 321 
 322 static int slim_activate_channel(struct slim_stream_runtime *stream,
 323                                  struct slim_port *port)
 324 {
 325         struct slim_device *sdev = stream->dev;
 326         u8 wbuf[1];
 327         struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL};
 328         u8 mc = SLIM_MSG_MC_NEXT_ACTIVATE_CHANNEL;
 329         DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg);
 330 
 331         txn.msg->num_bytes = 1;
 332         txn.msg->wbuf = wbuf;
 333         wbuf[0] = port->ch.id;
 334         port->ch.state = SLIM_CH_STATE_ACTIVE;
 335 
 336         return slim_do_transfer(sdev->ctrl, &txn);
 337 }
 338 
 339 /**
 340  * slim_stream_enable() - Enable a prepared SLIMbus Stream
 341  *
 342  * @stream: instance of slim stream runtime to enable
 343  *
 344  * This API will enable all the ports and channels associated with
 345  * SLIMbus stream
 346  *
 347  * Return: zero on success and error code on failure. From ASoC DPCM framework,
 348  * this state is linked to trigger() start operation.
 349  */
 350 int slim_stream_enable(struct slim_stream_runtime *stream)
 351 {
 352         DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION,
 353                                 3, SLIM_LA_MANAGER, NULL);
 354         struct slim_controller *ctrl = stream->dev->ctrl;
 355         int ret, i;
 356 
 357         if (ctrl->enable_stream) {
 358                 ret = ctrl->enable_stream(stream);
 359                 if (ret)
 360                         return ret;
 361 
 362                 for (i = 0; i < stream->num_ports; i++)
 363                         stream->ports[i].ch.state = SLIM_CH_STATE_ACTIVE;
 364 
 365                 return ret;
 366         }
 367 
 368         ret = slim_do_transfer(ctrl, &txn);
 369         if (ret)
 370                 return ret;
 371 
 372         /* define channels first before activating them */
 373         for (i = 0; i < stream->num_ports; i++) {
 374                 struct slim_port *port = &stream->ports[i];
 375 
 376                 slim_define_channel(stream, port);
 377                 slim_define_channel_content(stream, port);
 378         }
 379 
 380         for (i = 0; i < stream->num_ports; i++) {
 381                 struct slim_port *port = &stream->ports[i];
 382 
 383                 slim_activate_channel(stream, port);
 384                 port->state = SLIM_PORT_CONFIGURED;
 385         }
 386         txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW;
 387 
 388         return slim_do_transfer(ctrl, &txn);
 389 }
 390 EXPORT_SYMBOL_GPL(slim_stream_enable);
 391 
 392 /**
 393  * slim_stream_disable() - Disable a SLIMbus Stream
 394  *
 395  * @stream: instance of slim stream runtime to disable
 396  *
 397  * This API will disable all the ports and channels associated with
 398  * SLIMbus stream
 399  *
 400  * Return: zero on success and error code on failure. From ASoC DPCM framework,
 401  * this state is linked to trigger() pause operation.
 402  */
 403 int slim_stream_disable(struct slim_stream_runtime *stream)
 404 {
 405         DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION,
 406                                 3, SLIM_LA_MANAGER, NULL);
 407         struct slim_controller *ctrl = stream->dev->ctrl;
 408         int ret, i;
 409 
 410         if (ctrl->disable_stream)
 411                 ctrl->disable_stream(stream);
 412 
 413         ret = slim_do_transfer(ctrl, &txn);
 414         if (ret)
 415                 return ret;
 416 
 417         for (i = 0; i < stream->num_ports; i++)
 418                 slim_deactivate_remove_channel(stream, &stream->ports[i]);
 419 
 420         txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW;
 421 
 422         return slim_do_transfer(ctrl, &txn);
 423 }
 424 EXPORT_SYMBOL_GPL(slim_stream_disable);
 425 
 426 /**
 427  * slim_stream_unprepare() - Un-prepare a SLIMbus Stream
 428  *
 429  * @stream: instance of slim stream runtime to unprepare
 430  *
 431  * This API will un allocate all the ports and channels associated with
 432  * SLIMbus stream
 433  *
 434  * Return: zero on success and error code on failure. From ASoC DPCM framework,
 435  * this state is linked to trigger() stop operation.
 436  */
 437 int slim_stream_unprepare(struct slim_stream_runtime *stream)
 438 {
 439         int i;
 440 
 441         for (i = 0; i < stream->num_ports; i++)
 442                 slim_disconnect_port(stream, &stream->ports[i]);
 443 
 444         kfree(stream->ports);
 445         stream->ports = NULL;
 446         stream->num_ports = 0;
 447 
 448         return 0;
 449 }
 450 EXPORT_SYMBOL_GPL(slim_stream_unprepare);
 451 
 452 /**
 453  * slim_stream_free() - Free a SLIMbus Stream
 454  *
 455  * @stream: instance of slim stream runtime to free
 456  *
 457  * This API will un allocate all the memory associated with
 458  * slim stream runtime, user is not allowed to make an dereference
 459  * to stream after this call.
 460  *
 461  * Return: zero on success and error code on failure. From ASoC DPCM framework,
 462  * this state is linked to shutdown() operation.
 463  */
 464 int slim_stream_free(struct slim_stream_runtime *stream)
 465 {
 466         struct slim_device *sdev = stream->dev;
 467 
 468         spin_lock(&sdev->stream_list_lock);
 469         list_del(&stream->node);
 470         spin_unlock(&sdev->stream_list_lock);
 471 
 472         kfree(stream->name);
 473         kfree(stream);
 474 
 475         return 0;
 476 }
 477 EXPORT_SYMBOL_GPL(slim_stream_free);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/slimbus/stream.c

DEFINITIONS
