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