firmware: cs_dsp: Remove redundant download buffer allocator

Now that cs_dsp uses regmap_raw_write() instead of regmap_raw_write_async()
it doesn't need to keep multiple DMA-safe buffers of every chunk of data
it wrote.

See commit fe08b7d5085a ("firmware: cs_dsp: Remove async regmap writes")

Only one write can be in progress at a time, so one DMA-safe buffer can be
re-used. The single DMA-safe buffer is reallocated if the next write chunk
is larger. Reallocation size is rounded up to reduce the amount of churn.
PAGE_SIZE is used as a convenient size multiple. Typically for .wmfw files
the first chunk is the largest.

A DMA-safe intermediate buffer is used because we can't assume that the
bus underlying regmap can accept non-DMA-safe buffers.

Note that a chunk from the firmware file cannot simply be split into
arbitrarily-sized chunks to avoid buffer reallocation. The data in the
firmware file is preformatted to be written directly to the device as one
block. It already takes account of alignment, write-bursts and write
length requirements of the target hardware, so that the cs_dsp driver can
treat it as an opaque blob.

Signed-off-by: Richard Fitzgerald <rf@opensource.cirrus.com>
Link: https://patch.msgid.link/20251126131501.884188-1-rf@opensource.cirrus.com
Signed-off-by: Mark Brown <broonie@kernel.org>

authored by

Richard Fitzgerald and committed by

Mark Brown 6 months ago 900baa6e bcf016aa

+34 -69

1 changed file

expand all

drivers

firmware

cirrus

cs_dsp.c

+34 -69

drivers/firmware/cirrus/cs_dsp.c

··· 13 13 #include <linux/ctype.h> 14 14 #include <linux/debugfs.h> 15 15 #include <linux/delay.h> 16 + #include <linux/math.h> 16 17 #include <linux/minmax.h> 17 18 #include <linux/module.h> 18 19 #include <linux/moduleparam.h> ··· 317 316 struct list_head list; 318 317 struct cs_dsp_alg_region alg_region; 319 318 }; 320 - 321 - struct cs_dsp_buf { 322 - struct list_head list; 323 - void *buf; 324 - }; 325 - 326 - static struct cs_dsp_buf *cs_dsp_buf_alloc(const void *src, size_t len, 327 - struct list_head *list) 328 - { 329 - struct cs_dsp_buf *buf = kzalloc(sizeof(*buf), GFP_KERNEL); 330 - 331 - if (buf == NULL) 332 - return NULL; 333 - 334 - buf->buf = vmalloc(len); 335 - if (!buf->buf) { 336 - kfree(buf); 337 - return NULL; 338 - } 339 - memcpy(buf->buf, src, len); 340 - 341 - if (list) 342 - list_add_tail(&buf->list, list); 343 - 344 - return buf; 345 - } 346 - 347 - static void cs_dsp_buf_free(struct list_head *list) 348 - { 349 - while (!list_empty(list)) { 350 - struct cs_dsp_buf *buf = list_first_entry(list, 351 - struct cs_dsp_buf, 352 - list); 353 - list_del(&buf->list); 354 - vfree(buf->buf); 355 - kfree(buf); 356 - } 357 - } 358 319 359 320 /** 360 321 * cs_dsp_mem_region_name() - Return a name string for a memory type ··· 1444 1481 const struct wmfw_region *region; 1445 1482 const struct cs_dsp_region *mem; 1446 1483 const char *region_name; 1447 - struct cs_dsp_buf *buf; 1484 + u8 *buf __free(kfree) = NULL; 1485 + size_t buf_len = 0; 1486 + size_t region_len; 1448 1487 unsigned int reg; 1449 1488 int regions = 0; 1450 1489 int ret, offset, type; ··· 1566 1601 region_name); 1567 1602 1568 1603 if (reg) { 1569 - buf = cs_dsp_buf_alloc(region->data, 1570 - le32_to_cpu(region->len), 1571 - &buf_list); 1572 - if (!buf) { 1573 - cs_dsp_err(dsp, "Out of memory\n"); 1574 - ret = -ENOMEM; 1575 - goto out_fw; 1604 + region_len = le32_to_cpu(region->len); 1605 + if (region_len > buf_len) { 1606 + buf_len = round_up(region_len, PAGE_SIZE); 1607 + kfree(buf); 1608 + buf = kmalloc(buf_len, GFP_KERNEL | GFP_DMA); 1609 + if (!buf) { 1610 + ret = -ENOMEM; 1611 + goto out_fw; 1612 + } 1576 1613 } 1577 1614 1578 - ret = regmap_raw_write(regmap, reg, buf->buf, 1579 - le32_to_cpu(region->len)); 1615 + memcpy(buf, region->data, region_len); 1616 + ret = regmap_raw_write(regmap, reg, buf, region_len); 1580 1617 if (ret != 0) { 1581 1618 cs_dsp_err(dsp, 1582 - "%s.%d: Failed to write %d bytes at %d in %s: %d\n", 1583 - file, regions, 1584 - le32_to_cpu(region->len), offset, 1585 - region_name, ret); 1619 + "%s.%d: Failed to write %zu bytes at %d in %s: %d\n", 1620 + file, regions, region_len, offset, region_name, ret); 1586 1621 goto out_fw; 1587 1622 } 1588 1623 } ··· 1599 1634 1600 1635 ret = 0; 1601 1636 out_fw: 1602 - cs_dsp_buf_free(&buf_list); 1603 - 1604 1637 if (ret == -EOVERFLOW) 1605 1638 cs_dsp_err(dsp, "%s: file content overflows file data\n", file); 1606 1639 ··· 2130 2167 struct cs_dsp_alg_region *alg_region; 2131 2168 const char *region_name; 2132 2169 int ret, pos, blocks, type, offset, reg, version; 2133 - struct cs_dsp_buf *buf; 2170 + u8 *buf __free(kfree) = NULL; 2171 + size_t buf_len = 0; 2172 + size_t region_len; 2134 2173 2135 2174 if (!firmware) 2136 2175 return 0; ··· 2274 2309 } 2275 2310 2276 2311 if (reg) { 2277 - buf = cs_dsp_buf_alloc(blk->data, 2278 - le32_to_cpu(blk->len), 2279 - &buf_list); 2280 - if (!buf) { 2281 - cs_dsp_err(dsp, "Out of memory\n"); 2282 - ret = -ENOMEM; 2283 - goto out_fw; 2312 + region_len = le32_to_cpu(blk->len); 2313 + if (region_len > buf_len) { 2314 + buf_len = round_up(region_len, PAGE_SIZE); 2315 + kfree(buf); 2316 + buf = kmalloc(buf_len, GFP_KERNEL | GFP_DMA); 2317 + if (!buf) { 2318 + ret = -ENOMEM; 2319 + goto out_fw; 2320 + } 2284 2321 } 2285 2322 2286 - cs_dsp_dbg(dsp, "%s.%d: Writing %d bytes at %x\n", 2287 - file, blocks, le32_to_cpu(blk->len), 2288 - reg); 2289 - ret = regmap_raw_write(regmap, reg, buf->buf, 2290 - le32_to_cpu(blk->len)); 2323 + memcpy(buf, blk->data, region_len); 2324 + 2325 + cs_dsp_dbg(dsp, "%s.%d: Writing %zu bytes at %x\n", 2326 + file, blocks, region_len, reg); 2327 + ret = regmap_raw_write(regmap, reg, buf, region_len); 2291 2328 if (ret != 0) { 2292 2329 cs_dsp_err(dsp, 2293 2330 "%s.%d: Failed to write to %x in %s: %d\n", ··· 2309 2342 2310 2343 ret = 0; 2311 2344 out_fw: 2312 - cs_dsp_buf_free(&buf_list); 2313 - 2314 2345 if (ret == -EOVERFLOW) 2315 2346 cs_dsp_err(dsp, "%s: file content overflows file data\n", file); 2316 2347

Configure Feed

Configure Feed