drivers/slimbus/stream.c

   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         11025,
  71         22050,
  72         44100,
  73         88200,
  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, prrate;
 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         prrate = slim_get_prate_code(cfg->rate);
 225         if (prrate < 0) {
 226                 dev_err(&rt->dev->dev, "Cannot get presence rate for rate %d Hz\n",
 227                         cfg->rate);
 228                 return prrate;
 229         }
 230
 231         if (cfg->rate % ctrl->a_framer->superfreq) {
 232                 /*
 233                  * data rate not exactly multiple of super frame,
 234                  * use PUSH/PULL protocol
 235                  */
 236                 if (cfg->direction == SNDRV_PCM_STREAM_PLAYBACK)
 237                         rt->prot = SLIM_PROTO_PUSH;
 238                 else
 239                         rt->prot = SLIM_PROTO_PULL;
 240         } else {
 241                 rt->prot = SLIM_PROTO_ISO;
 242         }
 243
 244         rt->ratem = cfg->rate/ctrl->a_framer->superfreq;
 245
 246         i = 0;
 247         for_each_set_bit(port_id, &cfg->port_mask, SLIM_DEVICE_MAX_PORTS) {
 248                 port = &rt->ports[i];
 249                 port->state = SLIM_PORT_DISCONNECTED;
 250                 port->id = port_id;
 251                 port->ch.prrate = prrate;
 252                 port->ch.id = cfg->chs[i];
 253                 port->ch.data_fmt = SLIM_CH_DATA_FMT_NOT_DEFINED;
 254                 port->ch.aux_fmt = SLIM_CH_AUX_FMT_NOT_APPLICABLE;
 255                 port->ch.state = SLIM_CH_STATE_ALLOCATED;
 256
 257                 if (cfg->direction == SNDRV_PCM_STREAM_PLAYBACK)
 258                         port->direction = SLIM_PORT_SINK;
 259                 else
 260                         port->direction = SLIM_PORT_SOURCE;
 261
 262                 slim_connect_port_channel(rt, port);
 263                 i++;
 264         }
 265
 266         return 0;
 267 }
 268 EXPORT_SYMBOL_GPL(slim_stream_prepare);
 269
 270 static int slim_define_channel_content(struct slim_stream_runtime *stream,
 271                                        struct slim_port *port)
 272 {
 273         struct slim_device *sdev = stream->dev;
 274         u8 wbuf[4];
 275         struct slim_val_inf msg = {0, 4, NULL, wbuf, NULL};
 276         u8 mc = SLIM_MSG_MC_NEXT_DEFINE_CONTENT;
 277         DEFINE_SLIM_LDEST_TXN(txn, mc, 8, stream->dev->laddr, &msg);
 278
 279         wbuf[0] = port->ch.id;
 280         wbuf[1] = port->ch.prrate;
 281
 282         /* Frequency Locked for ISO Protocol */
 283         if (stream->prot != SLIM_PROTO_ISO)
 284                 wbuf[1] |= SLIM_CHANNEL_CONTENT_FL;
 285
 286         wbuf[2] = port->ch.data_fmt | (port->ch.aux_fmt << 4);
 287         wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS;
 288         port->ch.state = SLIM_CH_STATE_CONTENT_DEFINED;
 289
 290         return slim_do_transfer(sdev->ctrl, &txn);
 291 }
 292
 293 static int slim_get_segdist_code(int ratem)
 294 {
 295         int i;
 296
 297         for (i = 0; i < ARRAY_SIZE(segdist_codes); i++) {
 298                 if (segdist_codes[i].ratem == ratem)
 299                         return segdist_codes[i].segdist_code;
 300         }
 301
 302         return -EINVAL;
 303 }
 304
 305 static int slim_define_channel(struct slim_stream_runtime *stream,
 306                                        struct slim_port *port)
 307 {
 308         struct slim_device *sdev = stream->dev;
 309         u8 wbuf[4];
 310         struct slim_val_inf msg = {0, 4, NULL, wbuf, NULL};
 311         u8 mc = SLIM_MSG_MC_NEXT_DEFINE_CHANNEL;
 312         DEFINE_SLIM_LDEST_TXN(txn, mc, 8, stream->dev->laddr, &msg);
 313
 314         port->ch.seg_dist = slim_get_segdist_code(stream->ratem);
 315
 316         wbuf[0] = port->ch.id;
 317         wbuf[1] = port->ch.seg_dist & 0xFF;
 318         wbuf[2] = (stream->prot << 4) | ((port->ch.seg_dist & 0xF00) >> 8);
 319         if (stream->prot == SLIM_PROTO_ISO)
 320                 wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS;
 321         else
 322                 wbuf[3] = stream->bps/SLIM_SLOT_LEN_BITS + 1;
 323
 324         port->ch.state = SLIM_CH_STATE_DEFINED;
 325
 326         return slim_do_transfer(sdev->ctrl, &txn);
 327 }
 328
 329 static int slim_activate_channel(struct slim_stream_runtime *stream,
 330                                  struct slim_port *port)
 331 {
 332         struct slim_device *sdev = stream->dev;
 333         u8 wbuf[1];
 334         struct slim_val_inf msg = {0, 1, NULL, wbuf, NULL};
 335         u8 mc = SLIM_MSG_MC_NEXT_ACTIVATE_CHANNEL;
 336         DEFINE_SLIM_LDEST_TXN(txn, mc, 5, stream->dev->laddr, &msg);
 337
 338         txn.msg->num_bytes = 1;
 339         txn.msg->wbuf = wbuf;
 340         wbuf[0] = port->ch.id;
 341         port->ch.state = SLIM_CH_STATE_ACTIVE;
 342
 343         return slim_do_transfer(sdev->ctrl, &txn);
 344 }
 345
 346 /**
 347  * slim_stream_enable() - Enable a prepared SLIMbus Stream
 348  *
 349  * @stream: instance of slim stream runtime to enable
 350  *
 351  * This API will enable all the ports and channels associated with
 352  * SLIMbus stream
 353  *
 354  * Return: zero on success and error code on failure. From ASoC DPCM framework,
 355  * this state is linked to trigger() start operation.
 356  */
 357 int slim_stream_enable(struct slim_stream_runtime *stream)
 358 {
 359         DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION,
 360                                 3, SLIM_LA_MANAGER, NULL);
 361         struct slim_controller *ctrl = stream->dev->ctrl;
 362         int ret, i;
 363
 364         if (ctrl->enable_stream) {
 365                 ret = ctrl->enable_stream(stream);
 366                 if (ret)
 367                         return ret;
 368
 369                 for (i = 0; i < stream->num_ports; i++)
 370                         stream->ports[i].ch.state = SLIM_CH_STATE_ACTIVE;
 371
 372                 return ret;
 373         }
 374
 375         ret = slim_do_transfer(ctrl, &txn);
 376         if (ret)
 377                 return ret;
 378
 379         /* define channels first before activating them */
 380         for (i = 0; i < stream->num_ports; i++) {
 381                 struct slim_port *port = &stream->ports[i];
 382
 383                 slim_define_channel(stream, port);
 384                 slim_define_channel_content(stream, port);
 385         }
 386
 387         for (i = 0; i < stream->num_ports; i++) {
 388                 struct slim_port *port = &stream->ports[i];
 389
 390                 slim_activate_channel(stream, port);
 391                 port->state = SLIM_PORT_CONFIGURED;
 392         }
 393         txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW;
 394
 395         return slim_do_transfer(ctrl, &txn);
 396 }
 397 EXPORT_SYMBOL_GPL(slim_stream_enable);
 398
 399 /**
 400  * slim_stream_disable() - Disable a SLIMbus Stream
 401  *
 402  * @stream: instance of slim stream runtime to disable
 403  *
 404  * This API will disable all the ports and channels associated with
 405  * SLIMbus stream
 406  *
 407  * Return: zero on success and error code on failure. From ASoC DPCM framework,
 408  * this state is linked to trigger() pause operation.
 409  */
 410 int slim_stream_disable(struct slim_stream_runtime *stream)
 411 {
 412         DEFINE_SLIM_BCAST_TXN(txn, SLIM_MSG_MC_BEGIN_RECONFIGURATION,
 413                                 3, SLIM_LA_MANAGER, NULL);
 414         struct slim_controller *ctrl = stream->dev->ctrl;
 415         int ret, i;
 416
 417         if (!stream->ports || !stream->num_ports)
 418                 return -EINVAL;
 419
 420         if (ctrl->disable_stream)
 421                 ctrl->disable_stream(stream);
 422
 423         ret = slim_do_transfer(ctrl, &txn);
 424         if (ret)
 425                 return ret;
 426
 427         for (i = 0; i < stream->num_ports; i++)
 428                 slim_deactivate_remove_channel(stream, &stream->ports[i]);
 429
 430         txn.mc = SLIM_MSG_MC_RECONFIGURE_NOW;
 431
 432         return slim_do_transfer(ctrl, &txn);
 433 }
 434 EXPORT_SYMBOL_GPL(slim_stream_disable);
 435
 436 /**
 437  * slim_stream_unprepare() - Un-prepare a SLIMbus Stream
 438  *
 439  * @stream: instance of slim stream runtime to unprepare
 440  *
 441  * This API will un allocate all the ports and channels associated with
 442  * SLIMbus stream
 443  *
 444  * Return: zero on success and error code on failure. From ASoC DPCM framework,
 445  * this state is linked to trigger() stop operation.
 446  */
 447 int slim_stream_unprepare(struct slim_stream_runtime *stream)
 448 {
 449         int i;
 450
 451         if (!stream->ports || !stream->num_ports)
 452                 return -EINVAL;
 453
 454         for (i = 0; i < stream->num_ports; i++)
 455                 slim_disconnect_port(stream, &stream->ports[i]);
 456
 457         kfree(stream->ports);
 458         stream->ports = NULL;
 459         stream->num_ports = 0;
 460
 461         return 0;
 462 }
 463 EXPORT_SYMBOL_GPL(slim_stream_unprepare);
 464
 465 /**
 466  * slim_stream_free() - Free a SLIMbus Stream
 467  *
 468  * @stream: instance of slim stream runtime to free
 469  *
 470  * This API will un allocate all the memory associated with
 471  * slim stream runtime, user is not allowed to make an dereference
 472  * to stream after this call.
 473  *
 474  * Return: zero on success and error code on failure. From ASoC DPCM framework,
 475  * this state is linked to shutdown() operation.
 476  */
 477 int slim_stream_free(struct slim_stream_runtime *stream)
 478 {
 479         struct slim_device *sdev = stream->dev;
 480
 481         spin_lock(&sdev->stream_list_lock);
 482         list_del(&stream->node);
 483         spin_unlock(&sdev->stream_list_lock);
 484
 485         kfree(stream->name);
 486         kfree(stream);
 487
 488         return 0;
 489 }
 490 EXPORT_SYMBOL_GPL(slim_stream_free);