1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * hdac-ext-stream.c - HD-audio extended stream operations. 4 * 5 * Copyright (C) 2015 Intel Corp 6 * Author: Jeeja KP <jeeja.kp@intel.com> 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 10 */ 11 12 #include <linux/delay.h> 13 #include <linux/pci.h> 14 #include <linux/pci_ids.h> 15 #include <linux/slab.h> 16 #include <sound/pcm.h> 17 #include <sound/hda_register.h> 18 #include <sound/hdaudio_ext.h> 19 #include <sound/compress_driver.h> 20 21 /** 22 * snd_hdac_ext_host_stream_setup - Setup a HOST stream. 23 * @hext_stream: HDAudio stream to set up. 24 * @code_loading: Whether the stream is for PCM or code-loading. 25 * 26 * Return: Zero on success or negative error code. 27 */ 28 int snd_hdac_ext_host_stream_setup(struct hdac_ext_stream *hext_stream, bool code_loading) 29 { 30 return hext_stream->host_setup(hdac_stream(hext_stream), code_loading); 31 } 32 EXPORT_SYMBOL_GPL(snd_hdac_ext_host_stream_setup); 33 34 /** 35 * snd_hdac_apl_host_stream_setup - Setup a HOST stream following procedure 36 * recommended for ApolloLake devices. 37 * @hstream: HDAudio stream to set up. 38 * @code_loading: Whether the stream is for PCM or code-loading. 39 * 40 * Return: Zero on success or negative error code. 41 */ 42 static int snd_hdac_apl_host_stream_setup(struct hdac_stream *hstream, bool code_loading) 43 { 44 struct hdac_ext_stream *hext_stream = stream_to_hdac_ext_stream(hstream); 45 int ret; 46 47 snd_hdac_ext_stream_decouple(hstream->bus, hext_stream, false); 48 ret = snd_hdac_stream_setup(hstream, code_loading); 49 snd_hdac_ext_stream_decouple(hstream->bus, hext_stream, true); 50 51 return ret; 52 } 53 54 /** 55 * snd_hdac_ext_stream_init - initialize each stream (aka device) 56 * @bus: HD-audio core bus 57 * @hext_stream: HD-audio ext core stream object to initialize 58 * @idx: stream index number 59 * @direction: stream direction (SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE) 60 * @tag: the tag id to assign 61 * 62 * initialize the stream, if ppcap is enabled then init those and then 63 * invoke hdac stream initialization routine 64 */ 65 static void snd_hdac_ext_stream_init(struct hdac_bus *bus, 66 struct hdac_ext_stream *hext_stream, 67 int idx, int direction, int tag) 68 { 69 if (bus->ppcap) { 70 hext_stream->pphc_addr = bus->ppcap + AZX_PPHC_BASE + 71 AZX_PPHC_INTERVAL * idx; 72 73 hext_stream->pplc_addr = bus->ppcap + AZX_PPLC_BASE + 74 AZX_PPLC_MULTI * bus->num_streams + 75 AZX_PPLC_INTERVAL * idx; 76 } 77 78 hext_stream->decoupled = false; 79 snd_hdac_stream_init(bus, &hext_stream->hstream, idx, direction, tag); 80 } 81 82 /** 83 * snd_hdac_ext_stream_init_all - create and initialize the stream objects 84 * for an extended hda bus 85 * @bus: HD-audio core bus 86 * @start_idx: start index for streams 87 * @num_stream: number of streams to initialize 88 * @dir: direction of streams 89 */ 90 int snd_hdac_ext_stream_init_all(struct hdac_bus *bus, int start_idx, 91 int num_stream, int dir) 92 { 93 struct pci_dev *pci = to_pci_dev(bus->dev); 94 int (*setup_op)(struct hdac_stream *, bool); 95 int stream_tag = 0; 96 int i, tag, idx = start_idx; 97 98 if (pci->device == PCI_DEVICE_ID_INTEL_HDA_APL) 99 setup_op = snd_hdac_apl_host_stream_setup; 100 else 101 setup_op = snd_hdac_stream_setup; 102 103 for (i = 0; i < num_stream; i++) { 104 struct hdac_ext_stream *hext_stream = 105 kzalloc(sizeof(*hext_stream), GFP_KERNEL); 106 if (!hext_stream) 107 return -ENOMEM; 108 tag = ++stream_tag; 109 snd_hdac_ext_stream_init(bus, hext_stream, idx, dir, tag); 110 idx++; 111 hext_stream->host_setup = setup_op; 112 } 113 114 return 0; 115 116 } 117 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_init_all); 118 119 /** 120 * snd_hdac_ext_stream_free_all - free hdac extended stream objects 121 * 122 * @bus: HD-audio core bus 123 */ 124 void snd_hdac_ext_stream_free_all(struct hdac_bus *bus) 125 { 126 struct hdac_stream *s, *_s; 127 struct hdac_ext_stream *hext_stream; 128 129 list_for_each_entry_safe(s, _s, &bus->stream_list, list) { 130 hext_stream = stream_to_hdac_ext_stream(s); 131 snd_hdac_ext_stream_decouple(bus, hext_stream, false); 132 list_del(&s->list); 133 kfree(hext_stream); 134 } 135 } 136 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_free_all); 137 138 void snd_hdac_ext_stream_decouple_locked(struct hdac_bus *bus, 139 struct hdac_ext_stream *hext_stream, 140 bool decouple) 141 { 142 struct hdac_stream *hstream = &hext_stream->hstream; 143 u32 val; 144 int mask = AZX_PPCTL_PROCEN(hstream->index); 145 146 val = readw(bus->ppcap + AZX_REG_PP_PPCTL) & mask; 147 148 if (decouple && !val) 149 snd_hdac_updatel(bus->ppcap, AZX_REG_PP_PPCTL, mask, mask); 150 else if (!decouple && val) 151 snd_hdac_updatel(bus->ppcap, AZX_REG_PP_PPCTL, mask, 0); 152 153 hext_stream->decoupled = decouple; 154 } 155 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_decouple_locked); 156 157 /** 158 * snd_hdac_ext_stream_decouple - decouple the hdac stream 159 * @bus: HD-audio core bus 160 * @hext_stream: HD-audio ext core stream object to initialize 161 * @decouple: flag to decouple 162 */ 163 void snd_hdac_ext_stream_decouple(struct hdac_bus *bus, 164 struct hdac_ext_stream *hext_stream, bool decouple) 165 { 166 spin_lock_irq(&bus->reg_lock); 167 snd_hdac_ext_stream_decouple_locked(bus, hext_stream, decouple); 168 spin_unlock_irq(&bus->reg_lock); 169 } 170 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_decouple); 171 172 /** 173 * snd_hdac_ext_stream_start - start a stream 174 * @hext_stream: HD-audio ext core stream to start 175 */ 176 void snd_hdac_ext_stream_start(struct hdac_ext_stream *hext_stream) 177 { 178 snd_hdac_updatel(hext_stream->pplc_addr, AZX_REG_PPLCCTL, 179 AZX_PPLCCTL_RUN, AZX_PPLCCTL_RUN); 180 } 181 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_start); 182 183 /** 184 * snd_hdac_ext_stream_clear - stop a stream DMA 185 * @hext_stream: HD-audio ext core stream to stop 186 */ 187 void snd_hdac_ext_stream_clear(struct hdac_ext_stream *hext_stream) 188 { 189 snd_hdac_updatel(hext_stream->pplc_addr, AZX_REG_PPLCCTL, AZX_PPLCCTL_RUN, 0); 190 } 191 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_clear); 192 193 /** 194 * snd_hdac_ext_stream_reset - reset a stream 195 * @hext_stream: HD-audio ext core stream to reset 196 */ 197 void snd_hdac_ext_stream_reset(struct hdac_ext_stream *hext_stream) 198 { 199 unsigned char val; 200 int timeout; 201 202 snd_hdac_ext_stream_clear(hext_stream); 203 204 snd_hdac_updatel(hext_stream->pplc_addr, AZX_REG_PPLCCTL, 205 AZX_PPLCCTL_STRST, AZX_PPLCCTL_STRST); 206 udelay(3); 207 timeout = 50; 208 do { 209 val = readl(hext_stream->pplc_addr + AZX_REG_PPLCCTL) & 210 AZX_PPLCCTL_STRST; 211 if (val) 212 break; 213 udelay(3); 214 } while (--timeout); 215 val &= ~AZX_PPLCCTL_STRST; 216 writel(val, hext_stream->pplc_addr + AZX_REG_PPLCCTL); 217 udelay(3); 218 219 timeout = 50; 220 /* waiting for hardware to report that the stream is out of reset */ 221 do { 222 val = readl(hext_stream->pplc_addr + AZX_REG_PPLCCTL) & AZX_PPLCCTL_STRST; 223 if (!val) 224 break; 225 udelay(3); 226 } while (--timeout); 227 228 } 229 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_reset); 230 231 /** 232 * snd_hdac_ext_stream_setup - set up the SD for streaming 233 * @hext_stream: HD-audio ext core stream to set up 234 * @fmt: stream format 235 */ 236 int snd_hdac_ext_stream_setup(struct hdac_ext_stream *hext_stream, int fmt) 237 { 238 struct hdac_stream *hstream = &hext_stream->hstream; 239 unsigned int val; 240 241 /* make sure the run bit is zero for SD */ 242 snd_hdac_ext_stream_clear(hext_stream); 243 /* program the stream_tag */ 244 val = readl(hext_stream->pplc_addr + AZX_REG_PPLCCTL); 245 val = (val & ~AZX_PPLCCTL_STRM_MASK) | 246 (hstream->stream_tag << AZX_PPLCCTL_STRM_SHIFT); 247 writel(val, hext_stream->pplc_addr + AZX_REG_PPLCCTL); 248 249 /* program the stream format */ 250 writew(fmt, hext_stream->pplc_addr + AZX_REG_PPLCFMT); 251 252 return 0; 253 } 254 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_setup); 255 256 static struct hdac_ext_stream * 257 hdac_ext_link_dma_stream_assign(struct hdac_bus *bus, 258 struct snd_pcm_substream *substream) 259 { 260 struct hdac_ext_stream *res = NULL; 261 struct hdac_stream *hstream = NULL; 262 263 if (!bus->ppcap) { 264 dev_err(bus->dev, "stream type not supported\n"); 265 return NULL; 266 } 267 268 spin_lock_irq(&bus->reg_lock); 269 list_for_each_entry(hstream, &bus->stream_list, list) { 270 struct hdac_ext_stream *hext_stream = container_of(hstream, 271 struct hdac_ext_stream, 272 hstream); 273 if (hstream->direction != substream->stream) 274 continue; 275 276 /* check if link stream is available */ 277 if (!hext_stream->link_locked) { 278 res = hext_stream; 279 break; 280 } 281 282 } 283 if (res) { 284 snd_hdac_ext_stream_decouple_locked(bus, res, true); 285 res->link_locked = 1; 286 res->link_substream = substream; 287 } 288 spin_unlock_irq(&bus->reg_lock); 289 return res; 290 } 291 292 static struct hdac_ext_stream * 293 hdac_ext_host_dma_stream_assign(struct hdac_bus *bus, 294 struct snd_pcm_substream *substream) 295 { 296 struct hdac_ext_stream *res = NULL; 297 struct hdac_stream *hstream = NULL; 298 299 if (!bus->ppcap) { 300 dev_err(bus->dev, "stream type not supported\n"); 301 return NULL; 302 } 303 304 spin_lock_irq(&bus->reg_lock); 305 list_for_each_entry(hstream, &bus->stream_list, list) { 306 struct hdac_ext_stream *hext_stream = container_of(hstream, 307 struct hdac_ext_stream, 308 hstream); 309 if (hstream->direction != substream->stream) 310 continue; 311 312 if (!hstream->opened) { 313 res = hext_stream; 314 break; 315 } 316 } 317 if (res) { 318 snd_hdac_ext_stream_decouple_locked(bus, res, true); 319 res->hstream.opened = 1; 320 res->hstream.running = 0; 321 res->hstream.substream = substream; 322 } 323 spin_unlock_irq(&bus->reg_lock); 324 325 return res; 326 } 327 328 /** 329 * snd_hdac_ext_stream_assign - assign a stream for the PCM 330 * @bus: HD-audio core bus 331 * @substream: PCM substream to assign 332 * @type: type of stream (coupled, host or link stream) 333 * 334 * This assigns the stream based on the type (coupled/host/link), for the 335 * given PCM substream, assigns it and returns the stream object 336 * 337 * coupled: Looks for an unused stream 338 * host: Looks for an unused decoupled host stream 339 * link: Looks for an unused decoupled link stream 340 * 341 * If no stream is free, returns NULL. The function tries to keep using 342 * the same stream object when it's used beforehand. when a stream is 343 * decoupled, it becomes a host stream and link stream. 344 */ 345 struct hdac_ext_stream *snd_hdac_ext_stream_assign(struct hdac_bus *bus, 346 struct snd_pcm_substream *substream, 347 int type) 348 { 349 struct hdac_ext_stream *hext_stream = NULL; 350 struct hdac_stream *hstream = NULL; 351 352 switch (type) { 353 case HDAC_EXT_STREAM_TYPE_COUPLED: 354 hstream = snd_hdac_stream_assign(bus, substream); 355 if (hstream) 356 hext_stream = container_of(hstream, 357 struct hdac_ext_stream, 358 hstream); 359 return hext_stream; 360 361 case HDAC_EXT_STREAM_TYPE_HOST: 362 return hdac_ext_host_dma_stream_assign(bus, substream); 363 364 case HDAC_EXT_STREAM_TYPE_LINK: 365 return hdac_ext_link_dma_stream_assign(bus, substream); 366 367 default: 368 return NULL; 369 } 370 } 371 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_assign); 372 373 /** 374 * snd_hdac_ext_stream_release - release the assigned stream 375 * @hext_stream: HD-audio ext core stream to release 376 * @type: type of stream (coupled, host or link stream) 377 * 378 * Release the stream that has been assigned by snd_hdac_ext_stream_assign(). 379 */ 380 void snd_hdac_ext_stream_release(struct hdac_ext_stream *hext_stream, int type) 381 { 382 struct hdac_bus *bus = hext_stream->hstream.bus; 383 384 switch (type) { 385 case HDAC_EXT_STREAM_TYPE_COUPLED: 386 snd_hdac_stream_release(&hext_stream->hstream); 387 break; 388 389 case HDAC_EXT_STREAM_TYPE_HOST: 390 spin_lock_irq(&bus->reg_lock); 391 /* couple link only if not in use */ 392 if (!hext_stream->link_locked) 393 snd_hdac_ext_stream_decouple_locked(bus, hext_stream, false); 394 snd_hdac_stream_release_locked(&hext_stream->hstream); 395 spin_unlock_irq(&bus->reg_lock); 396 break; 397 398 case HDAC_EXT_STREAM_TYPE_LINK: 399 spin_lock_irq(&bus->reg_lock); 400 /* couple host only if not in use */ 401 if (!hext_stream->hstream.opened) 402 snd_hdac_ext_stream_decouple_locked(bus, hext_stream, false); 403 hext_stream->link_locked = 0; 404 hext_stream->link_substream = NULL; 405 spin_unlock_irq(&bus->reg_lock); 406 break; 407 408 default: 409 dev_dbg(bus->dev, "Invalid type %d\n", type); 410 } 411 412 } 413 EXPORT_SYMBOL_GPL(snd_hdac_ext_stream_release); 414 415 /** 416 * snd_hdac_ext_cstream_assign - assign a host stream for compress 417 * @bus: HD-audio core bus 418 * @cstream: Compress stream to assign 419 * 420 * Assign an unused host stream for the given compress stream. 421 * If no stream is free, NULL is returned. Stream is decoupled 422 * before assignment. 423 */ 424 struct hdac_ext_stream *snd_hdac_ext_cstream_assign(struct hdac_bus *bus, 425 struct snd_compr_stream *cstream) 426 { 427 struct hdac_ext_stream *res = NULL; 428 struct hdac_stream *hstream; 429 430 spin_lock_irq(&bus->reg_lock); 431 list_for_each_entry(hstream, &bus->stream_list, list) { 432 struct hdac_ext_stream *hext_stream = stream_to_hdac_ext_stream(hstream); 433 434 if (hstream->direction != cstream->direction) 435 continue; 436 437 if (!hstream->opened) { 438 res = hext_stream; 439 break; 440 } 441 } 442 443 if (res) { 444 snd_hdac_ext_stream_decouple_locked(bus, res, true); 445 res->hstream.opened = 1; 446 res->hstream.running = 0; 447 res->hstream.cstream = cstream; 448 } 449 spin_unlock_irq(&bus->reg_lock); 450 451 return res; 452 } 453 EXPORT_SYMBOL_GPL(snd_hdac_ext_cstream_assign); 454