sound/soc/sof/intel/atom.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
   2 //
   3 // This file is provided under a dual BSD/GPLv2 license.  When using or
   4 // redistributing this file, you may do so under either license.
   5 //
   6 // Copyright(c) 2018-2021 Intel Corporation. All rights reserved.
   7 //
   8 // Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
   9 //
  10
  11 /*
  12  * Hardware interface for audio DSP on Atom devices
  13  */
  14
  15 #include <linux/module.h>
  16 #include <sound/sof.h>
  17 #include <sound/sof/xtensa.h>
  18 #include <sound/soc-acpi.h>
  19 #include <sound/soc-acpi-intel-match.h>
  20 #include <sound/intel-dsp-config.h>
  21 #include "../ops.h"
  22 #include "shim.h"
  23 #include "atom.h"
  24 #include "../sof-acpi-dev.h"
  25 #include "../sof-audio.h"
  26 #include "../../intel/common/soc-intel-quirks.h"
  27
  28 static void atom_host_done(struct snd_sof_dev *sdev);
  29 static void atom_dsp_done(struct snd_sof_dev *sdev);
  30
  31 /*
  32  * Debug
  33  */
  34
  35 static void atom_get_registers(struct snd_sof_dev *sdev,
  36                                struct sof_ipc_dsp_oops_xtensa *xoops,
  37                                struct sof_ipc_panic_info *panic_info,
  38                                u32 *stack, size_t stack_words)
  39 {
  40         u32 offset = sdev->dsp_oops_offset;
  41
  42         /* first read regsisters */
  43         sof_mailbox_read(sdev, offset, xoops, sizeof(*xoops));
  44
  45         /* note: variable AR register array is not read */
  46
  47         /* then get panic info */
  48         if (xoops->arch_hdr.totalsize > EXCEPT_MAX_HDR_SIZE) {
  49                 dev_err(sdev->dev, "invalid header size 0x%x. FW oops is bogus\n",
  50                         xoops->arch_hdr.totalsize);
  51                 return;
  52         }
  53         offset += xoops->arch_hdr.totalsize;
  54         sof_mailbox_read(sdev, offset, panic_info, sizeof(*panic_info));
  55
  56         /* then get the stack */
  57         offset += sizeof(*panic_info);
  58         sof_mailbox_read(sdev, offset, stack, stack_words * sizeof(u32));
  59 }
  60
  61 void atom_dump(struct snd_sof_dev *sdev, u32 flags)
  62 {
  63         struct sof_ipc_dsp_oops_xtensa xoops;
  64         struct sof_ipc_panic_info panic_info;
  65         u32 stack[STACK_DUMP_SIZE];
  66         u64 status, panic, imrd, imrx;
  67
  68         /* now try generic SOF status messages */
  69         status = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCD);
  70         panic = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCX);
  71         atom_get_registers(sdev, &xoops, &panic_info, stack,
  72                            STACK_DUMP_SIZE);
  73         sof_print_oops_and_stack(sdev, KERN_ERR, status, panic, &xoops,
  74                                  &panic_info, stack, STACK_DUMP_SIZE);
  75
  76         /* provide some context for firmware debug */
  77         imrx = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IMRX);
  78         imrd = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IMRD);
  79         dev_err(sdev->dev,
  80                 "error: ipc host -> DSP: pending %s complete %s raw 0x%llx\n",
  81                 (panic & SHIM_IPCX_BUSY) ? "yes" : "no",
  82                 (panic & SHIM_IPCX_DONE) ? "yes" : "no", panic);
  83         dev_err(sdev->dev,
  84                 "error: mask host: pending %s complete %s raw 0x%llx\n",
  85                 (imrx & SHIM_IMRX_BUSY) ? "yes" : "no",
  86                 (imrx & SHIM_IMRX_DONE) ? "yes" : "no", imrx);
  87         dev_err(sdev->dev,
  88                 "error: ipc DSP -> host: pending %s complete %s raw 0x%llx\n",
  89                 (status & SHIM_IPCD_BUSY) ? "yes" : "no",
  90                 (status & SHIM_IPCD_DONE) ? "yes" : "no", status);
  91         dev_err(sdev->dev,
  92                 "error: mask DSP: pending %s complete %s raw 0x%llx\n",
  93                 (imrd & SHIM_IMRD_BUSY) ? "yes" : "no",
  94                 (imrd & SHIM_IMRD_DONE) ? "yes" : "no", imrd);
  95
  96 }
  97 EXPORT_SYMBOL_NS(atom_dump, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
  98
  99 /*
 100  * IPC Doorbell IRQ handler and thread.
 101  */
 102
 103 irqreturn_t atom_irq_handler(int irq, void *context)
 104 {
 105         struct snd_sof_dev *sdev = context;
 106         u64 ipcx, ipcd;
 107         int ret = IRQ_NONE;
 108
 109         ipcx = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCX);
 110         ipcd = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCD);
 111
 112         if (ipcx & SHIM_BYT_IPCX_DONE) {
 113
 114                 /* reply message from DSP, Mask Done interrupt first */
 115                 snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR,
 116                                                    SHIM_IMRX,
 117                                                    SHIM_IMRX_DONE,
 118                                                    SHIM_IMRX_DONE);
 119                 ret = IRQ_WAKE_THREAD;
 120         }
 121
 122         if (ipcd & SHIM_BYT_IPCD_BUSY) {
 123
 124                 /* new message from DSP, Mask Busy interrupt first */
 125                 snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR,
 126                                                    SHIM_IMRX,
 127                                                    SHIM_IMRX_BUSY,
 128                                                    SHIM_IMRX_BUSY);
 129                 ret = IRQ_WAKE_THREAD;
 130         }
 131
 132         return ret;
 133 }
 134 EXPORT_SYMBOL_NS(atom_irq_handler, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
 135
 136 irqreturn_t atom_irq_thread(int irq, void *context)
 137 {
 138         struct snd_sof_dev *sdev = context;
 139         u64 ipcx, ipcd;
 140
 141         ipcx = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCX);
 142         ipcd = snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_IPCD);
 143
 144         /* reply message from DSP */
 145         if (ipcx & SHIM_BYT_IPCX_DONE) {
 146
 147                 spin_lock_irq(&sdev->ipc_lock);
 148
 149                 /*
 150                  * handle immediate reply from DSP core. If the msg is
 151                  * found, set done bit in cmd_done which is called at the
 152                  * end of message processing function, else set it here
 153                  * because the done bit can't be set in cmd_done function
 154                  * which is triggered by msg
 155                  */
 156                 snd_sof_ipc_process_reply(sdev, ipcx);
 157
 158                 atom_dsp_done(sdev);
 159
 160                 spin_unlock_irq(&sdev->ipc_lock);
 161         }
 162
 163         /* new message from DSP */
 164         if (ipcd & SHIM_BYT_IPCD_BUSY) {
 165
 166                 /* Handle messages from DSP Core */
 167                 if ((ipcd & SOF_IPC_PANIC_MAGIC_MASK) == SOF_IPC_PANIC_MAGIC) {
 168                         snd_sof_dsp_panic(sdev, PANIC_OFFSET(ipcd) + MBOX_OFFSET,
 169                                           true);
 170                 } else {
 171                         snd_sof_ipc_msgs_rx(sdev);
 172                 }
 173
 174                 atom_host_done(sdev);
 175         }
 176
 177         return IRQ_HANDLED;
 178 }
 179 EXPORT_SYMBOL_NS(atom_irq_thread, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
 180
 181 int atom_send_msg(struct snd_sof_dev *sdev, struct snd_sof_ipc_msg *msg)
 182 {
 183         /* unmask and prepare to receive Done interrupt */
 184         snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR, SHIM_IMRX,
 185                                            SHIM_IMRX_DONE, 0);
 186
 187         /* send the message */
 188         sof_mailbox_write(sdev, sdev->host_box.offset, msg->msg_data,
 189                           msg->msg_size);
 190         snd_sof_dsp_write64(sdev, DSP_BAR, SHIM_IPCX, SHIM_BYT_IPCX_BUSY);
 191
 192         return 0;
 193 }
 194 EXPORT_SYMBOL_NS(atom_send_msg, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
 195
 196 int atom_get_mailbox_offset(struct snd_sof_dev *sdev)
 197 {
 198         return MBOX_OFFSET;
 199 }
 200 EXPORT_SYMBOL_NS(atom_get_mailbox_offset, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
 201
 202 int atom_get_window_offset(struct snd_sof_dev *sdev, u32 id)
 203 {
 204         return MBOX_OFFSET;
 205 }
 206 EXPORT_SYMBOL_NS(atom_get_window_offset, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
 207
 208 static void atom_host_done(struct snd_sof_dev *sdev)
 209 {
 210         /* clear BUSY bit and set DONE bit - accept new messages */
 211         snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR, SHIM_IPCD,
 212                                            SHIM_BYT_IPCD_BUSY |
 213                                            SHIM_BYT_IPCD_DONE,
 214                                            SHIM_BYT_IPCD_DONE);
 215
 216         /* unmask and prepare to receive next new message */
 217         snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR, SHIM_IMRX,
 218                                            SHIM_IMRX_BUSY, 0);
 219 }
 220
 221 static void atom_dsp_done(struct snd_sof_dev *sdev)
 222 {
 223         /* clear DONE bit - tell DSP we have completed */
 224         snd_sof_dsp_update_bits64_unlocked(sdev, DSP_BAR, SHIM_IPCX,
 225                                            SHIM_BYT_IPCX_DONE, 0);
 226 }
 227
 228 /*
 229  * DSP control.
 230  */
 231
 232 int atom_run(struct snd_sof_dev *sdev)
 233 {
 234         int tries = 10;
 235
 236         /* release stall and wait to unstall */
 237         snd_sof_dsp_update_bits64(sdev, DSP_BAR, SHIM_CSR,
 238                                   SHIM_BYT_CSR_STALL, 0x0);
 239         while (tries--) {
 240                 if (!(snd_sof_dsp_read64(sdev, DSP_BAR, SHIM_CSR) &
 241                       SHIM_BYT_CSR_PWAITMODE))
 242                         break;
 243                 msleep(100);
 244         }
 245         if (tries < 0)
 246                 return -ENODEV;
 247
 248         /* return init core mask */
 249         return 1;
 250 }
 251 EXPORT_SYMBOL_NS(atom_run, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
 252
 253 int atom_reset(struct snd_sof_dev *sdev)
 254 {
 255         /* put DSP into reset, set reset vector and stall */
 256         snd_sof_dsp_update_bits64(sdev, DSP_BAR, SHIM_CSR,
 257                                   SHIM_BYT_CSR_RST | SHIM_BYT_CSR_VECTOR_SEL |
 258                                   SHIM_BYT_CSR_STALL,
 259                                   SHIM_BYT_CSR_RST | SHIM_BYT_CSR_VECTOR_SEL |
 260                                   SHIM_BYT_CSR_STALL);
 261
 262         usleep_range(10, 15);
 263
 264         /* take DSP out of reset and keep stalled for FW loading */
 265         snd_sof_dsp_update_bits64(sdev, DSP_BAR, SHIM_CSR,
 266                                   SHIM_BYT_CSR_RST, 0);
 267
 268         return 0;
 269 }
 270 EXPORT_SYMBOL_NS(atom_reset, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
 271
 272 static const char *fixup_tplg_name(struct snd_sof_dev *sdev,
 273                                    const char *sof_tplg_filename,
 274                                    const char *ssp_str)
 275 {
 276         const char *tplg_filename = NULL;
 277         char *filename;
 278         char *split_ext;
 279
 280         filename = devm_kstrdup(sdev->dev, sof_tplg_filename, GFP_KERNEL);
 281         if (!filename)
 282                 return NULL;
 283
 284         /* this assumes a .tplg extension */
 285         split_ext = strsep(&filename, ".");
 286         if (split_ext) {
 287                 tplg_filename = devm_kasprintf(sdev->dev, GFP_KERNEL,
 288                                                "%s-%s.tplg",
 289                                                split_ext, ssp_str);
 290                 if (!tplg_filename)
 291                         return NULL;
 292         }
 293         return tplg_filename;
 294 }
 295
 296 struct snd_soc_acpi_mach *atom_machine_select(struct snd_sof_dev *sdev)
 297 {
 298         struct snd_sof_pdata *sof_pdata = sdev->pdata;
 299         const struct sof_dev_desc *desc = sof_pdata->desc;
 300         struct snd_soc_acpi_mach *mach;
 301         struct platform_device *pdev;
 302         const char *tplg_filename;
 303
 304         mach = snd_soc_acpi_find_machine(desc->machines);
 305         if (!mach) {
 306                 dev_warn(sdev->dev, "warning: No matching ASoC machine driver found\n");
 307                 return NULL;
 308         }
 309
 310         pdev = to_platform_device(sdev->dev);
 311         if (soc_intel_is_byt_cr(pdev)) {
 312                 dev_dbg(sdev->dev,
 313                         "BYT-CR detected, SSP0 used instead of SSP2\n");
 314
 315                 tplg_filename = fixup_tplg_name(sdev,
 316                                                 mach->sof_tplg_filename,
 317                                                 "ssp0");
 318         } else {
 319                 tplg_filename = mach->sof_tplg_filename;
 320         }
 321
 322         if (!tplg_filename) {
 323                 dev_dbg(sdev->dev,
 324                         "error: no topology filename\n");
 325                 return NULL;
 326         }
 327
 328         sof_pdata->tplg_filename = tplg_filename;
 329         mach->mach_params.acpi_ipc_irq_index = desc->irqindex_host_ipc;
 330
 331         return mach;
 332 }
 333 EXPORT_SYMBOL_NS(atom_machine_select, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
 334
 335 /* Atom DAIs */
 336 struct snd_soc_dai_driver atom_dai[] = {
 337 {
 338         .name = "ssp0-port",
 339         .playback = {
 340                 .channels_min = 1,
 341                 .channels_max = 8,
 342         },
 343         .capture = {
 344                 .channels_min = 1,
 345                 .channels_max = 8,
 346         },
 347 },
 348 {
 349         .name = "ssp1-port",
 350         .playback = {
 351                 .channels_min = 1,
 352                 .channels_max = 8,
 353         },
 354         .capture = {
 355                 .channels_min = 1,
 356                 .channels_max = 8,
 357         },
 358 },
 359 {
 360         .name = "ssp2-port",
 361         .playback = {
 362                 .channels_min = 1,
 363                 .channels_max = 8,
 364         },
 365         .capture = {
 366                 .channels_min = 1,
 367                 .channels_max = 8,
 368         }
 369 },
 370 {
 371         .name = "ssp3-port",
 372         .playback = {
 373                 .channels_min = 1,
 374                 .channels_max = 8,
 375         },
 376         .capture = {
 377                 .channels_min = 1,
 378                 .channels_max = 8,
 379         },
 380 },
 381 {
 382         .name = "ssp4-port",
 383         .playback = {
 384                 .channels_min = 1,
 385                 .channels_max = 8,
 386         },
 387         .capture = {
 388                 .channels_min = 1,
 389                 .channels_max = 8,
 390         },
 391 },
 392 {
 393         .name = "ssp5-port",
 394         .playback = {
 395                 .channels_min = 1,
 396                 .channels_max = 8,
 397         },
 398         .capture = {
 399                 .channels_min = 1,
 400                 .channels_max = 8,
 401         },
 402 },
 403 };
 404 EXPORT_SYMBOL_NS(atom_dai, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
 405
 406 void atom_set_mach_params(struct snd_soc_acpi_mach *mach,
 407                           struct snd_sof_dev *sdev)
 408 {
 409         struct snd_sof_pdata *pdata = sdev->pdata;
 410         const struct sof_dev_desc *desc = pdata->desc;
 411         struct snd_soc_acpi_mach_params *mach_params;
 412
 413         mach_params = &mach->mach_params;
 414         mach_params->platform = dev_name(sdev->dev);
 415         mach_params->num_dai_drivers = desc->ops->num_drv;
 416         mach_params->dai_drivers = desc->ops->drv;
 417 }
 418 EXPORT_SYMBOL_NS(atom_set_mach_params, SND_SOC_SOF_INTEL_ATOM_HIFI_EP);
 419
 420 MODULE_LICENSE("Dual BSD/GPL");