October 2017 - Sound-open-firmware - mailman.alsa-project.org

[Sound-open-firmware] [PATCH] trace: dma: Add atomic and nowait DMA tracing support.
by Liam Girdwood 19 Oct '17

19 Oct '17

Add support for DMA trace to run in atomic and IRQ contexts. Currently DMA trace would sleep between DMA copies and enter atomic state when inserting new tarce data into the trace buffer. This patch adds new DMA _nowait() APIs that dont sleep and _atomic() APIs for trace logging that can be safely called in atomic context. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- src/audio/dma-trace.c | 144 ++++++++++++++++++++-------------- src/include/reef/audio/dma-trace.h | 1 + src/include/reef/dma.h | 4 + src/include/reef/trace.h | 12 +++ src/ipc/dma-copy.c | 157 ++++++++++++++++++++++++++++++++++--- src/lib/trace.c | 56 ++++++++++++- 6 files changed, 301 insertions(+), 73 deletions(-) diff --git a/src/audio/dma-trace.c b/src/audio/dma-trace.c index 9704733..b0267fa 100644 --- a/src/audio/dma-trace.c +++ b/src/audio/dma-trace.c @@ -47,9 +47,7 @@ static uint64_t trace_work(void *data, uint64_t delay) struct dma_trace_buf *buffer = &d->dmatb; struct dma_sg_config *config = &d->config; unsigned long flags; - int32_t offset = 0; uint32_t avail = buffer->avail; - uint32_t bytes_copied = 0; uint32_t size; uint32_t hsize; uint32_t lsize; @@ -58,53 +56,51 @@ static uint64_t trace_work(void *data, uint64_t delay) if (avail == 0) return DMA_TRACE_US; + /* make sure we dont write more than buffer */ + if (avail > DMA_TRACE_LOCAL_SIZE) + avail = DMA_TRACE_LOCAL_SIZE; + /* copy to host in sections if we wrap */ - while (avail > 0) { - - lsize = hsize = avail; - - /* host buffer wrap ? */ - if (d->host_offset + buffer->avail > d->host_size) - hsize = d->host_offset + buffer->avail - d->host_size; - - /* local buffer wrap ? */ - if (buffer->r_ptr > buffer->w_ptr) - lsize = buffer->end_addr - buffer->r_ptr; - - /* get smallest size */ - if (hsize < lsize) - size = hsize; - else - size = lsize; - - /* writeback trace data */ - dcache_writeback_region((void*)buffer->r_ptr, size); - - /* copy this section to host */ - offset = dma_copy_to_host(&d->dc, config, d->host_offset, - buffer->r_ptr, size); - if (offset < 0) { - trace_buffer_error("ebb"); - goto out; - } - - /* update host pointer and check for wrap */ - d->host_offset += size; - if (d->host_offset + size >= d->host_size) - d->host_offset = 0; - - /* update local pointer and check for wrap */ - buffer->r_ptr += size; - if (buffer->r_ptr >= buffer->end_addr) - buffer->r_ptr = buffer->addr; - - avail -= size; - bytes_copied += size; + lsize = hsize = avail; + + /* host buffer wrap ? */ + if (d->host_offset + avail > d->host_size) + hsize = d->host_size - d->host_offset; + + /* local buffer wrap ? */ + if (buffer->r_ptr + avail > buffer->end_addr) + lsize = buffer->end_addr - buffer->r_ptr; + + /* get smallest size */ + if (hsize < lsize) + size = hsize; + else + size = lsize; + + /* writeback trace data */ + dcache_writeback_region((void*)buffer->r_ptr, size); + + /* copy this section to host */ + size = dma_copy_to_host_nowait(&d->dc, config, d->host_offset, + buffer->r_ptr, size); + if (size < 0) { + trace_buffer_error("ebb"); + goto out; } + /* update host pointer and check for wrap */ + d->host_offset += size; + if (d->host_offset + size >= d->host_size) + d->host_offset = 0; + + /* update local pointer and check for wrap */ + buffer->r_ptr += size; + if (buffer->r_ptr >= buffer->end_addr) + buffer->r_ptr = buffer->addr; + out: spin_lock_irq(&d->lock, flags); - buffer->avail -= bytes_copied; + buffer->avail -= size; spin_unlock_irq(&d->lock, flags); /* reschedule the trace copying work */ @@ -172,32 +168,28 @@ int dma_trace_enable(struct dma_trace_data *d) { /* validate DMA context */ if (d->dc.dmac == NULL || d->dc.chan < 0) { - trace_buffer_error("eem"); + trace_error_atomic(TRACE_CLASS_BUFFER, "eem"); return -ENODEV; } /* TODO: fix crash when enabled */ - //d->enabled = 1; + d->enabled = 1; work_schedule_default(&d->dmat_work, DMA_TRACE_US); return 0; } -void dtrace_event(const char *e, uint32_t length) +static void dtrace_add_event(const char *e, uint32_t length) { - struct dma_trace_buf *buffer = NULL; - int margin = 0; - unsigned long flags; + struct dma_trace_buf *buffer = &trace_data->dmatb; + int margin; - if (trace_data == NULL || length == 0) - return; + margin = buffer->end_addr - buffer->w_ptr; - buffer = &trace_data->dmatb; - if (buffer == NULL) + /* validate */ + if (margin <= 0) { + trace_buffer_error("emm"); return; - - spin_lock_irq(&trace_data->lock, flags); - - margin = buffer->end_addr - buffer->w_ptr; + } /* check for buffer wrap */ if (margin > length) { @@ -216,9 +208,45 @@ void dtrace_event(const char *e, uint32_t length) } buffer->avail += length; +} + +void dtrace_event(const char *e, uint32_t length) +{ + struct dma_trace_buf *buffer = NULL; + unsigned long flags; + + if (trace_data == NULL || length == 0) + return; + + if (!trace_data->enabled) + return; + + buffer = &trace_data->dmatb; + if (buffer == NULL) + return; + + spin_lock_irq(&trace_data->lock, flags); + dtrace_add_event(e, length); spin_unlock_irq(&trace_data->lock, flags); /* schedule copy now if buffer > 50% full */ if (trace_data->enabled && buffer->avail >= (DMA_TRACE_LOCAL_SIZE / 2)) work_reschedule_default(&trace_data->dmat_work, 100); } + +void dtrace_event_atomic(const char *e, uint32_t length) +{ + struct dma_trace_buf *buffer = NULL; + + if (trace_data == NULL || length == 0) + return; + + if (!trace_data->enabled) + return; + + buffer = &trace_data->dmatb; + if (buffer == NULL) + return; + + dtrace_add_event(e, length); +} diff --git a/src/include/reef/audio/dma-trace.h b/src/include/reef/audio/dma-trace.h index 83db484..12d0956 100644 --- a/src/include/reef/audio/dma-trace.h +++ b/src/include/reef/audio/dma-trace.h @@ -69,5 +69,6 @@ int dma_trace_host_buffer(struct dma_trace_data *d, struct dma_sg_elem *elem, int dma_trace_enable(struct dma_trace_data *d); void dtrace_event(const char *e, uint32_t size); +void dtrace_event_atomic(const char *e, uint32_t length); #endif diff --git a/src/include/reef/dma.h b/src/include/reef/dma.h index 33d1c9a..8dd4adf 100644 --- a/src/include/reef/dma.h +++ b/src/include/reef/dma.h @@ -249,9 +249,13 @@ static inline void dma_copy_free(struct dma_copy *dc) /* DMA copy data from host to DSP */ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size); +int dma_copy_from_host_nowait(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size); /* DMA copy data from DSP to host */ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size); +int dma_copy_to_host_nowait(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size); #endif diff --git a/src/include/reef/trace.h b/src/include/reef/trace.h index cdd8158..17dff5c 100644 --- a/src/include/reef/trace.h +++ b/src/include/reef/trace.h @@ -95,6 +95,8 @@ void _trace_event(uint32_t event); void _trace_error(uint32_t event); +void _trace_event_atomic(uint32_t event); +void _trace_error_atomic(uint32_t event); void trace_off(void); void trace_init(struct reef * reef); @@ -102,8 +104,11 @@ void trace_init(struct reef * reef); #define trace_event(__c, __e) \ _trace_event(__c | (__e[0] << 16) | (__e[1] <<8) | __e[2]) +#define trace_event_atomic(__c, __e) \ + _trace_event_atomic(__c | (__e[0] << 16) | (__e[1] <<8) | __e[2]) #define trace_value(x) _trace_event(x) +#define trace_value_atomic(x) _trace_event_atomic(x) #define trace_point(x) platform_trace_point(x) @@ -111,17 +116,24 @@ void trace_init(struct reef * reef); #if TRACEV #define tracev_event(__c, __e) trace_event(__c, __e) #define tracev_value(x) _trace_event(x) +#define tracev_event_atomic(__c, __e) trace_event_atomic(__c, __e) +#define tracev_value_atomic(x) _trace_event_atomic(x) #else #define tracev_event(__c, __e) #define tracev_value(x) +#define tracev_event_atomic(__c, __e) +#define tracev_value_atomic(x) #endif /* error tracing */ #if TRACEE #define trace_error(__c, __e) \ _trace_error(__c | (__e[0] << 16) | (__e[1] <<8) | __e[2]) +#define trace_error_atomic(__c, __e) \ + _trace_error_atomic(__c | (__e[0] << 16) | (__e[1] <<8) | __e[2]) #else #define trace_error(__c, __e) +#define trace_error_atomic(__c, __e) #endif #else diff --git a/src/ipc/dma-copy.c b/src/ipc/dma-copy.c index 75dd3bd..5c9ff97 100644 --- a/src/ipc/dma-copy.c +++ b/src/ipc/dma-copy.c @@ -75,8 +75,14 @@ static void dma_complete(void *data, uint32_t type, struct dma_sg_elem *next) if (type == DMA_IRQ_TYPE_LLIST) wait_completed(comp); + + next->size = DMA_RELOAD_END; } +/* Copy DSP memory to host memory. + * copies DSP memory to host in PAGE_SIZE or smaller blocks and waits/sleeps + * between blocks. Cant be used in IRQ context. + */ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size) { @@ -85,6 +91,7 @@ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, struct dma_sg_elem local_sg_elem; int32_t err; int32_t offset = host_offset; + int32_t bytes_copied = 0; if (size <= 0) return 0; @@ -104,7 +111,11 @@ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, /* configure local DMA elem */ local_sg_elem.dest = host_sg_elem->dest + offset; local_sg_elem.src = (uint32_t)local_ptr; - local_sg_elem.size = HOST_PAGE_SIZE - offset; + if (size >= HOST_PAGE_SIZE - offset) + local_sg_elem.size = HOST_PAGE_SIZE - offset; + else + local_sg_elem.size = size; + list_item_prepend(&local_sg_elem.list, &config.elem_list); /* transfer max PAGE size at a time to SG buffer */ @@ -112,8 +123,13 @@ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, /* start the DMA */ wait_init(&dc->complete); - dma_set_config(dc->dmac, dc->chan, &config); - dma_start(dc->dmac, dc->chan); + err = dma_set_config(dc->dmac, dc->chan, &config); + if (err < 0) + return err; + + err = dma_start(dc->dmac, dc->chan); + if (err < 0) + return err; /* wait for DMA to complete */ err = wait_for_completion_timeout(&dc->complete); @@ -127,12 +143,15 @@ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, host_offset += local_sg_elem.size; /* next dest host address is in next host elem */ + host_sg_elem = list_next_item(host_sg_elem, list); local_sg_elem.dest = host_sg_elem->dest; /* local address is continuous */ local_sg_elem.src = (uint32_t)local_ptr + local_sg_elem.size; + bytes_copied += local_sg_elem.size; + /* do we have less than 1 PAGE to copy ? */ if (size >= HOST_PAGE_SIZE) local_sg_elem.size = HOST_PAGE_SIZE; @@ -140,10 +159,65 @@ int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, local_sg_elem.size = size; } - /* new host offset in SG buffer */ - return host_offset; + /* bytes copied */ + return bytes_copied; +} + +/* Copy DSP memory to host memory. + * Copies DSP memory to host in a single PAGE_SIZE or smaller block. Does not + * waits/sleeps and can be used in IRQ context. + */ +int dma_copy_to_host_nowait(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size) +{ + struct dma_sg_config config; + struct dma_sg_elem *host_sg_elem; + struct dma_sg_elem local_sg_elem; + int32_t err; + int32_t offset = host_offset; + + if (size <= 0) + return 0; + + /* find host element with host_offset */ + host_sg_elem = sg_get_elem_at(host_sg, &offset); + if (host_sg_elem == NULL) + return -EINVAL; + + /* set up DMA configuration */ + config.direction = DMA_DIR_LMEM_TO_HMEM; + config.src_width = sizeof(uint32_t); + config.dest_width = sizeof(uint32_t); + config.cyclic = 0; + list_init(&config.elem_list); + + /* configure local DMA elem */ + local_sg_elem.dest = host_sg_elem->dest + offset; + local_sg_elem.src = (uint32_t)local_ptr; + if (size >= HOST_PAGE_SIZE - offset) + local_sg_elem.size = HOST_PAGE_SIZE - offset; + else + local_sg_elem.size = size; + + list_item_prepend(&local_sg_elem.list, &config.elem_list); + + /* start the DMA */ + err = dma_set_config(dc->dmac, dc->chan, &config); + if (err < 0) + return err; + + err = dma_start(dc->dmac, dc->chan); + if (err < 0) + return err; + + /* bytes copied */ + return local_sg_elem.size; } +/* Copy host memory to DSP memory. + * Copies host memory to host in PAGE_SIZE or smaller blocks and waits/sleeps + * between blocks. Cant be used in IRQ context. + */ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size) { @@ -152,6 +226,7 @@ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, struct dma_sg_elem local_sg_elem; int32_t err; int32_t offset = host_offset; + int32_t bytes_copied = 0; if (size <= 0) return 0; @@ -171,7 +246,10 @@ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, /* configure local DMA elem */ local_sg_elem.dest = (uint32_t)local_ptr; local_sg_elem.src = host_sg_elem->src + offset; - local_sg_elem.size = HOST_PAGE_SIZE - offset; + if (size >= HOST_PAGE_SIZE - offset) + local_sg_elem.size = HOST_PAGE_SIZE - offset; + else + local_sg_elem.size = size; list_item_prepend(&local_sg_elem.list, &config.elem_list); /* transfer max PAGE size at a time to SG buffer */ @@ -179,9 +257,14 @@ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, /* start the DMA */ wait_init(&dc->complete); - dma_set_config(dc->dmac, dc->chan, &config); - dma_start(dc->dmac, dc->chan); - + err = dma_set_config(dc->dmac, dc->chan, &config); + if (err < 0) + return err; + + err = dma_start(dc->dmac, dc->chan); + if (err < 0) + return err; + /* wait for DMA to complete */ err = wait_for_completion_timeout(&dc->complete); if (err < 0) { @@ -200,6 +283,8 @@ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, /* local address is continuous */ local_sg_elem.dest = (uint32_t)local_ptr + local_sg_elem.size; + bytes_copied += local_sg_elem.size; + /* do we have less than 1 PAGE to copy ? */ if (size >= HOST_PAGE_SIZE) local_sg_elem.size = HOST_PAGE_SIZE; @@ -207,8 +292,58 @@ int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, local_sg_elem.size = size; } - /* new host offset in SG buffer */ - return host_offset; + /* bytes copied */ + return bytes_copied; +} + +/* Copy host memory to DSP memory. + * Copies host memory to DSP in a single PAGE_SIZE or smaller block. Does not + * waits/sleeps and can be used in IRQ context. + */ +int dma_copy_from_host_nowait(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size) +{ + struct dma_sg_config config; + struct dma_sg_elem *host_sg_elem; + struct dma_sg_elem local_sg_elem; + int32_t err; + int32_t offset = host_offset; + + if (size <= 0) + return 0; + + /* find host element with host_offset */ + host_sg_elem = sg_get_elem_at(host_sg, &offset); + if (host_sg_elem == NULL) + return -EINVAL; + + /* set up DMA configuration */ + config.direction = DMA_DIR_HMEM_TO_LMEM; + config.src_width = sizeof(uint32_t); + config.dest_width = sizeof(uint32_t); + config.cyclic = 0; + list_init(&config.elem_list); + + /* configure local DMA elem */ + local_sg_elem.dest = (uint32_t)local_ptr; + local_sg_elem.src = host_sg_elem->src + offset; + if (size >= HOST_PAGE_SIZE - offset) + local_sg_elem.size = HOST_PAGE_SIZE - offset; + else + local_sg_elem.size = size; + list_item_prepend(&local_sg_elem.list, &config.elem_list); + + /* start the DMA */ + err = dma_set_config(dc->dmac, dc->chan, &config); + if (err < 0) + return err; + + err = dma_start(dc->dmac, dc->chan); + if (err < 0) + return err; + + /* bytes copied */ + return local_sg_elem.size; } int dma_copy_new(struct dma_copy *dc, int dmac) diff --git a/src/lib/trace.c b/src/lib/trace.c index 6f707c3..c0abf7c 100644 --- a/src/lib/trace.c +++ b/src/lib/trace.c @@ -49,30 +49,66 @@ void _trace_error(uint32_t event) { unsigned long flags; volatile uint64_t *t; + uint64_t dt[2]; + uint64_t time; if (!trace.enable) return; + time = platform_timer_get(platform_timer); + /* save event to DMA tracing buffer */ - _trace_event(event); + dt[0] = time; + dt[1] = event; + dtrace_event((const char*)dt, sizeof(uint64_t) * 2); /* send event by mail box too. */ spin_lock_irq(&trace.lock, flags); /* write timestamp and event to trace buffer */ t = (volatile uint64_t*)(MAILBOX_TRACE_BASE + trace.pos); - t[0] = platform_timer_get(platform_timer); + trace.pos += (sizeof(uint64_t) << 1); + + if (trace.pos > MAILBOX_TRACE_SIZE - sizeof(uint64_t) * 2) + trace.pos = 0; + + spin_unlock_irq(&trace.lock, flags); + + t[0] = time; t[1] = event; /* writeback trace data */ dcache_writeback_region((void*)t, sizeof(uint64_t) * 2); +} + +void _trace_error_atomic(uint32_t event) +{ + volatile uint64_t *t; + uint64_t dt[2]; + uint64_t time; + + if (!trace.enable) + return; + + time = platform_timer_get(platform_timer); + + /* save event to DMA tracing buffer */ + dt[0] = time; + dt[1] = event; + dtrace_event_atomic((const char*)dt, sizeof(uint64_t) * 2); + /* write timestamp and event to trace buffer */ + t = (volatile uint64_t*)(MAILBOX_TRACE_BASE + trace.pos); trace.pos += (sizeof(uint64_t) << 1); if (trace.pos > MAILBOX_TRACE_SIZE - sizeof(uint64_t) * 2) trace.pos = 0; - spin_unlock_irq(&trace.lock, flags); + t[0] = time; + t[1] = event; + + /* writeback trace data */ + dcache_writeback_region((void*)t, sizeof(uint64_t) * 2); } void _trace_event(uint32_t event) @@ -87,10 +123,22 @@ void _trace_event(uint32_t event) dtrace_event((const char*)dt, sizeof(uint64_t) * 2); } +void _trace_event_atomic(uint32_t event) +{ + uint64_t dt[2]; + + if (!trace.enable) + return; + + dt[0] = platform_timer_get(platform_timer); + dt[1] = event; + dtrace_event_atomic((const char*)dt, sizeof(uint64_t) * 2); +} + void trace_off(void) { trace.enable = 0; -}; +} void trace_init(struct reef *reef) { -- 2.11.0

1 5

Re: [Sound-open-firmware] Support for Tangier SoC
by Liam Girdwood 16 Oct '17

16 Oct '17

On Sun, 2017-10-15 at 19:51 +0200, Sven Schwermer wrote: > Hi. > > I was wondering if the Tangier SoC (Merrifield platform) is or will be > supported by SOF? I have the Intel Edison compute module in mind. > Yes, it _should_ work on Merrifield, but I don't have Edison HW so some things on the driver side might need some work. The 1.0-dev branch and sof-v4.13 kernel will probably be better for Edison than the stable 0.95 branch atm (mainly due to driver updates), but 1.0-dev is still has a few issues prior to doing an rc1 tag. Liam --------------------------------------------------------------------- Intel Corporation (UK) Limited Registered No. 1134945 (England) Registered Office: Pipers Way, Swindon SN3 1RJ VAT No: 860 2173 47 This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.

2 1

[Sound-open-firmware] [PATCH] dma copy: trace: Fix locking with DMA trace and refactor API usage.
by Liam Girdwood 15 Oct '17

15 Oct '17

Fix locking in DMA trace. Also run the DMA trace as delayed work so we dont block callers. Refactor API so that DMAC and channel are pre-allocated. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- src/audio/dma-trace.c | 101 ++++++++++------------ src/include/reef/alloc.h | 4 +- src/include/reef/audio/dma-trace.h | 5 +- src/include/reef/dma.h | 22 ++++- src/ipc/dma-copy.c | 95 ++++++++++---------- src/ipc/intel-ipc.c | 4 +- src/ipc/ipc.c | 1 - src/lib/alloc.c | 12 +-- src/lib/trace.c | 6 +- src/platform/baytrail/include/platform/platform.h | 3 + 10 files changed, 131 insertions(+), 122 deletions(-) diff --git a/src/audio/dma-trace.c b/src/audio/dma-trace.c index 00a29b4..9704733 100644 --- a/src/audio/dma-trace.c +++ b/src/audio/dma-trace.c @@ -41,51 +41,22 @@ static struct dma_trace_data *trace_data = NULL; -static int dma_trace_new_buffer(struct dma_trace_data *d, uint32_t buffer_size) -{ - struct dma_trace_buf *buffer = &d->dmatb; - - trace_buffer("nlb"); - - /* validate request */ - if (buffer_size == 0 || buffer_size > HEAP_BUFFER_SIZE) { - trace_buffer_error("ebg"); - trace_value(buffer_size); - return -ENOMEM; - } - - /* allocate new buffer */ - buffer->addr = rballoc(RZONE_RUNTIME, RFLAGS_NONE, buffer_size); - if (buffer->addr == NULL) { - trace_buffer_error("ebm"); - return -ENOMEM; - } - - bzero(buffer->addr, buffer_size); - - buffer->size = buffer_size; - buffer->w_ptr = buffer->r_ptr = buffer->addr; - buffer->end_addr = buffer->addr + buffer->size; - buffer->avail = 0; - - return 0; -} - -static void trace_send(struct dma_trace_data *d) +static uint64_t trace_work(void *data, uint64_t delay) { + struct dma_trace_data *d = (struct dma_trace_data *)data; struct dma_trace_buf *buffer = &d->dmatb; struct dma_sg_config *config = &d->config; unsigned long flags; int32_t offset = 0; uint32_t avail = buffer->avail; - uint32_t bytes_copied = avail; + uint32_t bytes_copied = 0; uint32_t size; uint32_t hsize; uint32_t lsize; /* any data to copy ? */ if (avail == 0) - return; + return DMA_TRACE_US; /* copy to host in sections if we wrap */ while (avail > 0) { @@ -106,12 +77,15 @@ static void trace_send(struct dma_trace_data *d) else size = lsize; + /* writeback trace data */ + dcache_writeback_region((void*)buffer->r_ptr, size); + /* copy this section to host */ - offset = dma_copy_to_host(config, d->host_offset, + offset = dma_copy_to_host(&d->dc, config, d->host_offset, buffer->r_ptr, size); if (offset < 0) { trace_buffer_error("ebb"); - return; + goto out; } /* update host pointer and check for wrap */ @@ -125,18 +99,13 @@ static void trace_send(struct dma_trace_data *d) buffer->r_ptr = buffer->addr; avail -= size; + bytes_copied += size; } +out: spin_lock_irq(&d->lock, flags); buffer->avail -= bytes_copied; spin_unlock_irq(&d->lock, flags); -} - -static uint64_t trace_work(void *data, uint64_t delay) -{ - struct dma_trace_data *d = (struct dma_trace_data *)data; - - trace_send(d); /* reschedule the trace copying work */ return DMA_TRACE_US; @@ -144,25 +113,41 @@ static uint64_t trace_work(void *data, uint64_t delay) int dma_trace_init(struct dma_trace_data *d) { - int err; + struct dma_trace_buf *buffer = &d->dmatb; + int ret; trace_buffer("dtn"); - /* init buffer elems */ - list_init(&d->config.elem_list); + /* allocate new buffer */ + buffer->addr = rballoc(RZONE_RUNTIME, RFLAGS_NONE, DMA_TRACE_LOCAL_SIZE); + if (buffer->addr == NULL) { + trace_buffer_error("ebm"); + return -ENOMEM; + } - /* allocate local DMA buffer */ - err = dma_trace_new_buffer(d, DMA_TRACE_LOCAL_SIZE); - if (err < 0) { - trace_buffer_error("ePb"); - return err; + /* init DMA copy context */ + ret = dma_copy_new(&d->dc, PLATFORM_TRACE_DMAC); + if (ret < 0) { + trace_buffer_error("edm"); + rfree(buffer->addr); + return ret; } + bzero(buffer->addr, DMA_TRACE_LOCAL_SIZE); + + /* initialise the DMA buffer */ + buffer->size = DMA_TRACE_LOCAL_SIZE; + buffer->w_ptr = buffer->r_ptr = buffer->addr; + buffer->end_addr = buffer->addr + buffer->size; + buffer->avail = 0; d->host_offset = 0; - trace_data = d; + d->enabled = 0; + list_init(&d->config.elem_list); work_init(&d->dmat_work, trace_work, d, WORK_ASYNC); spinlock_init(&d->lock); + trace_data = d; + return 0; } @@ -183,10 +168,18 @@ int dma_trace_host_buffer(struct dma_trace_data *d, struct dma_sg_elem *elem, return 0; } -void dma_trace_config_ready(struct dma_trace_data *d) +int dma_trace_enable(struct dma_trace_data *d) { + /* validate DMA context */ + if (d->dc.dmac == NULL || d->dc.chan < 0) { + trace_buffer_error("eem"); + return -ENODEV; + } + + /* TODO: fix crash when enabled */ + //d->enabled = 1; work_schedule_default(&d->dmat_work, DMA_TRACE_US); - d->ready = 1; + return 0; } void dtrace_event(const char *e, uint32_t length) @@ -226,6 +219,6 @@ void dtrace_event(const char *e, uint32_t length) spin_unlock_irq(&trace_data->lock, flags); /* schedule copy now if buffer > 50% full */ - if (trace_data->ready && buffer->avail >= (DMA_TRACE_LOCAL_SIZE / 2)) + if (trace_data->enabled && buffer->avail >= (DMA_TRACE_LOCAL_SIZE / 2)) work_reschedule_default(&trace_data->dmat_work, 100); } diff --git a/src/include/reef/alloc.h b/src/include/reef/alloc.h index 4e8a630..982af90 100644 --- a/src/include/reef/alloc.h +++ b/src/include/reef/alloc.h @@ -86,8 +86,8 @@ int rstrlen(const char *s); /* Heap save/restore contents and context for PM D0/D3 events */ uint32_t mm_pm_context_size(void); -int mm_pm_context_save(struct dma_sg_config *sg); -int mm_pm_context_restore(struct dma_sg_config *sg); +int mm_pm_context_save(struct dma_copy *dc, struct dma_sg_config *sg); +int mm_pm_context_restore(struct dma_copy *dc, struct dma_sg_config *sg); /* heap initialisation */ void init_heap(struct reef *reef); diff --git a/src/include/reef/audio/dma-trace.h b/src/include/reef/audio/dma-trace.h index 20f2e18..83db484 100644 --- a/src/include/reef/audio/dma-trace.h +++ b/src/include/reef/audio/dma-trace.h @@ -55,17 +55,18 @@ struct dma_trace_buf { struct dma_trace_data { struct dma_sg_config config; struct dma_trace_buf dmatb; + struct dma_copy dc; int32_t host_offset; uint32_t host_size; struct work dmat_work; - uint32_t ready; + uint32_t enabled; spinlock_t lock; }; int dma_trace_init(struct dma_trace_data *d); int dma_trace_host_buffer(struct dma_trace_data *d, struct dma_sg_elem *elem, uint32_t host_size); -void dma_trace_config_ready(struct dma_trace_data *d); +int dma_trace_enable(struct dma_trace_data *d); void dtrace_event(const char *e, uint32_t size); diff --git a/src/include/reef/dma.h b/src/include/reef/dma.h index 881332f..33d1c9a 100644 --- a/src/include/reef/dma.h +++ b/src/include/reef/dma.h @@ -36,6 +36,7 @@ #include <reef/list.h> #include <reef/lock.h> #include <reef/reef.h> +#include <reef/wait.h> /* DMA directions */ #define DMA_DIR_MEM_TO_MEM 0 /* local memcpy */ @@ -228,12 +229,29 @@ static inline uint32_t dma_sg_get_size(struct dma_sg_config *sg) return size; } +/* generic DMA DSP <-> Host copier */ + +struct dma_copy { + int chan; + struct dma *dmac; + completion_t complete; +}; + +/* init dma copy context */ +int dma_copy_new(struct dma_copy *dc, int dmac); + +/* free dma copy context resources */ +static inline void dma_copy_free(struct dma_copy *dc) +{ + dma_channel_put(dc->dmac, dc->chan); +} + /* DMA copy data from host to DSP */ -int dma_copy_from_host(struct dma_sg_config *host_sg, +int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size); /* DMA copy data from DSP to host */ -int dma_copy_to_host(struct dma_sg_config *host_sg, +int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, int32_t host_offset, void *local_ptr, int32_t size); #endif diff --git a/src/ipc/dma-copy.c b/src/ipc/dma-copy.c index b345ac9..75dd3bd 100644 --- a/src/ipc/dma-copy.c +++ b/src/ipc/dma-copy.c @@ -38,6 +38,11 @@ #include <reef/wait.h> #include <platform/dma.h> +/* tracing */ +#define trace_dma(__e) trace_event(TRACE_CLASS_DMA, __e) +#define trace_dma_error(__e) trace_error(TRACE_CLASS_DMA, __e) +#define tracev_dma(__e) tracev_event(TRACE_CLASS_DMA, __e) + static struct dma_sg_elem *sg_get_elem_at(struct dma_sg_config *host_sg, int32_t *offset) { @@ -60,7 +65,7 @@ static struct dma_sg_elem *sg_get_elem_at(struct dma_sg_config *host_sg, } /* host offset in beyond end of SG buffer */ - //trace_mem_error("eMs"); + trace_dma_error("ex0"); return NULL; } @@ -72,27 +77,17 @@ static void dma_complete(void *data, uint32_t type, struct dma_sg_elem *next) wait_completed(comp); } -int dma_copy_to_host(struct dma_sg_config *host_sg, int32_t host_offset, - void *local_ptr, int32_t size) +int dma_copy_to_host(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size) { struct dma_sg_config config; struct dma_sg_elem *host_sg_elem; struct dma_sg_elem local_sg_elem; - struct dma *dma = dma_get(DMA_ID_DMAC0); - completion_t complete; int32_t err; int32_t offset = host_offset; - int32_t chan; - if (dma == NULL) - return -ENODEV; - - /* get DMA channel from DMAC0 */ - chan = dma_channel_get(dma); - if (chan < 0) { - //trace_ipc_error("ePC"); - return chan; - } + if (size <= 0) + return 0; /* find host element with host_offset */ host_sg_elem = sg_get_elem_at(host_sg, &offset); @@ -100,7 +95,6 @@ int dma_copy_to_host(struct dma_sg_config *host_sg, int32_t host_offset, return -EINVAL; /* set up DMA configuration */ - complete.timeout = 100; /* wait 100 usecs for DMA to finish */ config.direction = DMA_DIR_LMEM_TO_HMEM; config.src_width = sizeof(uint32_t); config.dest_width = sizeof(uint32_t); @@ -113,21 +107,18 @@ int dma_copy_to_host(struct dma_sg_config *host_sg, int32_t host_offset, local_sg_elem.size = HOST_PAGE_SIZE - offset; list_item_prepend(&local_sg_elem.list, &config.elem_list); - dma_set_cb(dma, chan, DMA_IRQ_TYPE_LLIST, dma_complete, &complete); - /* transfer max PAGE size at a time to SG buffer */ while (size > 0) { /* start the DMA */ - wait_init(&complete); - dma_set_config(dma, chan, &config); - dma_start(dma, chan); + wait_init(&dc->complete); + dma_set_config(dc->dmac, dc->chan, &config); + dma_start(dc->dmac, dc->chan); /* wait for DMA to complete */ - err = wait_for_completion_timeout(&complete); + err = wait_for_completion_timeout(&dc->complete); if (err < 0) { - //trace_comp_error("eAp"); - dma_channel_put(dma, chan); + trace_dma_error("ex1"); return -EIO; } @@ -150,31 +141,20 @@ int dma_copy_to_host(struct dma_sg_config *host_sg, int32_t host_offset, } /* new host offset in SG buffer */ - dma_channel_put(dma, chan); return host_offset; } -int dma_copy_from_host(struct dma_sg_config *host_sg, int32_t host_offset, - void *local_ptr, int32_t size) +int dma_copy_from_host(struct dma_copy *dc, struct dma_sg_config *host_sg, + int32_t host_offset, void *local_ptr, int32_t size) { struct dma_sg_config config; struct dma_sg_elem *host_sg_elem; struct dma_sg_elem local_sg_elem; - struct dma *dma = dma_get(DMA_ID_DMAC0); - completion_t complete; int32_t err; int32_t offset = host_offset; - int32_t chan; - if (dma == NULL) - return -ENODEV; - - /* get DMA channel from DMAC0 */ - chan = dma_channel_get(dma); - if (chan < 0) { - //trace_ipc_error("ePC"); - return chan; - } + if (size <= 0) + return 0; /* find host element with host_offset */ host_sg_elem = sg_get_elem_at(host_sg, &offset); @@ -182,7 +162,6 @@ int dma_copy_from_host(struct dma_sg_config *host_sg, int32_t host_offset, return -EINVAL; /* set up DMA configuration */ - complete.timeout = 100; /* wait 100 usecs for DMA to finish */ config.direction = DMA_DIR_HMEM_TO_LMEM; config.src_width = sizeof(uint32_t); config.dest_width = sizeof(uint32_t); @@ -195,21 +174,18 @@ int dma_copy_from_host(struct dma_sg_config *host_sg, int32_t host_offset, local_sg_elem.size = HOST_PAGE_SIZE - offset; list_item_prepend(&local_sg_elem.list, &config.elem_list); - dma_set_cb(dma, chan, DMA_IRQ_TYPE_LLIST, dma_complete, &complete); - /* transfer max PAGE size at a time to SG buffer */ while (size > 0) { /* start the DMA */ - wait_init(&complete); - dma_set_config(dma, chan, &config); - dma_start(dma, chan); + wait_init(&dc->complete); + dma_set_config(dc->dmac, dc->chan, &config); + dma_start(dc->dmac, dc->chan); /* wait for DMA to complete */ - err = wait_for_completion_timeout(&complete); + err = wait_for_completion_timeout(&dc->complete); if (err < 0) { - //trace_comp_error("eAp"); - dma_channel_put(dma, chan); + trace_dma_error("ex2"); return -EIO; } @@ -232,6 +208,27 @@ int dma_copy_from_host(struct dma_sg_config *host_sg, int32_t host_offset, } /* new host offset in SG buffer */ - dma_channel_put(dma, chan); return host_offset; } + +int dma_copy_new(struct dma_copy *dc, int dmac) +{ + dc->dmac = dma_get(dmac); + if (dc->dmac == NULL) { + trace_dma_error("ec0"); + return -ENODEV; + } + + /* get DMA channel from DMAC0 */ + dc->chan = dma_channel_get(dc->dmac); + if (dc->chan < 0) { + trace_dma_error("ec1"); + return dc->chan; + } + + dc->complete.timeout = 100; /* wait 100 usecs for DMA to finish */ + dma_set_cb(dc->dmac, dc->chan, DMA_IRQ_TYPE_LLIST, dma_complete, + &dc->complete); + return 0; +} + diff --git a/src/ipc/intel-ipc.c b/src/ipc/intel-ipc.c index 4b56993..9b47ca9 100644 --- a/src/ipc/intel-ipc.c +++ b/src/ipc/intel-ipc.c @@ -629,7 +629,9 @@ static int ipc_dma_trace_config(uint32_t header) trace_ipc("DAp"); - dma_trace_config_ready(&_ipc->dmat); + err = dma_trace_enable(&_ipc->dmat); + if (err < 0) + goto error; /* write component values to the outbox */ reply.hdr.size = sizeof(reply); diff --git a/src/ipc/ipc.c b/src/ipc/ipc.c index 05de838..6c40d10 100644 --- a/src/ipc/ipc.c +++ b/src/ipc/ipc.c @@ -350,7 +350,6 @@ int ipc_init(struct reef *reef) /* init ipc data */ reef->ipc = rzalloc(RZONE_SYS, RFLAGS_NONE, sizeof(*reef->ipc)); reef->ipc->comp_data = rzalloc(RZONE_SYS, RFLAGS_NONE, SOF_IPC_MSG_MAX_SIZE); - reef->ipc->dmat.ready = 0; list_init(&reef->ipc->comp_list); diff --git a/src/lib/alloc.c b/src/lib/alloc.c index 0d9b07c..63f92de 100644 --- a/src/lib/alloc.c +++ b/src/lib/alloc.c @@ -573,7 +573,7 @@ uint32_t mm_pm_context_size(void) * must be disabled before calling this functions. No allocations are permitted after * calling this and before calling restore. */ -int mm_pm_context_save(struct dma_sg_config *sg) +int mm_pm_context_save(struct dma_copy *dc, struct dma_sg_config *sg) { uint32_t used; int32_t offset = 0; @@ -585,13 +585,13 @@ int mm_pm_context_save(struct dma_sg_config *sg) return -EINVAL; /* copy memory maps to SG */ - ret = dma_copy_to_host(sg, offset, + ret = dma_copy_to_host(dc, sg, offset, (void *)&memmap, sizeof(memmap)); if (ret < 0) return ret; /* copy system memory contents to SG */ - ret = dma_copy_to_host(sg, offset + ret, + ret = dma_copy_to_host(dc, sg, offset + ret, (void *)memmap.system.heap, (int32_t)(memmap.system.size)); if (ret < 0) return ret; @@ -611,19 +611,19 @@ int mm_pm_context_save(struct dma_sg_config *sg) * Restore the DSP memories to modules abd the system. This must be called immediately * after booting before any pipeline work. */ -int mm_pm_context_restore(struct dma_sg_config *sg) +int mm_pm_context_restore(struct dma_copy *dc, struct dma_sg_config *sg) { int32_t offset = 0; int32_t ret; /* copy memory maps from SG */ - ret = dma_copy_from_host(sg, offset, + ret = dma_copy_from_host(dc, sg, offset, (void *)&memmap, sizeof(memmap)); if (ret < 0) return ret; /* copy system memory contents from SG */ - ret = dma_copy_to_host(sg, offset + ret, + ret = dma_copy_to_host(dc, sg, offset + ret, (void *)memmap.system.heap, (int32_t)(memmap.system.size)); if (ret < 0) return ret; diff --git a/src/lib/trace.c b/src/lib/trace.c index bdd50ae..6f707c3 100644 --- a/src/lib/trace.c +++ b/src/lib/trace.c @@ -77,15 +77,11 @@ void _trace_error(uint32_t event) void _trace_event(uint32_t event) { - volatile uint64_t dt[2]; - uint32_t et = (event & 0xff000000); + uint64_t dt[2]; if (!trace.enable) return; - if (et == TRACE_CLASS_DMA) - return; - dt[0] = platform_timer_get(platform_timer); dt[1] = event; dtrace_event((const char*)dt, sizeof(uint64_t) * 2); diff --git a/src/platform/baytrail/include/platform/platform.h b/src/platform/baytrail/include/platform/platform.h index ff3a117..4d63f7b 100644 --- a/src/platform/baytrail/include/platform/platform.h +++ b/src/platform/baytrail/include/platform/platform.h @@ -82,6 +82,9 @@ struct reef; /* the interval of DMA trace copying */ #define DMA_TRACE_US 500000 +/* DMAC used for trace DMA */ +#define PLATFORM_TRACE_DMAC DMA_ID_DMAC0 + /* Platform defined panic code */ #define platform_panic(__x) \ shim_write(SHIM_IPCXL, ((shim_read(SHIM_IPCXL) & 0xc0000000) |\ -- 1.9.1

1 0

[Sound-open-firmware] [PATCH 2/2] Forward trace event to DMA buffer.
by yan.wang＠linux.intel.com 13 Oct '17

13 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> 1. Ignore DMA trace event when forwarding for avoiding dead lock because DMA tracing uses DMA API to copy trace event. 2. Add _trace_error() API to send error event by mail box at the same time too when copying error event by DMA. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- src/include/reef/trace.h | 4 +++- src/lib/trace.c | 28 +++++++++++++++++++++++++++- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/src/include/reef/trace.h b/src/include/reef/trace.h index 300e8d8..cdd8158 100644 --- a/src/include/reef/trace.h +++ b/src/include/reef/trace.h @@ -94,6 +94,7 @@ #define TRACEE 1 void _trace_event(uint32_t event); +void _trace_error(uint32_t event); void trace_off(void); void trace_init(struct reef * reef); @@ -117,7 +118,8 @@ void trace_init(struct reef * reef); /* error tracing */ #if TRACEE -#define trace_error(__c, __e) trace_event(__c, __e) +#define trace_error(__c, __e) \ + _trace_error(__c | (__e[0] << 16) | (__e[1] <<8) | __e[2]) #else #define trace_error(__c, __e) #endif diff --git a/src/lib/trace.c b/src/lib/trace.c index 33e1466..b0b32d6 100644 --- a/src/lib/trace.c +++ b/src/lib/trace.c @@ -34,6 +34,7 @@ #include <arch/cache.h> #include <platform/timer.h> #include <reef/lock.h> +#include <reef/audio/dma-trace.h> #include <stdint.h> struct trace { @@ -44,7 +45,7 @@ struct trace { static struct trace trace; -void _trace_event(uint32_t event) +void _trace_error(uint32_t event) { unsigned long flags; volatile uint32_t *t; @@ -52,6 +53,10 @@ void _trace_event(uint32_t event) if (!trace.enable) return; + /* save event to DMA tracing buffer */ + _trace_event(event); + + /* send event by mail box too. */ spin_lock_irq(&trace.lock, flags); /* write timestamp and event to trace buffer */ @@ -70,6 +75,27 @@ void _trace_event(uint32_t event) spin_unlock_irq(&trace.lock, flags); } +void _trace_event(uint32_t event) +{ + unsigned long flags; + volatile uint64_t dt[2]; + volatile uint32_t et = (event & 0xff000000); + + if (!trace.enable) + return; + + if (et == TRACE_CLASS_DMA) + return; + + spin_lock_irq(&trace.lock, flags); + + dt[0] = platform_timer_get(platform_timer); + dt[1] = event; + dtrace_event((const char*)dt, sizeof(uint64_t) * 2); + + spin_unlock_irq(&trace.lock, flags); +} + void trace_off(void) { trace.enable = 0; -- 2.7.4

3 2

[Sound-open-firmware] [PATCH] scheduler: enforce locking for edf_schedule list operations
by Liam Girdwood 13 Oct '17

13 Oct '17

make sure our task list is protected by lock for readers and writers. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- src/lib/schedule.c | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/src/lib/schedule.c b/src/lib/schedule.c index 993f94a..ab0602b 100644 --- a/src/lib/schedule.c +++ b/src/lib/schedule.c @@ -102,10 +102,15 @@ static inline struct task *edf_get_next(uint64_t current, uint64_t delta; uint64_t deadline; int reschedule = 0; + uint32_t flags; + spin_lock_irq(&sch->lock, flags); + /* any tasks in the scheduler ? */ - if (list_is_empty(&sch->list)) + if (list_is_empty(&sch->list)) { + spin_unlock_irq(&sch->lock, flags); return NULL; + } /* check every queued or running task in list */ list_for_item_safe(clist, tlist, &sch->list) { @@ -142,6 +147,7 @@ static inline struct task *edf_get_next(uint64_t current, } } + spin_unlock_irq(&sch->lock, flags); return next_task; } @@ -164,20 +170,15 @@ static struct task *schedule_edf(void) struct task *task; struct task *next_plus1_task = NULL; uint64_t current; - uint32_t flags; tracev_pipe("edf"); - /* get next component scheduled */ - spin_lock_irq(&sch->lock, flags); - /* get the current time */ current = platform_timer_get(platform_timer); /* get next task to be scheduled */ task = edf_get_next(current, NULL); - spin_unlock_irq(&sch->lock, flags); interrupt_clear(PLATFORM_SCHEDULE_IRQ); /* any tasks ? */ -- 1.9.1

1 1

[Sound-open-firmware] [PATCH] rmbox: move trace into separate parser function to ease future work.
by Liam Girdwood 13 Oct '17

13 Oct '17

Move trace handler into separate function to make it easier to add new trace features. Make sure we only support 64 bit timestamps. Signed-off-by: Liam Girdwood <liam.r.girdwood(a)linux.intel.com> --- rmbox/rmbox.c | 159 ++++++++++++++++++++++++++++++++++++++++------------------ 1 file changed, 109 insertions(+), 50 deletions(-) diff --git a/rmbox/rmbox.c b/rmbox/rmbox.c index d650d30..9313f4b 100644 --- a/rmbox/rmbox.c +++ b/rmbox/rmbox.c @@ -82,6 +82,9 @@ #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0])) + +#define TRACE_BLOCK_SIZE 8 + static inline char get_char(uint32_t val, int idx) { char c = (val >> (idx * 8)) & 0xff; @@ -94,58 +97,41 @@ static inline char get_char(uint32_t val, int idx) static void usage(char *name) { fprintf(stdout, "Usage %s <option(s)> <file(s)>\n", name); + fprintf(stdout, "%s:\t \t\t\tDisplay mailbox contents\n", name); fprintf(stdout, "%s:\t -i infile -o outfile\tDump infile contents to outfile\n", name); fprintf(stdout, "%s:\t -c\t\t\tSet timestamp clock in MHz\n", name); fprintf(stdout, "%s:\t -s\t\t\tTake a snapshot of state\n", name); + fprintf(stdout, "%s:\t -t\t\t\tDisplay trace data\n", name); exit(0); } -static float to_usecs(uint64_t time, float clk) +static double to_usecs(uint64_t time, double clk) { /* trace timestamp uses CPU system clock at default 25MHz ticks */ // TODO: support variable clock rates return (double)time / clk; } -static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, float clk, uint64_t align) +static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, double clk) { const char *trace; uint32_t class; uint64_t delta = val - *timestamp; - float fdelta = to_usecs(delta, clk); - float us = 0.0f; - uint64_t s = 0, ms = 0; - uint64_t ds = 0, dms = 0; + double fdelta = to_usecs(delta, clk); + double us = 0.0f; /* timestamp or value ? */ - if ((addr % align) == 0) { - /* buffer wrap ? */ - if (val < *timestamp) { - printf("----------------------------------------" - "----------------------------------------" - "--------------------------------------\n"); - delta = 0; - fdelta = 0.0; - } else { - delta = val - *timestamp; - fdelta = to_usecs(delta, clk); - } + if ((addr % (TRACE_BLOCK_SIZE * 2)) == 0) { + + delta = val - *timestamp; + fdelta = to_usecs(delta, clk); + + /* 64-bit timestamp */ + us = to_usecs(val, clk); + + printf("[%6.6f]\tdelta [%6.6f]\t", + us / 1000000.0 , fdelta / 1000000.0); - if (align == 8) { - /* 32-bit timestamp */ - printf("trace.io: timestamp 0x%16.16lx (%2.2f us) \tdelta 0x%16.16lx (%2.2f us)\t", - (uint64_t)val, to_usecs(val, clk), - (uint64_t)delta, fdelta); - } else { - /* 64-bit timestamp */ - us = to_usecs(val, clk); - s = us / 1000000; - ms = us / 1000 - s * 1000; - ds = fdelta / 1000000; - dms = fdelta / 1000 - ds * 1000; - printf("trace.io: timestamp [%lu.%lu] \tdelta [%lu.%lu]\t", - s, ms, ds, dms); - } *timestamp = val; return; } @@ -206,6 +192,68 @@ static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, float c (char)(val >> 16), (char)(val >> 8), (char)val); } +static int trace_read(const char *in_file, const char *out_file, double clk, + int offset) +{ + int count, i; + FILE *in_fd = NULL, *out_fd = NULL; + char c, tmp[TRACE_BLOCK_SIZE] = {0}; + uint64_t addr = 0, val, timestamp = 0; + + in_fd = fopen(in_file, "r"); + if (in_fd == NULL) { + fprintf(stderr, "error: unable to open %s for reading %d\n", + in_file, errno); + return -EIO; + } + + if (out_file == NULL) + goto trace; + + out_fd = fopen(out_file, "w"); + if (out_fd == NULL) { + fprintf(stderr, "error: unable to open %s for writing %d\n", + out_file, errno); + } + +trace: + fprintf(stdout, "using %2.2fMHz timestamp clock\n", clk); + + while (1) { + count = fread(&tmp[0], 1, TRACE_BLOCK_SIZE, in_fd); + if (count != TRACE_BLOCK_SIZE) + break; + + if (addr < offset) { + addr += TRACE_BLOCK_SIZE; + continue; + } + + val = *((uint64_t*)tmp); + + for (i = 0; i < TRACE_BLOCK_SIZE / 2; i++) { + c = tmp[i]; + tmp[i] = tmp[TRACE_BLOCK_SIZE - i - 1]; + tmp[TRACE_BLOCK_SIZE - i - 1] = c; + } + + if (val == 0) + break; + + show_trace(val, addr, &timestamp, clk); + + if (out_fd) { + count = fwrite(&tmp[0], 1, TRACE_BLOCK_SIZE, out_fd); + if (count != TRACE_BLOCK_SIZE) + break; + } + + addr += TRACE_BLOCK_SIZE; + } + + return 0; +} + static void show_debug(uint32_t val, uint32_t addr) { printf("debug: 0x%x (%2.2d) = \t0x%8.8x \t(%8.8d) \t|%c%c%c%c|\n", @@ -233,7 +281,7 @@ static const char *debugfs[] = { static int snapshot(const char *name) { - const char *path = "/sys/kernel/debug"; + const char *path = "/sys/kernel/debug/sof"; uint32_t val, addr; char pinname[64], poutname[64], buffer[128]; FILE *in_fd, *out_fd; @@ -290,15 +338,15 @@ static int snapshot(const char *name) int main(int argc, char *argv[]) { - int opt, count; + int opt, count, trace = 0; const char * out_file = NULL, *in_file = "/sys/kernel/debug/sof/mbox"; FILE *in_fd = NULL, *out_fd = NULL; char c, tmp[8] = {0}; uint64_t addr = 0, val, timestamp = 0, align = 4, i; - float clk = 19.2f; - uint32_t is_dma_trace = 0; + double clk = 19.2; + int title_dbg_done = 0, title_exp_done = 0; - while ((opt = getopt(argc, argv, "ho:i:s:m:c:t:")) != -1) { + while ((opt = getopt(argc, argv, "ho:i:s:m:c:t")) != -1) { switch (opt) { case 'o': out_file = optarg; @@ -307,9 +355,7 @@ int main(int argc, char *argv[]) in_file = optarg; break; case 't': - in_file = optarg; - is_dma_trace = 1; - align = 8; + trace = 1; break; case 'c': clk = atof(optarg); @@ -322,6 +368,10 @@ int main(int argc, char *argv[]) } } + /* trace requested ? */ + if (trace) + return trace_read("/sys/kernel/debug/sof/trace", out_file, clk, 0); + /* open infile for reading */ in_fd = fopen(in_file, "r"); if (in_fd == NULL) { @@ -359,17 +409,21 @@ convert: tmp[align - i - 1] = c; } - if (is_dma_trace) - show_trace(val, addr, &timestamp, clk, align * 2); - else if (addr >= MAILBOX_TRACE_OFFSET && - addr < MAILBOX_TRACE_OFFSET + MAILBOX_TRACE_SIZE) - show_trace(val, addr, &timestamp, clk, align * 2); - else if (addr >= MAILBOX_DEBUG_OFFSET && - addr < MAILBOX_DEBUG_OFFSET + MAILBOX_DEBUG_SIZE) + if (addr >= MAILBOX_DEBUG_OFFSET && + addr < MAILBOX_DEBUG_OFFSET + MAILBOX_DEBUG_SIZE) { + + if (!title_dbg_done++) + fprintf(stdout, "\nDebug log:\n"); + show_debug(val, addr); - else if (addr >= MAILBOX_EXCEPTION_OFFSET && - addr < MAILBOX_EXCEPTION_OFFSET + MAILBOX_EXCEPTION_SIZE) + } else if (addr >= MAILBOX_EXCEPTION_OFFSET && + addr < MAILBOX_EXCEPTION_OFFSET + MAILBOX_EXCEPTION_SIZE) { + + if (!title_exp_done++) + fprintf(stdout, "\nException log:\n"); + show_exception(val, addr); + } if (out_fd) { count = fwrite(&tmp[0], 1, align, out_fd); @@ -380,6 +434,11 @@ convert: addr += align; } + /* read debug */ + fprintf(stdout, "\nError log:\n"); + trace_read("/sys/kernel/debug/sof/mbox", out_file, clk, + MAILBOX_TRACE_OFFSET); + /* close files */ fclose(in_fd); if (out_fd) -- 1.9.1

1 0

[Sound-open-firmware] [PATCH] Use new output format for 64-bit timestamp.
by yan.wang＠linux.intel.com 13 Oct '17

13 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> 1. Use [second.microsecond] for 64-bit timestamp. 2. Keep previous format for 32-bit timestamp. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- rmbox/rmbox.c | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/rmbox/rmbox.c b/rmbox/rmbox.c index 638158c..d650d30 100644 --- a/rmbox/rmbox.c +++ b/rmbox/rmbox.c @@ -113,6 +113,9 @@ static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, float c uint32_t class; uint64_t delta = val - *timestamp; float fdelta = to_usecs(delta, clk); + float us = 0.0f; + uint64_t s = 0, ms = 0; + uint64_t ds = 0, dms = 0; /* timestamp or value ? */ if ((addr % align) == 0) { @@ -128,9 +131,21 @@ static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, float c fdelta = to_usecs(delta, clk); } - printf("trace.io: timestamp 0x%16.16lx (%2.2f us) \tdelta 0x%16.16lx (%2.2f us)\t", - (uint64_t)val, to_usecs(val, clk), - (uint64_t)delta, fdelta); + if (align == 8) { + /* 32-bit timestamp */ + printf("trace.io: timestamp 0x%16.16lx (%2.2f us) \tdelta 0x%16.16lx (%2.2f us)\t", + (uint64_t)val, to_usecs(val, clk), + (uint64_t)delta, fdelta); + } else { + /* 64-bit timestamp */ + us = to_usecs(val, clk); + s = us / 1000000; + ms = us / 1000 - s * 1000; + ds = fdelta / 1000000; + dms = fdelta / 1000 - ds * 1000; + printf("trace.io: timestamp [%lu.%lu] \tdelta [%lu.%lu]\t", + s, ms, ds, dms); + } *timestamp = val; return; } -- 2.7.4

2 1

[Sound-open-firmware] [Sound-open-firmware-tools][PATCH] Add option "-t" to process DMA trace event with 64-bit tempstamp.
by yan.wang＠linux.intel.com 13 Oct '17

13 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> 1. Timestamp is changed to 64-bit width. 2. Trace event is still 32-bit. High 32-bit of 64-bit is ignored. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- rmbox/rmbox.c | 64 ++++++++++++++++++++++++++++++++--------------------------- 1 file changed, 35 insertions(+), 29 deletions(-) diff --git a/rmbox/rmbox.c b/rmbox/rmbox.c index 3ef6fb4..638158c 100644 --- a/rmbox/rmbox.c +++ b/rmbox/rmbox.c @@ -100,23 +100,22 @@ static void usage(char *name) exit(0); } -static float to_usecs(uint32_t time, float clk) +static float to_usecs(uint64_t time, float clk) { /* trace timestamp uses CPU system clock at default 25MHz ticks */ // TODO: support variable clock rates - return (float)time / clk; + return (double)time / clk; } -static void show_trace(uint32_t val, uint32_t addr, uint32_t *timestamp, float clk) +static void show_trace(uint64_t val, uint64_t addr, uint64_t *timestamp, float clk, uint64_t align) { const char *trace; uint32_t class; - uint32_t delta = val - *timestamp; + uint64_t delta = val - *timestamp; float fdelta = to_usecs(delta, clk); /* timestamp or value ? */ - if ((addr % 8) == 0) { - + if ((addr % align) == 0) { /* buffer wrap ? */ if (val < *timestamp) { printf("----------------------------------------" @@ -129,9 +128,9 @@ static void show_trace(uint32_t val, uint32_t addr, uint32_t *timestamp, float c fdelta = to_usecs(delta, clk); } - printf("trace.io: timestamp 0x%8.8x (%2.2f us) \tdelta 0x%8.8x (%2.2f us)\t", - (uint32_t)val, to_usecs(val, clk), - (uint32_t)delta, fdelta); + printf("trace.io: timestamp 0x%16.16lx (%2.2f us) \tdelta 0x%16.16lx (%2.2f us)\t", + (uint64_t)val, to_usecs(val, clk), + (uint64_t)delta, fdelta); *timestamp = val; return; } @@ -279,11 +278,12 @@ int main(int argc, char *argv[]) int opt, count; const char * out_file = NULL, *in_file = "/sys/kernel/debug/sof/mbox"; FILE *in_fd = NULL, *out_fd = NULL; - char c, tmp[4] = {0}; - uint32_t addr = 0, val, timestamp = 0; + char c, tmp[8] = {0}; + uint64_t addr = 0, val, timestamp = 0, align = 4, i; float clk = 19.2f; + uint32_t is_dma_trace = 0; - while ((opt = getopt(argc, argv, "ho:i:s:m:c:")) != -1) { + while ((opt = getopt(argc, argv, "ho:i:s:m:c:t:")) != -1) { switch (opt) { case 'o': out_file = optarg; @@ -291,6 +291,11 @@ int main(int argc, char *argv[]) case 'i': in_file = optarg; break; + case 't': + in_file = optarg; + is_dma_trace = 1; + align = 8; + break; case 'c': clk = atof(optarg); break; @@ -327,36 +332,37 @@ convert: fprintf(stdout, "using %2.2fMHz timestamp clock\n", clk); while (1) { - count = fread(&tmp[0], 1, 4, in_fd); - if (count != 4) + count = fread(&tmp[0], 1, align, in_fd); + if (count != align) break; - val = *((uint32_t*)tmp); + val = *((uint64_t*)tmp); - c = tmp[0]; - tmp[0] = tmp[3]; - tmp[3] = c; - c = tmp[1]; - tmp[1] = tmp[2]; - tmp[2] = c; + for (i = 0; i < align / 2; i++) { + c = tmp[i]; + tmp[i] = tmp[align - i - 1]; + tmp[align - i - 1] = c; + } - if (addr >= MAILBOX_TRACE_OFFSET && - addr < MAILBOX_TRACE_OFFSET + MAILBOX_TRACE_SIZE) - show_trace(val, addr, &timestamp, clk); + if (is_dma_trace) + show_trace(val, addr, &timestamp, clk, align * 2); + else if (addr >= MAILBOX_TRACE_OFFSET && + addr < MAILBOX_TRACE_OFFSET + MAILBOX_TRACE_SIZE) + show_trace(val, addr, &timestamp, clk, align * 2); else if (addr >= MAILBOX_DEBUG_OFFSET && - addr < MAILBOX_DEBUG_OFFSET + MAILBOX_DEBUG_SIZE) + addr < MAILBOX_DEBUG_OFFSET + MAILBOX_DEBUG_SIZE) show_debug(val, addr); else if (addr >= MAILBOX_EXCEPTION_OFFSET && - addr < MAILBOX_EXCEPTION_OFFSET + MAILBOX_EXCEPTION_SIZE) + addr < MAILBOX_EXCEPTION_OFFSET + MAILBOX_EXCEPTION_SIZE) show_exception(val, addr); if (out_fd) { - count = fwrite(&tmp[0], 1, 4, out_fd); - if (count != 4) + count = fwrite(&tmp[0], 1, align, out_fd); + if (count != align) break; } - addr += 4; + addr += align; } /* close files */ -- 2.7.4

3 2

[Sound-open-firmware] [PATCH 1/2] Modify API of DMA tracing for forwading trace to DMA buffer.
by yan.wang＠linux.intel.com 12 Oct '17

12 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> 1. Change trace data coping API for current trace event data including 64-bit timestamp. 2. Remove trace event of DMA tracing for avoiding dead lock. 3. If DMA tracing is ready, send event data when the data size is half full or the DMA tracing buffer arrive at the end. Otherwise, overwrite the data directly. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- src/audio/dma-trace.c | 22 ++++++++-------------- src/include/reef/audio/dma-trace.h | 3 ++- src/ipc/ipc.c | 1 + 3 files changed, 11 insertions(+), 15 deletions(-) diff --git a/src/audio/dma-trace.c b/src/audio/dma-trace.c index d725fcf..123853c 100644 --- a/src/audio/dma-trace.c +++ b/src/audio/dma-trace.c @@ -93,8 +93,6 @@ static void trace_send(struct dma_trace_data *d) d->host_offset += size; buffer->r_ptr += size; - - trace_buffer("dts"); } static uint64_t trace_work(void *data, uint64_t delay) @@ -150,24 +148,20 @@ int dma_trace_host_buffer(struct dma_trace_data *d, struct dma_sg_elem *elem, void dma_trace_config_ready(struct dma_trace_data *d) { work_schedule_default(&d->dmat_work, DMA_TRACE_US); + d->ready = 1; } -void dtrace_event(char *e) +void dtrace_event(const char *e, uint32_t length) { struct dma_trace_buf *buffer = NULL; - int length = rstrlen(e); int margin = 0; - if (trace_data == NULL || length < 1) { - trace_buffer_error("ele"); + if (trace_data == NULL || length < 1) return; - } buffer = &trace_data->dmatb; - if (buffer == NULL) { - trace_buffer_error("ele"); + if (buffer == NULL) return; - } margin = buffer->end_addr - buffer->w_ptr; @@ -178,17 +172,17 @@ void dtrace_event(char *e) memcpy(buffer->w_ptr, e, margin); buffer->w_ptr += margin; - trace_send(trace_data); + if(trace_data->ready) + trace_send(trace_data); + buffer->w_ptr = buffer->r_ptr = buffer->addr; bzero(buffer->addr, buffer->size); memcpy(buffer->w_ptr, e + margin, length - margin); buffer->w_ptr += length -margin; - - trace_buffer("ebs"); } length = buffer->w_ptr - buffer->r_ptr; - if (length >= (DMA_TRACE_LOCAL_SIZE / 2)) + if (trace_data->ready && length >= (DMA_TRACE_LOCAL_SIZE / 2)) trace_send(trace_data); } diff --git a/src/include/reef/audio/dma-trace.h b/src/include/reef/audio/dma-trace.h index 9ee88a0..438fd2f 100644 --- a/src/include/reef/audio/dma-trace.h +++ b/src/include/reef/audio/dma-trace.h @@ -57,6 +57,7 @@ struct dma_trace_data { int32_t host_offset; uint32_t host_size; struct work dmat_work; + uint32_t ready; }; int dma_trace_init(struct dma_trace_data *d); @@ -64,6 +65,6 @@ int dma_trace_host_buffer(struct dma_trace_data *d, struct dma_sg_elem *elem, uint32_t host_size); void dma_trace_config_ready(struct dma_trace_data *d); -void dtrace_event(char *e); +void dtrace_event(const char *e, uint32_t size); #endif diff --git a/src/ipc/ipc.c b/src/ipc/ipc.c index 6c40d10..05de838 100644 --- a/src/ipc/ipc.c +++ b/src/ipc/ipc.c @@ -350,6 +350,7 @@ int ipc_init(struct reef *reef) /* init ipc data */ reef->ipc = rzalloc(RZONE_SYS, RFLAGS_NONE, sizeof(*reef->ipc)); reef->ipc->comp_data = rzalloc(RZONE_SYS, RFLAGS_NONE, SOF_IPC_MSG_MAX_SIZE); + reef->ipc->dmat.ready = 0; list_init(&reef->ipc->comp_list); -- 2.7.4

2 1

[Sound-open-firmware] [PATCH] Use "const char*" instead of "char*" in rstrlen().
by yan.wang＠linux.intel.com 12 Oct '17

12 Oct '17

From: Yan Wang <yan.wang(a)linux.intel.com> It is unnecessary to use "char*" for calculating string length. Signed-off-by: Yan Wang <yan.wang(a)linux.intel.com> --- src/include/reef/alloc.h | 2 +- src/lib/lib.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/include/reef/alloc.h b/src/include/reef/alloc.h index a589959..4e8a630 100644 --- a/src/include/reef/alloc.h +++ b/src/include/reef/alloc.h @@ -82,7 +82,7 @@ void rbfree(void *ptr); /* utility */ void bzero(void *s, size_t n); void *memset(void *s, int c, size_t n); -int rstrlen(char *s); +int rstrlen(const char *s); /* Heap save/restore contents and context for PM D0/D3 events */ uint32_t mm_pm_context_size(void); diff --git a/src/lib/lib.c b/src/lib/lib.c index a1c9933..7e4c09d 100644 --- a/src/lib/lib.c +++ b/src/lib/lib.c @@ -99,9 +99,9 @@ void *memset(void *s, int c, size_t n) } /* generic strlen - TODO: can be optimsed for ARCH ? */ -int rstrlen(char *s) +int rstrlen(const char *s) { - char *p = s; + const char *p = s; while(*p++ != 0); return (p - s) - 1; -- 2.7.4

2 1