tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

soundwire: pass sdw_bpt_section to cdns BPT helpers

We can get start_register, data_size, and buffer data from the new
sdw_bpt_section parameter. Also, handle all register sections in the
cdns BRA helpers. No function changes as section number is 1.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
Tested-by: Shuming Fan <shumingf@realtek.com>
Link: https://patch.msgid.link/20251021094355.132943-3-yung-chuan.liao@linux.intel.com
Signed-off-by: Vinod Koul <vkoul@kernel.org>

authored by

Bard Liao and committed by
Vinod Koul fe8a9cf7 fdfa1960

+122 -85
+111 -73
drivers/soundwire/cadence_master.c
··· 2324 2324 2325 2325 #define CDNS_BPT_ROLLING_COUNTER_START 1 2326 2326 2327 - int sdw_cdns_prepare_write_dma_buffer(u8 dev_num, u32 start_register, u8 *data, int data_size, 2328 - int data_per_frame, u8 *dma_buffer, int dma_buffer_size, 2329 - int *dma_buffer_total_bytes) 2327 + int sdw_cdns_prepare_write_dma_buffer(u8 dev_num, struct sdw_bpt_section *sec, int num_sec, 2328 + int data_per_frame, u8 *dma_buffer, 2329 + int dma_buffer_size, int *dma_buffer_total_bytes) 2330 2330 { 2331 2331 int total_dma_data_written = 0; 2332 2332 u8 *p_dma_buffer = dma_buffer; 2333 2333 u8 header[SDW_CDNS_BRA_HDR]; 2334 + unsigned int start_register; 2335 + unsigned int section_size; 2334 2336 int dma_data_written; 2335 - u8 *p_data = data; 2337 + u8 *p_data; 2336 2338 u8 counter; 2337 2339 int ret; 2340 + int i; 2338 2341 2339 2342 counter = CDNS_BPT_ROLLING_COUNTER_START; 2340 2343 ··· 2345 2342 header[0] |= GENMASK(7, 6); /* header is active */ 2346 2343 header[0] |= (dev_num << 2); 2347 2344 2348 - while (data_size >= data_per_frame) { 2349 - header[1] = data_per_frame; 2350 - header[2] = start_register >> 24 & 0xFF; 2351 - header[3] = start_register >> 16 & 0xFF; 2352 - header[4] = start_register >> 8 & 0xFF; 2353 - header[5] = start_register >> 0 & 0xFF; 2345 + for (i = 0; i < num_sec; i++) { 2346 + start_register = sec[i].addr; 2347 + section_size = sec[i].len; 2348 + p_data = sec[i].buf; 2354 2349 2355 - ret = sdw_cdns_prepare_write_pd0_buffer(header, SDW_CDNS_BRA_HDR, 2356 - p_data, data_per_frame, 2357 - p_dma_buffer, dma_buffer_size, 2358 - &dma_data_written, counter); 2359 - if (ret < 0) 2360 - return ret; 2350 + while (section_size >= data_per_frame) { 2351 + header[1] = data_per_frame; 2352 + header[2] = start_register >> 24 & 0xFF; 2353 + header[3] = start_register >> 16 & 0xFF; 2354 + header[4] = start_register >> 8 & 0xFF; 2355 + header[5] = start_register >> 0 & 0xFF; 2361 2356 2362 - counter++; 2357 + ret = sdw_cdns_prepare_write_pd0_buffer(header, SDW_CDNS_BRA_HDR, 2358 + p_data, data_per_frame, 2359 + p_dma_buffer, dma_buffer_size, 2360 + &dma_data_written, counter); 2361 + if (ret < 0) 2362 + return ret; 2363 2363 2364 - p_data += data_per_frame; 2365 - data_size -= data_per_frame; 2364 + counter++; 2366 2365 2367 - p_dma_buffer += dma_data_written; 2368 - dma_buffer_size -= dma_data_written; 2369 - total_dma_data_written += dma_data_written; 2366 + p_data += data_per_frame; 2367 + section_size -= data_per_frame; 2370 2368 2371 - start_register += data_per_frame; 2372 - } 2369 + p_dma_buffer += dma_data_written; 2370 + dma_buffer_size -= dma_data_written; 2371 + total_dma_data_written += dma_data_written; 2373 2372 2374 - if (data_size) { 2375 - header[1] = data_size; 2376 - header[2] = start_register >> 24 & 0xFF; 2377 - header[3] = start_register >> 16 & 0xFF; 2378 - header[4] = start_register >> 8 & 0xFF; 2379 - header[5] = start_register >> 0 & 0xFF; 2373 + start_register += data_per_frame; 2374 + } 2380 2375 2381 - ret = sdw_cdns_prepare_write_pd0_buffer(header, SDW_CDNS_BRA_HDR, 2382 - p_data, data_size, 2383 - p_dma_buffer, dma_buffer_size, 2384 - &dma_data_written, counter); 2385 - if (ret < 0) 2386 - return ret; 2376 + if (section_size) { 2377 + header[1] = section_size; 2378 + header[2] = start_register >> 24 & 0xFF; 2379 + header[3] = start_register >> 16 & 0xFF; 2380 + header[4] = start_register >> 8 & 0xFF; 2381 + header[5] = start_register >> 0 & 0xFF; 2387 2382 2388 - total_dma_data_written += dma_data_written; 2383 + ret = sdw_cdns_prepare_write_pd0_buffer(header, SDW_CDNS_BRA_HDR, 2384 + p_data, section_size, 2385 + p_dma_buffer, dma_buffer_size, 2386 + &dma_data_written, counter); 2387 + if (ret < 0) 2388 + return ret; 2389 + 2390 + counter++; 2391 + 2392 + p_dma_buffer += dma_data_written; 2393 + dma_buffer_size -= dma_data_written; 2394 + total_dma_data_written += dma_data_written; 2395 + } 2389 2396 } 2390 2397 2391 2398 *dma_buffer_total_bytes = total_dma_data_written; ··· 2404 2391 } 2405 2392 EXPORT_SYMBOL(sdw_cdns_prepare_write_dma_buffer); 2406 2393 2407 - int sdw_cdns_prepare_read_dma_buffer(u8 dev_num, u32 start_register, int data_size, 2394 + int sdw_cdns_prepare_read_dma_buffer(u8 dev_num, struct sdw_bpt_section *sec, int num_sec, 2408 2395 int data_per_frame, u8 *dma_buffer, int dma_buffer_size, 2409 2396 int *dma_buffer_total_bytes, unsigned int fake_size) 2410 2397 { 2411 2398 int total_dma_data_written = 0; 2412 2399 u8 *p_dma_buffer = dma_buffer; 2413 2400 u8 header[SDW_CDNS_BRA_HDR]; 2401 + unsigned int start_register; 2402 + unsigned int data_size; 2414 2403 int dma_data_written; 2415 2404 u8 counter; 2416 2405 int ret; 2406 + int i; 2417 2407 2418 2408 counter = CDNS_BPT_ROLLING_COUNTER_START; 2419 2409 ··· 2424 2408 header[0] |= GENMASK(7, 6); /* header is active */ 2425 2409 header[0] |= (dev_num << 2); 2426 2410 2427 - while (data_size >= data_per_frame) { 2428 - header[1] = data_per_frame; 2429 - header[2] = start_register >> 24 & 0xFF; 2430 - header[3] = start_register >> 16 & 0xFF; 2431 - header[4] = start_register >> 8 & 0xFF; 2432 - header[5] = start_register >> 0 & 0xFF; 2411 + for (i = 0; i < num_sec; i++) { 2412 + start_register = sec[i].addr; 2413 + data_size = sec[i].len; 2414 + while (data_size >= data_per_frame) { 2415 + header[1] = data_per_frame; 2416 + header[2] = start_register >> 24 & 0xFF; 2417 + header[3] = start_register >> 16 & 0xFF; 2418 + header[4] = start_register >> 8 & 0xFF; 2419 + header[5] = start_register >> 0 & 0xFF; 2433 2420 2434 - ret = sdw_cdns_prepare_read_pd0_buffer(header, SDW_CDNS_BRA_HDR, p_dma_buffer, 2435 - dma_buffer_size, &dma_data_written, 2436 - counter); 2437 - if (ret < 0) 2438 - return ret; 2421 + ret = sdw_cdns_prepare_read_pd0_buffer(header, SDW_CDNS_BRA_HDR, 2422 + p_dma_buffer, dma_buffer_size, 2423 + &dma_data_written, counter); 2424 + if (ret < 0) 2425 + return ret; 2439 2426 2440 - counter++; 2427 + counter++; 2441 2428 2442 - data_size -= data_per_frame; 2429 + data_size -= data_per_frame; 2443 2430 2444 - p_dma_buffer += dma_data_written; 2445 - dma_buffer_size -= dma_data_written; 2446 - total_dma_data_written += dma_data_written; 2431 + p_dma_buffer += dma_data_written; 2432 + dma_buffer_size -= dma_data_written; 2433 + total_dma_data_written += dma_data_written; 2447 2434 2448 - start_register += data_per_frame; 2449 - } 2435 + start_register += data_per_frame; 2436 + } 2450 2437 2451 - if (data_size) { 2452 - header[1] = data_size; 2453 - header[2] = start_register >> 24 & 0xFF; 2454 - header[3] = start_register >> 16 & 0xFF; 2455 - header[4] = start_register >> 8 & 0xFF; 2456 - header[5] = start_register >> 0 & 0xFF; 2438 + if (data_size) { 2439 + header[1] = data_size; 2440 + header[2] = start_register >> 24 & 0xFF; 2441 + header[3] = start_register >> 16 & 0xFF; 2442 + header[4] = start_register >> 8 & 0xFF; 2443 + header[5] = start_register >> 0 & 0xFF; 2457 2444 2458 - ret = sdw_cdns_prepare_read_pd0_buffer(header, SDW_CDNS_BRA_HDR, p_dma_buffer, 2459 - dma_buffer_size, &dma_data_written, 2460 - counter); 2461 - if (ret < 0) 2462 - return ret; 2445 + ret = sdw_cdns_prepare_read_pd0_buffer(header, SDW_CDNS_BRA_HDR, 2446 + p_dma_buffer, dma_buffer_size, 2447 + &dma_data_written, counter); 2448 + if (ret < 0) 2449 + return ret; 2463 2450 2464 - counter++; 2451 + counter++; 2465 2452 2466 - p_dma_buffer += dma_data_written; 2467 - dma_buffer_size -= dma_data_written; 2468 - total_dma_data_written += dma_data_written; 2453 + p_dma_buffer += dma_data_written; 2454 + dma_buffer_size -= dma_data_written; 2455 + total_dma_data_written += dma_data_written; 2456 + } 2469 2457 } 2470 2458 2471 2459 /* Add fake frame */ ··· 2636 2616 } 2637 2617 2638 2618 int sdw_cdns_check_read_response(struct device *dev, u8 *dma_buffer, int dma_buffer_size, 2639 - u8 *buffer, int buffer_size, int num_frames, int data_per_frame) 2619 + struct sdw_bpt_section *sec, int num_sec, int num_frames, 2620 + int data_per_frame) 2640 2621 { 2641 2622 int total_num_bytes = 0; 2623 + int buffer_size = 0; 2624 + int sec_index; 2642 2625 u32 *p_data; 2643 2626 u8 *p_buf; 2644 2627 int counter; ··· 2655 2632 2656 2633 counter = CDNS_BPT_ROLLING_COUNTER_START; 2657 2634 p_data = (u32 *)dma_buffer; 2658 - p_buf = buffer; 2635 + 2636 + sec_index = 0; 2637 + p_buf = sec[sec_index].buf; 2638 + buffer_size = sec[sec_index].len; 2659 2639 2660 2640 for (i = 0; i < num_frames; i++) { 2661 2641 header = *p_data++; ··· 2698 2672 2699 2673 counter++; 2700 2674 counter &= GENMASK(3, 0); 2675 + 2676 + if (buffer_size == total_num_bytes && (i + 1) < num_frames) { 2677 + sec_index++; 2678 + if (sec_index >= num_sec) { 2679 + dev_err(dev, "%s: incorrect section index %d i %d\n", 2680 + __func__, sec_index, i); 2681 + return -EINVAL; 2682 + } 2683 + p_buf = sec[sec_index].buf; 2684 + buffer_size = sec[sec_index].len; 2685 + total_num_bytes = 0; 2686 + } 2701 2687 } 2702 2688 return 0; 2703 2689 }
+7 -5
drivers/soundwire/cadence_master.h
··· 1 1 /* SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) */ 2 2 /* Copyright(c) 2015-17 Intel Corporation. */ 3 3 #include <sound/soc.h> 4 + #include "bus.h" 4 5 5 6 #ifndef __SDW_CADENCE_H 6 7 #define __SDW_CADENCE_H ··· 221 220 unsigned int *data_per_frame, unsigned int *pdi0_buffer_size, 222 221 unsigned int *pdi1_buffer_size, unsigned int *num_frames); 223 222 224 - int sdw_cdns_prepare_write_dma_buffer(u8 dev_num, u32 start_register, u8 *data, int data_size, 225 - int data_per_frame, u8 *dma_buffer, int dma_buffer_size, 226 - int *dma_buffer_total_bytes); 223 + int sdw_cdns_prepare_write_dma_buffer(u8 dev_num, struct sdw_bpt_section *sec, int num_sec, 224 + int data_per_frame, u8 *dma_buffer, 225 + int dma_buffer_size, int *dma_buffer_total_bytes); 227 226 228 - int sdw_cdns_prepare_read_dma_buffer(u8 dev_num, u32 start_register, int data_size, 227 + int sdw_cdns_prepare_read_dma_buffer(u8 dev_num, struct sdw_bpt_section *sec, int num_sec, 229 228 int data_per_frame, u8 *dma_buffer, int dma_buffer_size, 230 229 int *dma_buffer_total_bytes, unsigned int fake_size); 231 230 ··· 233 232 int dma_buffer_size, int num_frames); 234 233 235 234 int sdw_cdns_check_read_response(struct device *dev, u8 *dma_buffer, int dma_buffer_size, 236 - u8 *buffer, int buffer_size, int num_frames, int data_per_frame); 235 + struct sdw_bpt_section *sec, int num_sec, int num_frames, 236 + int data_per_frame); 237 237 #endif /* __SDW_CADENCE_H */
+4 -7
drivers/soundwire/intel_ace2x.c
··· 220 220 } 221 221 222 222 if (!command) { 223 - ret = sdw_cdns_prepare_write_dma_buffer(msg->dev_num, msg->sec[0].addr, 224 - msg->sec[0].buf, 225 - msg->sec[0].len, data_per_frame, 223 + ret = sdw_cdns_prepare_write_dma_buffer(msg->dev_num, msg->sec, 1, 224 + data_per_frame, 226 225 sdw->bpt_ctx.dmab_tx_bdl.area, 227 226 pdi0_buffer_size, &tx_total_bytes); 228 227 } else { 229 - ret = sdw_cdns_prepare_read_dma_buffer(msg->dev_num, msg->sec[0].addr, 230 - msg->sec[0].len, 228 + ret = sdw_cdns_prepare_read_dma_buffer(msg->dev_num, msg->sec, 1, 231 229 data_per_frame, 232 230 sdw->bpt_ctx.dmab_tx_bdl.area, 233 231 pdi0_buffer_size, &tx_total_bytes, ··· 368 370 } else { 369 371 ret = sdw_cdns_check_read_response(cdns->dev, sdw->bpt_ctx.dmab_rx_bdl.area, 370 372 sdw->bpt_ctx.pdi1_buffer_size, 371 - msg->sec[0].buf, msg->sec[0].len, 372 - sdw->bpt_ctx.num_frames, 373 + msg->sec, 1, sdw->bpt_ctx.num_frames, 373 374 sdw->bpt_ctx.data_per_frame); 374 375 if (ret < 0) 375 376 dev_err(cdns->dev, "%s: BPT Read failed %d\n", __func__, ret);