sound/soc/intel/sst-dsp.c

   1 /*
   2  * Intel Smart Sound Technology (SST) DSP Core Driver
   3  *
   4  * Copyright (C) 2013, Intel Corporation. All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License version
   8  * 2 as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  */
  16
  17 #include <linux/slab.h>
  18 #include <linux/export.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/module.h>
  21 #include <linux/platform_device.h>
  22
  23 #include "sst-dsp.h"
  24 #include "sst-dsp-priv.h"
  25
  26 #define CREATE_TRACE_POINTS
  27 #include <trace/events/intel-sst.h>
  28
  29 /* Public API */
  30 void sst_dsp_shim_write(struct sst_dsp *sst, u32 offset, u32 value)
  31 {
  32         unsigned long flags;
  33
  34         spin_lock_irqsave(&sst->spinlock, flags);
  35         sst->ops->write(sst->addr.shim, offset, value);
  36         spin_unlock_irqrestore(&sst->spinlock, flags);
  37 }
  38 EXPORT_SYMBOL_GPL(sst_dsp_shim_write);
  39
  40 u32 sst_dsp_shim_read(struct sst_dsp *sst, u32 offset)
  41 {
  42         unsigned long flags;
  43         u32 val;
  44
  45         spin_lock_irqsave(&sst->spinlock, flags);
  46         val = sst->ops->read(sst->addr.shim, offset);
  47         spin_unlock_irqrestore(&sst->spinlock, flags);
  48
  49         return val;
  50 }
  51 EXPORT_SYMBOL_GPL(sst_dsp_shim_read);
  52
  53 void sst_dsp_shim_write64(struct sst_dsp *sst, u32 offset, u64 value)
  54 {
  55         unsigned long flags;
  56
  57         spin_lock_irqsave(&sst->spinlock, flags);
  58         sst->ops->write64(sst->addr.shim, offset, value);
  59         spin_unlock_irqrestore(&sst->spinlock, flags);
  60 }
  61 EXPORT_SYMBOL_GPL(sst_dsp_shim_write64);
  62
  63 u64 sst_dsp_shim_read64(struct sst_dsp *sst, u32 offset)
  64 {
  65         unsigned long flags;
  66         u64 val;
  67
  68         spin_lock_irqsave(&sst->spinlock, flags);
  69         val = sst->ops->read64(sst->addr.shim, offset);
  70         spin_unlock_irqrestore(&sst->spinlock, flags);
  71
  72         return val;
  73 }
  74 EXPORT_SYMBOL_GPL(sst_dsp_shim_read64);
  75
  76 void sst_dsp_shim_write_unlocked(struct sst_dsp *sst, u32 offset, u32 value)
  77 {
  78         sst->ops->write(sst->addr.shim, offset, value);
  79 }
  80 EXPORT_SYMBOL_GPL(sst_dsp_shim_write_unlocked);
  81
  82 u32 sst_dsp_shim_read_unlocked(struct sst_dsp *sst, u32 offset)
  83 {
  84         return sst->ops->read(sst->addr.shim, offset);
  85 }
  86 EXPORT_SYMBOL_GPL(sst_dsp_shim_read_unlocked);
  87
  88 void sst_dsp_shim_write64_unlocked(struct sst_dsp *sst, u32 offset, u64 value)
  89 {
  90         sst->ops->write64(sst->addr.shim, offset, value);
  91 }
  92 EXPORT_SYMBOL_GPL(sst_dsp_shim_write64_unlocked);
  93
  94 u64 sst_dsp_shim_read64_unlocked(struct sst_dsp *sst, u32 offset)
  95 {
  96         return sst->ops->read64(sst->addr.shim, offset);
  97 }
  98 EXPORT_SYMBOL_GPL(sst_dsp_shim_read64_unlocked);
  99
 100 int sst_dsp_shim_update_bits_unlocked(struct sst_dsp *sst, u32 offset,
 101                                 u32 mask, u32 value)
 102 {
 103         bool change;
 104         unsigned int old, new;
 105         u32 ret;
 106
 107         ret = sst_dsp_shim_read_unlocked(sst, offset);
 108
 109         old = ret;
 110         new = (old & (~mask)) | (value & mask);
 111
 112         change = (old != new);
 113         if (change)
 114                 sst_dsp_shim_write_unlocked(sst, offset, new);
 115
 116         return change;
 117 }
 118 EXPORT_SYMBOL_GPL(sst_dsp_shim_update_bits_unlocked);
 119
 120 int sst_dsp_shim_update_bits64_unlocked(struct sst_dsp *sst, u32 offset,
 121                                 u64 mask, u64 value)
 122 {
 123         bool change;
 124         u64 old, new;
 125
 126         old = sst_dsp_shim_read64_unlocked(sst, offset);
 127
 128         new = (old & (~mask)) | (value & mask);
 129
 130         change = (old != new);
 131         if (change)
 132                 sst_dsp_shim_write64_unlocked(sst, offset, new);
 133
 134         return change;
 135 }
 136 EXPORT_SYMBOL_GPL(sst_dsp_shim_update_bits64_unlocked);
 137
 138 int sst_dsp_shim_update_bits(struct sst_dsp *sst, u32 offset,
 139                                 u32 mask, u32 value)
 140 {
 141         unsigned long flags;
 142         bool change;
 143
 144         spin_lock_irqsave(&sst->spinlock, flags);
 145         change = sst_dsp_shim_update_bits_unlocked(sst, offset, mask, value);
 146         spin_unlock_irqrestore(&sst->spinlock, flags);
 147         return change;
 148 }
 149 EXPORT_SYMBOL_GPL(sst_dsp_shim_update_bits);
 150
 151 int sst_dsp_shim_update_bits64(struct sst_dsp *sst, u32 offset,
 152                                 u64 mask, u64 value)
 153 {
 154         unsigned long flags;
 155         bool change;
 156
 157         spin_lock_irqsave(&sst->spinlock, flags);
 158         change = sst_dsp_shim_update_bits64_unlocked(sst, offset, mask, value);
 159         spin_unlock_irqrestore(&sst->spinlock, flags);
 160         return change;
 161 }
 162 EXPORT_SYMBOL_GPL(sst_dsp_shim_update_bits64);
 163
 164 void sst_dsp_dump(struct sst_dsp *sst)
 165 {
 166         sst->ops->dump(sst);
 167 }
 168 EXPORT_SYMBOL_GPL(sst_dsp_dump);
 169
 170 void sst_dsp_reset(struct sst_dsp *sst)
 171 {
 172         sst->ops->reset(sst);
 173 }
 174 EXPORT_SYMBOL_GPL(sst_dsp_reset);
 175
 176 int sst_dsp_boot(struct sst_dsp *sst)
 177 {
 178         sst->ops->boot(sst);
 179         return 0;
 180 }
 181 EXPORT_SYMBOL_GPL(sst_dsp_boot);
 182
 183 void sst_dsp_ipc_msg_tx(struct sst_dsp *dsp, u32 msg)
 184 {
 185         sst_dsp_shim_write_unlocked(dsp, SST_IPCX, msg | SST_IPCX_BUSY);
 186         trace_sst_ipc_msg_tx(msg);
 187 }
 188 EXPORT_SYMBOL_GPL(sst_dsp_ipc_msg_tx);
 189
 190 u32 sst_dsp_ipc_msg_rx(struct sst_dsp *dsp)
 191 {
 192         u32 msg;
 193
 194         msg = sst_dsp_shim_read_unlocked(dsp, SST_IPCX);
 195         trace_sst_ipc_msg_rx(msg);
 196
 197         return msg;
 198 }
 199 EXPORT_SYMBOL_GPL(sst_dsp_ipc_msg_rx);
 200
 201 int sst_dsp_mailbox_init(struct sst_dsp *sst, u32 inbox_offset, size_t inbox_size,
 202         u32 outbox_offset, size_t outbox_size)
 203 {
 204         sst->mailbox.in_base = sst->addr.lpe + inbox_offset;
 205         sst->mailbox.out_base = sst->addr.lpe + outbox_offset;
 206         sst->mailbox.in_size = inbox_size;
 207         sst->mailbox.out_size = outbox_size;
 208         return 0;
 209 }
 210 EXPORT_SYMBOL_GPL(sst_dsp_mailbox_init);
 211
 212 void sst_dsp_outbox_write(struct sst_dsp *sst, void *message, size_t bytes)
 213 {
 214         u32 i;
 215
 216         trace_sst_ipc_outbox_write(bytes);
 217
 218         memcpy_toio(sst->mailbox.out_base, message, bytes);
 219
 220         for (i = 0; i < bytes; i += 4)
 221                 trace_sst_ipc_outbox_wdata(i, *(u32 *)(message + i));
 222 }
 223 EXPORT_SYMBOL_GPL(sst_dsp_outbox_write);
 224
 225 void sst_dsp_outbox_read(struct sst_dsp *sst, void *message, size_t bytes)
 226 {
 227         u32 i;
 228
 229         trace_sst_ipc_outbox_read(bytes);
 230
 231         memcpy_fromio(message, sst->mailbox.out_base, bytes);
 232
 233         for (i = 0; i < bytes; i += 4)
 234                 trace_sst_ipc_outbox_rdata(i, *(u32 *)(message + i));
 235 }
 236 EXPORT_SYMBOL_GPL(sst_dsp_outbox_read);
 237
 238 void sst_dsp_inbox_write(struct sst_dsp *sst, void *message, size_t bytes)
 239 {
 240         u32 i;
 241
 242         trace_sst_ipc_inbox_write(bytes);
 243
 244         memcpy_toio(sst->mailbox.in_base, message, bytes);
 245
 246         for (i = 0; i < bytes; i += 4)
 247                 trace_sst_ipc_inbox_wdata(i, *(u32 *)(message + i));
 248 }
 249 EXPORT_SYMBOL_GPL(sst_dsp_inbox_write);
 250
 251 void sst_dsp_inbox_read(struct sst_dsp *sst, void *message, size_t bytes)
 252 {
 253         u32 i;
 254
 255         trace_sst_ipc_inbox_read(bytes);
 256
 257         memcpy_fromio(message, sst->mailbox.in_base, bytes);
 258
 259         for (i = 0; i < bytes; i += 4)
 260                 trace_sst_ipc_inbox_rdata(i, *(u32 *)(message + i));
 261 }
 262 EXPORT_SYMBOL_GPL(sst_dsp_inbox_read);
 263
 264 struct sst_dsp *sst_dsp_new(struct device *dev,
 265         struct sst_dsp_device *sst_dev, struct sst_pdata *pdata)
 266 {
 267         struct sst_dsp *sst;
 268         int err;
 269
 270         dev_dbg(dev, "initialising audio DSP id 0x%x\n", pdata->id);
 271
 272         sst = devm_kzalloc(dev, sizeof(*sst), GFP_KERNEL);
 273         if (sst == NULL)
 274                 return NULL;
 275
 276         spin_lock_init(&sst->spinlock);
 277         mutex_init(&sst->mutex);
 278         sst->dev = dev;
 279         sst->thread_context = sst_dev->thread_context;
 280         sst->sst_dev = sst_dev;
 281         sst->id = pdata->id;
 282         sst->irq = pdata->irq;
 283         sst->ops = sst_dev->ops;
 284         sst->pdata = pdata;
 285         INIT_LIST_HEAD(&sst->used_block_list);
 286         INIT_LIST_HEAD(&sst->free_block_list);
 287         INIT_LIST_HEAD(&sst->module_list);
 288         INIT_LIST_HEAD(&sst->fw_list);
 289
 290         /* Initialise SST Audio DSP */
 291         if (sst->ops->init) {
 292                 err = sst->ops->init(sst, pdata);
 293                 if (err < 0)
 294                         return NULL;
 295         }
 296
 297         /* Register the ISR */
 298         err = request_threaded_irq(sst->irq, sst->ops->irq_handler,
 299                 sst_dev->thread, IRQF_SHARED, "AudioDSP", sst);
 300         if (err)
 301                 goto irq_err;
 302
 303         return sst;
 304
 305 irq_err:
 306         if (sst->ops->free)
 307                 sst->ops->free(sst);
 308
 309         return NULL;
 310 }
 311 EXPORT_SYMBOL_GPL(sst_dsp_new);
 312
 313 void sst_dsp_free(struct sst_dsp *sst)
 314 {
 315         free_irq(sst->irq, sst);
 316         if (sst->ops->free)
 317                 sst->ops->free(sst);
 318 }
 319 EXPORT_SYMBOL_GPL(sst_dsp_free);
 320
 321 /* Module information */
 322 MODULE_AUTHOR("Liam Girdwood");
 323 MODULE_DESCRIPTION("Intel SST Core");
 324 MODULE_LICENSE("GPL v2");