sound/soc/intel/avs/utils.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 //
   3 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
   4 //
   5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
   6 //          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
   7 //
   8
   9 #include <linux/firmware.h>
  10 #include <linux/kfifo.h>
  11 #include <linux/slab.h>
  12 #include "avs.h"
  13 #include "messages.h"
  14
  15 /* Caller responsible for holding adev->modres_mutex. */
  16 static int avs_module_entry_index(struct avs_dev *adev, const guid_t *uuid)
  17 {
  18         int i;
  19
  20         for (i = 0; i < adev->mods_info->count; i++) {
  21                 struct avs_module_entry *module;
  22
  23                 module = &adev->mods_info->entries[i];
  24                 if (guid_equal(&module->uuid, uuid))
  25                         return i;
  26         }
  27
  28         return -ENOENT;
  29 }
  30
  31 /* Caller responsible for holding adev->modres_mutex. */
  32 static int avs_module_id_entry_index(struct avs_dev *adev, u32 module_id)
  33 {
  34         int i;
  35
  36         for (i = 0; i < adev->mods_info->count; i++) {
  37                 struct avs_module_entry *module;
  38
  39                 module = &adev->mods_info->entries[i];
  40                 if (module->module_id == module_id)
  41                         return i;
  42         }
  43
  44         return -ENOENT;
  45 }
  46
  47 int avs_get_module_entry(struct avs_dev *adev, const guid_t *uuid, struct avs_module_entry *entry)
  48 {
  49         int idx;
  50
  51         mutex_lock(&adev->modres_mutex);
  52
  53         idx = avs_module_entry_index(adev, uuid);
  54         if (idx >= 0)
  55                 memcpy(entry, &adev->mods_info->entries[idx], sizeof(*entry));
  56
  57         mutex_unlock(&adev->modres_mutex);
  58         return (idx < 0) ? idx : 0;
  59 }
  60
  61 int avs_get_module_id_entry(struct avs_dev *adev, u32 module_id, struct avs_module_entry *entry)
  62 {
  63         int idx;
  64
  65         mutex_lock(&adev->modres_mutex);
  66
  67         idx = avs_module_id_entry_index(adev, module_id);
  68         if (idx >= 0)
  69                 memcpy(entry, &adev->mods_info->entries[idx], sizeof(*entry));
  70
  71         mutex_unlock(&adev->modres_mutex);
  72         return (idx < 0) ? idx : 0;
  73 }
  74
  75 int avs_get_module_id(struct avs_dev *adev, const guid_t *uuid)
  76 {
  77         struct avs_module_entry module;
  78         int ret;
  79
  80         ret = avs_get_module_entry(adev, uuid, &module);
  81         return !ret ? module.module_id : -ENOENT;
  82 }
  83
  84 bool avs_is_module_ida_empty(struct avs_dev *adev, u32 module_id)
  85 {
  86         bool ret = false;
  87         int idx;
  88
  89         mutex_lock(&adev->modres_mutex);
  90
  91         idx = avs_module_id_entry_index(adev, module_id);
  92         if (idx >= 0)
  93                 ret = ida_is_empty(adev->mod_idas[idx]);
  94
  95         mutex_unlock(&adev->modres_mutex);
  96         return ret;
  97 }
  98
  99 /* Caller responsible for holding adev->modres_mutex. */
 100 static void avs_module_ida_destroy(struct avs_dev *adev)
 101 {
 102         int i = adev->mods_info ? adev->mods_info->count : 0;
 103
 104         while (i--) {
 105                 ida_destroy(adev->mod_idas[i]);
 106                 kfree(adev->mod_idas[i]);
 107         }
 108         kfree(adev->mod_idas);
 109 }
 110
 111 /* Caller responsible for holding adev->modres_mutex. */
 112 static int
 113 avs_module_ida_alloc(struct avs_dev *adev, struct avs_mods_info *newinfo, bool purge)
 114 {
 115         struct avs_mods_info *oldinfo = adev->mods_info;
 116         struct ida **ida_ptrs;
 117         u32 tocopy_count = 0;
 118         int i;
 119
 120         if (!purge && oldinfo) {
 121                 if (oldinfo->count >= newinfo->count)
 122                         dev_warn(adev->dev, "refreshing %d modules info with %d\n",
 123                                  oldinfo->count, newinfo->count);
 124                 tocopy_count = oldinfo->count;
 125         }
 126
 127         ida_ptrs = kcalloc(newinfo->count, sizeof(*ida_ptrs), GFP_KERNEL);
 128         if (!ida_ptrs)
 129                 return -ENOMEM;
 130
 131         if (tocopy_count)
 132                 memcpy(ida_ptrs, adev->mod_idas, tocopy_count * sizeof(*ida_ptrs));
 133
 134         for (i = tocopy_count; i < newinfo->count; i++) {
 135                 ida_ptrs[i] = kzalloc(sizeof(**ida_ptrs), GFP_KERNEL);
 136                 if (!ida_ptrs[i]) {
 137                         while (i--)
 138                                 kfree(ida_ptrs[i]);
 139
 140                         kfree(ida_ptrs);
 141                         return -ENOMEM;
 142                 }
 143
 144                 ida_init(ida_ptrs[i]);
 145         }
 146
 147         /* If old elements have been reused, don't wipe them. */
 148         if (tocopy_count)
 149                 kfree(adev->mod_idas);
 150         else
 151                 avs_module_ida_destroy(adev);
 152
 153         adev->mod_idas = ida_ptrs;
 154         return 0;
 155 }
 156
 157 int avs_module_info_init(struct avs_dev *adev, bool purge)
 158 {
 159         struct avs_mods_info *info;
 160         int ret;
 161
 162         ret = avs_ipc_get_modules_info(adev, &info);
 163         if (ret)
 164                 return AVS_IPC_RET(ret);
 165
 166         mutex_lock(&adev->modres_mutex);
 167
 168         ret = avs_module_ida_alloc(adev, info, purge);
 169         if (ret < 0) {
 170                 dev_err(adev->dev, "initialize module idas failed: %d\n", ret);
 171                 goto exit;
 172         }
 173
 174         /* Refresh current information with newly received table. */
 175         kfree(adev->mods_info);
 176         adev->mods_info = info;
 177
 178 exit:
 179         mutex_unlock(&adev->modres_mutex);
 180         return ret;
 181 }
 182
 183 void avs_module_info_free(struct avs_dev *adev)
 184 {
 185         mutex_lock(&adev->modres_mutex);
 186
 187         avs_module_ida_destroy(adev);
 188         kfree(adev->mods_info);
 189         adev->mods_info = NULL;
 190
 191         mutex_unlock(&adev->modres_mutex);
 192 }
 193
 194 int avs_module_id_alloc(struct avs_dev *adev, u16 module_id)
 195 {
 196         int ret, idx, max_id;
 197
 198         mutex_lock(&adev->modres_mutex);
 199
 200         idx = avs_module_id_entry_index(adev, module_id);
 201         if (idx == -ENOENT) {
 202                 dev_err(adev->dev, "invalid module id: %d", module_id);
 203                 ret = -EINVAL;
 204                 goto exit;
 205         }
 206         max_id = adev->mods_info->entries[idx].instance_max_count - 1;
 207         ret = ida_alloc_max(adev->mod_idas[idx], max_id, GFP_KERNEL);
 208 exit:
 209         mutex_unlock(&adev->modres_mutex);
 210         return ret;
 211 }
 212
 213 void avs_module_id_free(struct avs_dev *adev, u16 module_id, u8 instance_id)
 214 {
 215         int idx;
 216
 217         mutex_lock(&adev->modres_mutex);
 218
 219         idx = avs_module_id_entry_index(adev, module_id);
 220         if (idx == -ENOENT) {
 221                 dev_err(adev->dev, "invalid module id: %d", module_id);
 222                 goto exit;
 223         }
 224
 225         ida_free(adev->mod_idas[idx], instance_id);
 226 exit:
 227         mutex_unlock(&adev->modres_mutex);
 228 }
 229
 230 /*
 231  * Once driver loads FW it should keep it in memory, so we are not affected
 232  * by FW removal from filesystem or even worse by loading different FW at
 233  * runtime suspend/resume.
 234  */
 235 int avs_request_firmware(struct avs_dev *adev, const struct firmware **fw_p, const char *name)
 236 {
 237         struct avs_fw_entry *entry;
 238         int ret;
 239
 240         /* first check in list if it is not already loaded */
 241         list_for_each_entry(entry, &adev->fw_list, node) {
 242                 if (!strcmp(name, entry->name)) {
 243                         *fw_p = entry->fw;
 244                         return 0;
 245                 }
 246         }
 247
 248         /* FW is not loaded, let's load it now and add to the list */
 249         entry = kzalloc(sizeof(*entry), GFP_KERNEL);
 250         if (!entry)
 251                 return -ENOMEM;
 252
 253         entry->name = kstrdup(name, GFP_KERNEL);
 254         if (!entry->name) {
 255                 kfree(entry);
 256                 return -ENOMEM;
 257         }
 258
 259         ret = request_firmware(&entry->fw, name, adev->dev);
 260         if (ret < 0) {
 261                 kfree(entry->name);
 262                 kfree(entry);
 263                 return ret;
 264         }
 265
 266         *fw_p = entry->fw;
 267
 268         list_add_tail(&entry->node, &adev->fw_list);
 269
 270         return 0;
 271 }
 272
 273 /*
 274  * Release single FW entry, used to handle errors in functions calling
 275  * avs_request_firmware()
 276  */
 277 void avs_release_last_firmware(struct avs_dev *adev)
 278 {
 279         struct avs_fw_entry *entry;
 280
 281         entry = list_last_entry(&adev->fw_list, typeof(*entry), node);
 282
 283         list_del(&entry->node);
 284         release_firmware(entry->fw);
 285         kfree(entry->name);
 286         kfree(entry);
 287 }
 288
 289 /*
 290  * Release all FW entries, used on driver removal
 291  */
 292 void avs_release_firmwares(struct avs_dev *adev)
 293 {
 294         struct avs_fw_entry *entry, *tmp;
 295
 296         list_for_each_entry_safe(entry, tmp, &adev->fw_list, node) {
 297                 list_del(&entry->node);
 298                 release_firmware(entry->fw);
 299                 kfree(entry->name);
 300                 kfree(entry);
 301         }
 302 }
 303
 304 unsigned int __kfifo_fromio_locked(struct kfifo *fifo, const void __iomem *src, unsigned int len,
 305                                    spinlock_t *lock)
 306 {
 307         struct __kfifo *__fifo = &fifo->kfifo;
 308         unsigned long flags;
 309         unsigned int l, off;
 310
 311         spin_lock_irqsave(lock, flags);
 312         len = min(len, kfifo_avail(fifo));
 313         off = __fifo->in & __fifo->mask;
 314         l = min(len, kfifo_size(fifo) - off);
 315
 316         memcpy_fromio(__fifo->data + off, src, l);
 317         memcpy_fromio(__fifo->data, src + l, len - l);
 318         /* Make sure data copied from SRAM is visible to all CPUs. */
 319         smp_mb();
 320         __fifo->in += len;
 321         spin_unlock_irqrestore(lock, flags);
 322
 323         return len;
 324 }