Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 570d0176 authored by Sinan Kaya's avatar Sinan Kaya Committed by Vinod Koul
Browse files

dmaengine: qcom_hidma: add debugfs hooks 



Add debugfs hooks for debugging the execution behavior of the DMA
channel. The debugfs hooks get initialized by the probe function and
uninitialized by the remove function.

A stats file is created in debugfs. The stats file will show the
information about each HIDMA channel as well as each asynchronous job
queued and completed at a given time.

Signed-off-by: default avatarSinan Kaya <okaya@codeaurora.org>
Signed-off-by: default avatarVinod Koul <vinod.koul@intel.com>
parent d1615ca2

drivers/dma/qcom/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -2,4 +2,4 @@ obj-$(CONFIG_QCOM_BAM_DMA) += bam_dma.o 
obj-$(CONFIG_QCOM_HIDMA_MGMT) += hdma_mgmt.o

hdma_mgmt-objs	 := hidma_mgmt.o hidma_mgmt_sys.o

obj-$(CONFIG_QCOM_HIDMA) +=  hdma.o

hdma-objs        := hidma_ll.o hidma.o
 
hdma-objs        := hidma_ll.o hidma.o hidma_dbg.o

drivers/dma/qcom/hidma.c

+4 −1
Original line number Diff line number Diff line 
/*

 * Qualcomm Technologies HIDMA DMA engine interface

 *

 * Copyright (c) 2015, The Linux Foundation. All rights reserved.

 * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and
@@ -644,6 +644,7 @@ static int hidma_probe(struct platform_device *pdev) 


	dmadev->irq = chirq;

	tasklet_init(&dmadev->task, hidma_issue_task, (unsigned long)dmadev);

	hidma_debug_init(dmadev);

	dev_info(&pdev->dev, "HI-DMA engine driver registration complete\n");

	platform_set_drvdata(pdev, dmadev);

	pm_runtime_mark_last_busy(dmadev->ddev.dev);
@@ -651,6 +652,7 @@ static int hidma_probe(struct platform_device *pdev) 
	return 0;



uninit:

	hidma_debug_uninit(dmadev);

	hidma_ll_uninit(dmadev->lldev);

dmafree:

	if (dmadev)
@@ -668,6 +670,7 @@ static int hidma_remove(struct platform_device *pdev) 
	pm_runtime_get_sync(dmadev->ddev.dev);

	dma_async_device_unregister(&dmadev->ddev);

	devm_free_irq(dmadev->ddev.dev, dmadev->irq, dmadev->lldev);

	hidma_debug_uninit(dmadev);

	hidma_ll_uninit(dmadev->lldev);

	hidma_free(dmadev);

drivers/dma/qcom/hidma.h

+2 −0
Original line number Diff line number Diff line
@@ -153,4 +153,6 @@ int hidma_ll_uninit(struct hidma_lldev *llhndl); 
irqreturn_t hidma_ll_inthandler(int irq, void *arg);

void hidma_cleanup_pending_tre(struct hidma_lldev *llhndl, u8 err_info,

				u8 err_code);

int hidma_debug_init(struct hidma_dev *dmadev);

void hidma_debug_uninit(struct hidma_dev *dmadev);

#endif

drivers/dma/qcom/hidma_dbg.c

0 → 100644
+217 −0
Original line number Diff line number Diff line 
/*

 * Qualcomm Technologies HIDMA debug file

 *

 * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 */



#include <linux/debugfs.h>

#include <linux/device.h>

#include <linux/list.h>

#include <linux/pm_runtime.h>



#include "hidma.h"



static void hidma_ll_chstats(struct seq_file *s, void *llhndl, u32 tre_ch)

{

	struct hidma_lldev *lldev = llhndl;

	struct hidma_tre *tre;

	u32 length;

	dma_addr_t src_start;

	dma_addr_t dest_start;

	u32 *tre_local;



	if (tre_ch >= lldev->nr_tres) {

		dev_err(lldev->dev, "invalid TRE number in chstats:%d", tre_ch);

		return;

	}

	tre = &lldev->trepool[tre_ch];

	seq_printf(s, "------Channel %d -----\n", tre_ch);

	seq_printf(s, "allocated=%d\n", atomic_read(&tre->allocated));

	seq_printf(s, "queued = 0x%x\n", tre->queued);

	seq_printf(s, "err_info = 0x%x\n", tre->err_info);

	seq_printf(s, "err_code = 0x%x\n", tre->err_code);

	seq_printf(s, "status = 0x%x\n", tre->status);

	seq_printf(s, "idx = 0x%x\n", tre->idx);

	seq_printf(s, "dma_sig = 0x%x\n", tre->dma_sig);

	seq_printf(s, "dev_name=%s\n", tre->dev_name);

	seq_printf(s, "callback=%p\n", tre->callback);

	seq_printf(s, "data=%p\n", tre->data);

	seq_printf(s, "tre_index = 0x%x\n", tre->tre_index);



	tre_local = &tre->tre_local[0];

	src_start = tre_local[HIDMA_TRE_SRC_LOW_IDX];

	src_start = ((u64) (tre_local[HIDMA_TRE_SRC_HI_IDX]) << 32) + src_start;

	dest_start = tre_local[HIDMA_TRE_DEST_LOW_IDX];

	dest_start += ((u64) (tre_local[HIDMA_TRE_DEST_HI_IDX]) << 32);

	length = tre_local[HIDMA_TRE_LEN_IDX];



	seq_printf(s, "src=%pap\n", &src_start);

	seq_printf(s, "dest=%pap\n", &dest_start);

	seq_printf(s, "length = 0x%x\n", length);

}



static void hidma_ll_devstats(struct seq_file *s, void *llhndl)

{

	struct hidma_lldev *lldev = llhndl;



	seq_puts(s, "------Device -----\n");

	seq_printf(s, "lldev init = 0x%x\n", lldev->initialized);

	seq_printf(s, "trch_state = 0x%x\n", lldev->trch_state);

	seq_printf(s, "evch_state = 0x%x\n", lldev->evch_state);

	seq_printf(s, "chidx = 0x%x\n", lldev->chidx);

	seq_printf(s, "nr_tres = 0x%x\n", lldev->nr_tres);

	seq_printf(s, "trca=%p\n", lldev->trca);

	seq_printf(s, "tre_ring=%p\n", lldev->tre_ring);

	seq_printf(s, "tre_ring_handle=%pap\n", &lldev->tre_dma);

	seq_printf(s, "tre_ring_size = 0x%x\n", lldev->tre_ring_size);

	seq_printf(s, "tre_processed_off = 0x%x\n", lldev->tre_processed_off);

	seq_printf(s, "pending_tre_count=%d\n", lldev->pending_tre_count);

	seq_printf(s, "evca=%p\n", lldev->evca);

	seq_printf(s, "evre_ring=%p\n", lldev->evre_ring);

	seq_printf(s, "evre_ring_handle=%pap\n", &lldev->evre_dma);

	seq_printf(s, "evre_ring_size = 0x%x\n", lldev->evre_ring_size);

	seq_printf(s, "evre_processed_off = 0x%x\n", lldev->evre_processed_off);

	seq_printf(s, "tre_write_offset = 0x%x\n", lldev->tre_write_offset);

}



/*

 * hidma_chan_stats: display HIDMA channel statistics

 *

 * Display the statistics for the current HIDMA virtual channel device.

 */

static int hidma_chan_stats(struct seq_file *s, void *unused)

{

	struct hidma_chan *mchan = s->private;

	struct hidma_desc *mdesc;

	struct hidma_dev *dmadev = mchan->dmadev;



	pm_runtime_get_sync(dmadev->ddev.dev);

	seq_printf(s, "paused=%u\n", mchan->paused);

	seq_printf(s, "dma_sig=%u\n", mchan->dma_sig);

	seq_puts(s, "prepared\n");

	list_for_each_entry(mdesc, &mchan->prepared, node)

		hidma_ll_chstats(s, mchan->dmadev->lldev, mdesc->tre_ch);



	seq_puts(s, "active\n");

	list_for_each_entry(mdesc, &mchan->active, node)

		hidma_ll_chstats(s, mchan->dmadev->lldev, mdesc->tre_ch);



	seq_puts(s, "completed\n");

	list_for_each_entry(mdesc, &mchan->completed, node)

		hidma_ll_chstats(s, mchan->dmadev->lldev, mdesc->tre_ch);



	hidma_ll_devstats(s, mchan->dmadev->lldev);

	pm_runtime_mark_last_busy(dmadev->ddev.dev);

	pm_runtime_put_autosuspend(dmadev->ddev.dev);

	return 0;

}



/*

 * hidma_dma_info: display HIDMA device info

 *

 * Display the info for the current HIDMA device.

 */

static int hidma_dma_info(struct seq_file *s, void *unused)

{

	struct hidma_dev *dmadev = s->private;

	resource_size_t sz;



	seq_printf(s, "nr_descriptors=%d\n", dmadev->nr_descriptors);

	seq_printf(s, "dev_trca=%p\n", &dmadev->dev_trca);

	seq_printf(s, "dev_trca_phys=%pa\n", &dmadev->trca_resource->start);

	sz = resource_size(dmadev->trca_resource);

	seq_printf(s, "dev_trca_size=%pa\n", &sz);

	seq_printf(s, "dev_evca=%p\n", &dmadev->dev_evca);

	seq_printf(s, "dev_evca_phys=%pa\n", &dmadev->evca_resource->start);

	sz = resource_size(dmadev->evca_resource);

	seq_printf(s, "dev_evca_size=%pa\n", &sz);

	return 0;

}



static int hidma_chan_stats_open(struct inode *inode, struct file *file)

{

	return single_open(file, hidma_chan_stats, inode->i_private);

}



static int hidma_dma_info_open(struct inode *inode, struct file *file)

{

	return single_open(file, hidma_dma_info, inode->i_private);

}



static const struct file_operations hidma_chan_fops = {

	.open = hidma_chan_stats_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};



static const struct file_operations hidma_dma_fops = {

	.open = hidma_dma_info_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};



void hidma_debug_uninit(struct hidma_dev *dmadev)

{

	debugfs_remove_recursive(dmadev->debugfs);

	debugfs_remove_recursive(dmadev->stats);

}



int hidma_debug_init(struct hidma_dev *dmadev)

{

	int rc = 0;

	int chidx = 0;

	struct list_head *position = NULL;



	dmadev->debugfs = debugfs_create_dir(dev_name(dmadev->ddev.dev), NULL);

	if (!dmadev->debugfs) {

		rc = -ENODEV;

		return rc;

	}



	/* walk through the virtual channel list */

	list_for_each(position, &dmadev->ddev.channels) {

		struct hidma_chan *chan;



		chan = list_entry(position, struct hidma_chan,

				  chan.device_node);

		sprintf(chan->dbg_name, "chan%d", chidx);

		chan->debugfs = debugfs_create_dir(chan->dbg_name,

						   dmadev->debugfs);

		if (!chan->debugfs) {

			rc = -ENOMEM;

			goto cleanup;

		}

		chan->stats = debugfs_create_file("stats", S_IRUGO,

						  chan->debugfs, chan,

						  &hidma_chan_fops);

		if (!chan->stats) {

			rc = -ENOMEM;

			goto cleanup;

		}

		chidx++;

	}



	dmadev->stats = debugfs_create_file("stats", S_IRUGO,

					    dmadev->debugfs, dmadev,

					    &hidma_dma_fops);

	if (!dmadev->stats) {

		rc = -ENOMEM;

		goto cleanup;

	}



	return 0;

cleanup:

	hidma_debug_uninit(dmadev);

	return rc;

}