drivers/omap_hsi/hsi_driver_debugfs.c - kernel/omap - Git at Google

 /*
  * hsi_driver_debugfs.c
  *
  * Implements HSI debugfs.
  *
  * Copyright (C) 2007-2008 Nokia Corporation. All rights reserved.
  * Copyright (C) 2009 Texas Instruments, Inc.
  *
  * Author: Carlos Chinea <carlos.chinea@nokia.com>
  * Author: Sebastien JAN <s-jan@ti.com>
  *
  * This package is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  */

 #include <linux/err.h>
 #include <linux/list.h>
 #include <linux/uaccess.h>
 #include <linux/ctype.h>
 #include "hsi_driver.h"

 #define HSI_DIR_NAME_SIZE	64

 static struct dentry *hsi_dir;

 static int hsi_debug_show(struct seq_file *m, void *p)
 {
 	struct hsi_dev *hsi_ctrl = m->private;
 	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);

 	hsi_clocks_enable(hsi_ctrl->dev, __func__);

 	seq_printf(m, "REVISION\t: 0x%08x\n",
 		   hsi_inl(hsi_ctrl->base, HSI_SYS_REVISION_REG));
 	if (hsi_driver_device_is_hsi(pdev))
 		seq_printf(m, "HWINFO\t\t: 0x%08x\n",
 			   hsi_inl(hsi_ctrl->base, HSI_SYS_HWINFO_REG));
 	seq_printf(m, "SYSCONFIG\t: 0x%08x\n",
 		   hsi_inl(hsi_ctrl->base, HSI_SYS_SYSCONFIG_REG));
 	seq_printf(m, "SYSSTATUS\t: 0x%08x\n",
 		   hsi_inl(hsi_ctrl->base, HSI_SYS_SYSSTATUS_REG));

 	hsi_clocks_disable(hsi_ctrl->dev, __func__);

 	return 0;
 }

 static int hsi_debug_port_show(struct seq_file *m, void *p)
 {
 	struct hsi_port *hsi_port = m->private;
 	struct hsi_dev *hsi_ctrl = hsi_port->hsi_controller;
 	void __iomem *base = hsi_ctrl->base;
 	unsigned int port = hsi_port->port_number;
 	int ch, fifo;
 	long buff_offset;
 	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);

 	hsi_clocks_enable(hsi_ctrl->dev, __func__);

 	if (hsi_port->cawake_gpio >= 0)
 		seq_printf(m, "CAWAKE\t\t: %d\n", hsi_get_cawake(hsi_port));

 	seq_printf(m, "WAKE\t\t: 0x%08x\n",
 		   hsi_inl(base, HSI_SYS_WAKE_REG(port)));
 	seq_printf(m, "MPU_ENABLE_IRQ%d\t: 0x%08x\n", hsi_port->n_irq,
 		   hsi_inl(base,
 			   HSI_SYS_MPU_ENABLE_REG(port, hsi_port->n_irq)));
 	seq_printf(m, "MPU_STATUS_IRQ%d\t: 0x%08x\n", hsi_port->n_irq,
 		   hsi_inl(base,
 			   HSI_SYS_MPU_STATUS_REG(port, hsi_port->n_irq)));
 	if (hsi_driver_device_is_hsi(pdev)) {
 		seq_printf(m, "MPU_U_ENABLE_IRQ%d\t: 0x%08x\n",
 			   hsi_port->n_irq,
 			   hsi_inl(base, HSI_SYS_MPU_U_ENABLE_REG(port,
 							hsi_port->n_irq)));
 		seq_printf(m, "MPU_U_STATUS_IRQ%d\t: 0x%08x\n", hsi_port->n_irq,
 			   hsi_inl(base,
 				   HSI_SYS_MPU_U_STATUS_REG(port,
 							    hsi_port->n_irq)));
 	}
 	/* HST */
 	seq_printf(m, "\nHST\n===\n");
 	seq_printf(m, "MODE\t\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HST_MODE_REG(port)));
 	seq_printf(m, "FRAMESIZE\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HST_FRAMESIZE_REG(port)));
 	seq_printf(m, "DIVISOR\t\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HST_DIVISOR_REG(port)));
 	seq_printf(m, "CHANNELS\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HST_CHANNELS_REG(port)));
 	seq_printf(m, "ARBMODE\t\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HST_ARBMODE_REG(port)));
 	seq_printf(m, "TXSTATE\t\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HST_TXSTATE_REG(port)));
 	if (hsi_driver_device_is_hsi(pdev)) {
 		seq_printf(m, "BUFSTATE P1\t: 0x%08x\n",
 			   hsi_inl(base, HSI_HST_BUFSTATE_REG(1)));
 		seq_printf(m, "BUFSTATE P2\t: 0x%08x\n",
 			   hsi_inl(base, HSI_HST_BUFSTATE_REG(2)));
 	} else {
 		seq_printf(m, "BUFSTATE\t: 0x%08x\n",
 			   hsi_inl(base, HSI_HST_BUFSTATE_REG(port)));
 	}
 	seq_printf(m, "BREAK\t\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HST_BREAK_REG(port)));
 	for (ch = 0; ch < 8; ch++) {
 		buff_offset = hsi_hst_buffer_reg(hsi_ctrl, port, ch);
 		if (buff_offset >= 0)
 			seq_printf(m, "BUFFER_CH%d\t: 0x%08x\n", ch,
 				   hsi_inl(base, buff_offset));
 	}
 	if (hsi_driver_device_is_hsi(pdev)) {
 		for (fifo = 0; fifo < HSI_HST_FIFO_COUNT; fifo++) {
 			seq_printf(m, "FIFO MAPPING%d\t: 0x%08x\n", fifo,
 				   hsi_inl(base,
 					   HSI_HST_MAPPING_FIFO_REG(fifo)));
 		}
 	}
 	/* HSR */
 	seq_printf(m, "\nHSR\n===\n");
 	seq_printf(m, "MODE\t\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HSR_MODE_REG(port)));
 	seq_printf(m, "FRAMESIZE\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HSR_FRAMESIZE_REG(port)));
 	seq_printf(m, "CHANNELS\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HSR_CHANNELS_REG(port)));
 	seq_printf(m, "COUNTERS\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HSR_COUNTERS_REG(port)));
 	seq_printf(m, "RXSTATE\t\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HSR_RXSTATE_REG(port)));
 	if (hsi_driver_device_is_hsi(pdev)) {
 		seq_printf(m, "BUFSTATE P1\t: 0x%08x\n",
 			   hsi_inl(base, HSI_HSR_BUFSTATE_REG(1)));
 		seq_printf(m, "BUFSTATE P2\t: 0x%08x\n",
 			   hsi_inl(base, HSI_HSR_BUFSTATE_REG(2)));
 	} else {
 		seq_printf(m, "BUFSTATE\t: 0x%08x\n",
 			   hsi_inl(base, HSI_HSR_BUFSTATE_REG(port)));
 	}
 	seq_printf(m, "BREAK\t\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HSR_BREAK_REG(port)));
 	seq_printf(m, "ERROR\t\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HSR_ERROR_REG(port)));
 	seq_printf(m, "ERRORACK\t: 0x%08x\n",
 		   hsi_inl(base, HSI_HSR_ERRORACK_REG(port)));
 	for (ch = 0; ch < 8; ch++) {
 		buff_offset = hsi_hsr_buffer_reg(hsi_ctrl, port, ch);
 		if (buff_offset >= 0)
 			seq_printf(m, "BUFFER_CH%d\t: 0x%08x\n", ch,
 				   hsi_inl(base, buff_offset));
 	}
 	if (hsi_driver_device_is_hsi(pdev)) {
 		for (fifo = 0; fifo < HSI_HSR_FIFO_COUNT; fifo++) {
 			seq_printf(m, "FIFO MAPPING%d\t: 0x%08x\n", fifo,
 				   hsi_inl(base,
 					   HSI_HSR_MAPPING_FIFO_REG(fifo)));
 		}
 		seq_printf(m, "DLL\t: 0x%08x\n",
 			   hsi_inl(base, HSI_HSR_DLL_REG));
 		seq_printf(m, "DIVISOR\t: 0x%08x\n",
 			   hsi_inl(base, HSI_HSR_DIVISOR_REG(port)));
 	}

 	hsi_clocks_disable(hsi_ctrl->dev, __func__);

 	return 0;
 }

 static int hsi_debug_gdd_show(struct seq_file *m, void *p)
 {
 	struct hsi_dev *hsi_ctrl = m->private;
 	void __iomem *base = hsi_ctrl->base;
 	int lch;
 	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);

 	hsi_clocks_enable(hsi_ctrl->dev, __func__);

 	seq_printf(m, "GDD_MPU_STATUS\t: 0x%08x\n",
 		   hsi_inl(base, HSI_SYS_GDD_MPU_IRQ_STATUS_REG));
 	seq_printf(m, "GDD_MPU_ENABLE\t: 0x%08x\n\n",
 		   hsi_inl(base, HSI_SYS_GDD_MPU_IRQ_ENABLE_REG));

 	if (!hsi_driver_device_is_hsi(pdev)) {
 		seq_printf(m, "HW_ID\t\t: 0x%08x\n",
 			   hsi_inl(base, HSI_SSI_GDD_HW_ID_REG));
 		seq_printf(m, "PPORT_ID\t: 0x%08x\n",
 			   hsi_inl(base, HSI_SSI_GDD_PPORT_ID_REG));
 		seq_printf(m, "MPORT_ID\t: 0x%08x\n",
 			   hsi_inl(base, HSI_SSI_GDD_MPORT_ID_REG));
 		seq_printf(m, "TEST\t\t: 0x%08x\n",
 			   hsi_inl(base, HSI_SSI_GDD_TEST_REG));
 	}

 	seq_printf(m, "GCR\t\t: 0x%08x\n", hsi_inl(base, HSI_GDD_GCR_REG));

 	for (lch = 0; lch < hsi_ctrl->gdd_chan_count; lch++) {
 		seq_printf(m, "\nGDD LCH %d\n=========\n", lch);
 		seq_printf(m, "CSDP\t\t: 0x%04x\n",
 			   hsi_inw(base, HSI_GDD_CSDP_REG(lch)));
 		seq_printf(m, "CCR\t\t: 0x%04x\n",
 			   hsi_inw(base, HSI_GDD_CCR_REG(lch)));
 		seq_printf(m, "CICR\t\t: 0x%04x\n",
 			   hsi_inw(base, HSI_GDD_CCIR_REG(lch)));
 		seq_printf(m, "CSR\t\t: 0x%04x\n",
 			   hsi_inw(base, HSI_GDD_CSR_REG(lch)));
 		seq_printf(m, "CSSA\t\t: 0x%08x\n",
 			   hsi_inl(base, HSI_GDD_CSSA_REG(lch)));
 		seq_printf(m, "CDSA\t\t: 0x%08x\n",
 			   hsi_inl(base, HSI_GDD_CDSA_REG(lch)));
 		seq_printf(m, "CEN\t\t: 0x%04x\n",
 			   hsi_inw(base, HSI_GDD_CEN_REG(lch)));
 		seq_printf(m, "CSAC\t\t: 0x%04x\n",
 			   hsi_inw(base, HSI_GDD_CSAC_REG(lch)));
 		seq_printf(m, "CDAC\t\t: 0x%04x\n",
 			   hsi_inw(base, HSI_GDD_CDAC_REG(lch)));
 		if (!hsi_driver_device_is_hsi(pdev))
 			seq_printf(m, "CLNK_CTRL\t: 0x%04x\n",
 				   hsi_inw(base,
 					   HSI_SSI_GDD_CLNK_CTRL_REG(lch)));
 	}

 	hsi_clocks_disable(hsi_ctrl->dev, __func__);

 	return 0;
 }

 static int hsi_port_counters_open(struct inode *inode, struct file *file)
 {
 	file->private_data = inode->i_private;
 	return 0;
 }

 static int hsi_port_counters_release(struct inode *inode, struct file *file)
 {
 	return 0;
 }

 static loff_t hsi_port_counters_seek(struct file *file, loff_t off, int whence)
 {
 	return 0;
 }

 static ssize_t hsi_port_counters_read(struct file *filep, char __user * buff,
 				      size_t count, loff_t *offp)
 {
 	ssize_t ret;
 	struct hsi_port *hsi_port = filep->private_data;
 	struct hsi_dev *hsi_ctrl = hsi_port->hsi_controller;
 	void __iomem *base = hsi_ctrl->base;
 	unsigned int port = hsi_port->port_number;
 	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);
 	char str[50];
 	unsigned int reg;

 	if (*offp > 0) {
 		ret = 0;
 		goto hsi_cnt_rd_bk;
 	}

 	hsi_clocks_enable(hsi_ctrl->dev, __func__);

 	reg = hsi_inl(base, HSI_HSR_COUNTERS_REG(port));

 	hsi_clocks_disable(hsi_ctrl->dev, __func__);

 	if (hsi_driver_device_is_hsi(pdev)) {
 		sprintf(str, "FT:%d, TB:%d, FB:%d\n",
 			(unsigned int)(reg & HSI_COUNTERS_FT_MASK) >>
 			HSI_COUNTERS_FT_OFFSET,
 			(unsigned int)(reg & HSI_COUNTERS_TB_MASK) >>
 			HSI_COUNTERS_TB_OFFSET,
 			(unsigned int)(reg & HSI_COUNTERS_FB_MASK) >>
 			HSI_COUNTERS_FB_OFFSET);
 	} else {
 		sprintf(str, "timeout:%d\n", (int)reg);
 	}

 	ret = strlen(str);
 	if (copy_to_user((void __user *)buff, str, ret)) {
 		dev_err(hsi_ctrl->dev, "copy_to_user failed\n");
 		ret = 0;
 	} else {
 		*offp = ret;
 	}

 hsi_cnt_rd_bk:
 	return ret;
 }

 /*
  * Split the buffer `buf' into space-separated words.
  * Return the number of words or <0 on error.
  */
 static int hsi_debug_tokenize(char *buf, char *words[], int maxwords)
 {
 	int nwords = 0;

 	while (*buf) {
 		char *end;

 		/* Skip leading whitespace */
 		while (*buf && isspace(*buf))
 			buf++;
 		if (!*buf)
 			break;	/* oh, it was trailing whitespace */

 		/* Run `end' over a word */
 		for (end = buf; *end && !isspace(*end); end++)
 			;
 		/* `buf' is the start of the word, `end' is one past the end */

 		if (nwords == maxwords)
 			return -EINVAL;	/* ran out of words[] before bytes */
 		if (*end)
 			*end++ = '\0';	/* terminate the word */
 		words[nwords++] = buf;
 		buf = end;
 	}
 	return nwords;
 }

 static ssize_t hsi_port_counters_write(struct file *filep,
 				       const char __user *buff, size_t count,
 				       loff_t *offp)
 {
 	ssize_t ret;
 	struct hsi_port *hsi_port = filep->private_data;
 	struct hsi_dev *hsi_ctrl = hsi_port->hsi_controller;
 	void __iomem *base = hsi_ctrl->base;
 	unsigned int port = hsi_port->port_number;
 	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);
 #define MAXWORDS 4
 	int nwords;
 	char *words[MAXWORDS];
 	char tmpbuf[256];
 	unsigned long reg, ft, tb, fb;

 	if (count == 0)
 		return 0;
 	if (count > sizeof(tmpbuf) - 1)
 		return -E2BIG;
 	if (copy_from_user(tmpbuf, buff, count))
 		return -EFAULT;
 	tmpbuf[count] = '\0';
 	dev_dbg(hsi_ctrl->dev, "%s: read %d bytes from userspace\n",
 		__func__, (int)count);

 	nwords = hsi_debug_tokenize(tmpbuf, words, MAXWORDS);
 	if (nwords < 0) {
 		dev_warn(hsi_ctrl->dev,
 			"HSI counters write usage: echo <values> > counters\n");
 		return -EINVAL;
 	}

 	hsi_clocks_enable(hsi_ctrl->dev, __func__);

 	if (hsi_driver_device_is_hsi(pdev)) {
 		if (nwords != 3) {
 			dev_warn(hsi_ctrl->dev, "HSI counters write usage: "
 				 "echo \"FT TB FB\" > counters\n");
 			ret = -EINVAL;
 			goto hsi_cnt_w_bk1;
 		}

 		if (strict_strtoul(words[0], 0, &ft) ||
 		    strict_strtoul(words[1], 0, &tb) ||
 		    strict_strtoul(words[2], 0, &fb)) {
 			dev_warn(hsi_ctrl->dev, "Not an unsigned long\n");
 			ret = -EINVAL;
 			goto hsi_cnt_w_bk1;
 		}

 		ft = clamp_val(ft, 0,
 				HSI_COUNTERS_FT_MASK >> HSI_COUNTERS_FT_OFFSET);
 		tb = clamp_val(tb, 0,
 				HSI_COUNTERS_TB_MASK >> HSI_COUNTERS_TB_OFFSET);
 		fb = clamp_val(fb, 0,
 				HSI_COUNTERS_FB_MASK >> HSI_COUNTERS_FB_OFFSET);
 		reg = (((ft << HSI_COUNTERS_FT_OFFSET) & HSI_COUNTERS_FT_MASK) |
 		       ((tb << HSI_COUNTERS_TB_OFFSET) & HSI_COUNTERS_TB_MASK) |
 		       ((fb << HSI_COUNTERS_FB_OFFSET) & HSI_COUNTERS_FB_MASK));
 	} else {
 		if (nwords != 1) {
 			dev_warn(hsi_ctrl->dev, "HSI counters write usage: "
 				 "echo \"timeout\" > counters\n");
 			ret = -EINVAL;
 			goto hsi_cnt_w_bk1;
 		}
 		if (strict_strtoul(words[0], 0, &reg)) {
 			dev_warn(hsi_ctrl->dev, "Not an unsigned long\n");
 			ret = -EINVAL;
 			goto hsi_cnt_w_bk1;
 		}
 		reg = clamp_val(reg, 0,
 			(HSI_SSI_RX_TIMEOUT_MASK >> HSI_SSI_RX_TIMEOUT_OFFSET));
 	}
 	hsi_outl((unsigned int)reg, base, HSI_HSR_COUNTERS_REG(port));
 	ret = count;
 	*offp += count;

 hsi_cnt_w_bk1:

 	hsi_clocks_disable(hsi_ctrl->dev, __func__);

 	return ret;
 }

 static int hsi_regs_open(struct inode *inode, struct file *file)
 {
 	return single_open(file, hsi_debug_show, inode->i_private);
 }

 static int hsi_port_regs_open(struct inode *inode, struct file *file)
 {
 	return single_open(file, hsi_debug_port_show, inode->i_private);
 }

 static int hsi_gdd_regs_open(struct inode *inode, struct file *file)
 {
 	return single_open(file, hsi_debug_gdd_show, inode->i_private);
 }

 static const struct file_operations hsi_regs_fops = {
 	.open = hsi_regs_open,
 	.read = seq_read,
 	.llseek = seq_lseek,
 	.release = single_release,
 };

 static const struct file_operations hsi_port_regs_fops = {
 	.open = hsi_port_regs_open,
 	.read = seq_read,
 	.llseek = seq_lseek,
 	.release = single_release,
 };

 static const struct file_operations hsi_port_counters_fops = {
 	.open = hsi_port_counters_open,
 	.read = hsi_port_counters_read,
 	.write = hsi_port_counters_write,
 	.llseek = hsi_port_counters_seek,
 	.release = hsi_port_counters_release,
 };

 static const struct file_operations hsi_gdd_regs_fops = {
 	.open = hsi_gdd_regs_open,
 	.read = seq_read,
 	.llseek = seq_lseek,
 	.release = single_release,
 };

 int __init hsi_debug_add_ctrl(struct hsi_dev *hsi_ctrl)
 {
 	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);
 	unsigned char dir_name[HSI_DIR_NAME_SIZE];
 	struct dentry *dir;
 	unsigned int port;

 	if (pdev->id < 0) {
 		hsi_ctrl->dir = debugfs_create_dir(pdev->name, hsi_dir);
 	} else {
 		snprintf(dir_name, sizeof(dir_name), "%s%d", pdev->name,
 			 pdev->id);
 		hsi_ctrl->dir = debugfs_create_dir(dir_name, hsi_dir);
 	}
 	if (IS_ERR(hsi_ctrl->dir))
 		return PTR_ERR(hsi_ctrl->dir);

 	debugfs_create_file("regs", S_IRUGO, hsi_ctrl->dir, hsi_ctrl,
 			    &hsi_regs_fops);

 	for (port = 0; port < hsi_ctrl->max_p; port++) {
 		snprintf(dir_name, sizeof(dir_name), "port%d", port + 1);
 		dir = debugfs_create_dir(dir_name, hsi_ctrl->dir);
 		if (IS_ERR(dir))
 			goto rback;
 		debugfs_create_file("regs", S_IRUGO, dir,
 				    &hsi_ctrl->hsi_port[port],
 				    &hsi_port_regs_fops);
 		debugfs_create_file("counters", S_IRUGO | S_IWUSR, dir,
 				    &hsi_ctrl->hsi_port[port],
 				    &hsi_port_counters_fops);
 	}

 	dir = debugfs_create_dir("gdd", hsi_ctrl->dir);
 	if (IS_ERR(dir))
 		goto rback;
 	debugfs_create_file("regs", S_IRUGO, dir, hsi_ctrl, &hsi_gdd_regs_fops);

 	return 0;
 rback:
 	debugfs_remove_recursive(hsi_ctrl->dir);
 	return PTR_ERR(dir);
 }

 void hsi_debug_remove_ctrl(struct hsi_dev *hsi_ctrl)
 {
 	debugfs_remove_recursive(hsi_ctrl->dir);
 }

 int __init hsi_debug_init(void)
 {
 	hsi_dir = debugfs_create_dir("hsi", NULL);
 	if (IS_ERR(hsi_dir))
 		return PTR_ERR(hsi_dir);

 	return 0;
 }

 void hsi_debug_exit(void)
 {
 	debugfs_remove_recursive(hsi_dir);
 }
	/*
	* hsi_driver_debugfs.c
	*
	* Implements HSI debugfs.
	*
	* Copyright (C) 2007-2008 Nokia Corporation. All rights reserved.
	* Copyright (C) 2009 Texas Instruments, Inc.
	*
	* Author: Carlos Chinea <carlos.chinea@nokia.com>
	* Author: Sebastien JAN <s-jan@ti.com>
	*
	* This package is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*
	* THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
	* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
	* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
	*/

	#include <linux/err.h>
	#include <linux/list.h>
	#include <linux/uaccess.h>
	#include <linux/ctype.h>
	#include "hsi_driver.h"

	#define HSI_DIR_NAME_SIZE 64

	static struct dentry *hsi_dir;

	static int hsi_debug_show(struct seq_file m, void p)
	{
	struct hsi_dev *hsi_ctrl = m->private;
	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);

	hsi_clocks_enable(hsi_ctrl->dev, __func__);

	seq_printf(m, "REVISION\t: 0x%08x\n",
	hsi_inl(hsi_ctrl->base, HSI_SYS_REVISION_REG));
	if (hsi_driver_device_is_hsi(pdev))
	seq_printf(m, "HWINFO\t\t: 0x%08x\n",
	hsi_inl(hsi_ctrl->base, HSI_SYS_HWINFO_REG));
	seq_printf(m, "SYSCONFIG\t: 0x%08x\n",
	hsi_inl(hsi_ctrl->base, HSI_SYS_SYSCONFIG_REG));
	seq_printf(m, "SYSSTATUS\t: 0x%08x\n",
	hsi_inl(hsi_ctrl->base, HSI_SYS_SYSSTATUS_REG));

	hsi_clocks_disable(hsi_ctrl->dev, __func__);

	return 0;
	}

	static int hsi_debug_port_show(struct seq_file m, void p)
	{
	struct hsi_port *hsi_port = m->private;
	struct hsi_dev *hsi_ctrl = hsi_port->hsi_controller;
	void __iomem *base = hsi_ctrl->base;
	unsigned int port = hsi_port->port_number;
	int ch, fifo;
	long buff_offset;
	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);

	hsi_clocks_enable(hsi_ctrl->dev, __func__);

	if (hsi_port->cawake_gpio >= 0)
	seq_printf(m, "CAWAKE\t\t: %d\n", hsi_get_cawake(hsi_port));

	seq_printf(m, "WAKE\t\t: 0x%08x\n",
	hsi_inl(base, HSI_SYS_WAKE_REG(port)));
	seq_printf(m, "MPU_ENABLE_IRQ%d\t: 0x%08x\n", hsi_port->n_irq,
	hsi_inl(base,
	HSI_SYS_MPU_ENABLE_REG(port, hsi_port->n_irq)));
	seq_printf(m, "MPU_STATUS_IRQ%d\t: 0x%08x\n", hsi_port->n_irq,
	hsi_inl(base,
	HSI_SYS_MPU_STATUS_REG(port, hsi_port->n_irq)));
	if (hsi_driver_device_is_hsi(pdev)) {
	seq_printf(m, "MPU_U_ENABLE_IRQ%d\t: 0x%08x\n",
	hsi_port->n_irq,
	hsi_inl(base, HSI_SYS_MPU_U_ENABLE_REG(port,
	hsi_port->n_irq)));
	seq_printf(m, "MPU_U_STATUS_IRQ%d\t: 0x%08x\n", hsi_port->n_irq,
	hsi_inl(base,
	HSI_SYS_MPU_U_STATUS_REG(port,
	hsi_port->n_irq)));
	}
	/* HST */
	seq_printf(m, "\nHST\n===\n");
	seq_printf(m, "MODE\t\t: 0x%08x\n",
	hsi_inl(base, HSI_HST_MODE_REG(port)));
	seq_printf(m, "FRAMESIZE\t: 0x%08x\n",
	hsi_inl(base, HSI_HST_FRAMESIZE_REG(port)));
	seq_printf(m, "DIVISOR\t\t: 0x%08x\n",
	hsi_inl(base, HSI_HST_DIVISOR_REG(port)));
	seq_printf(m, "CHANNELS\t: 0x%08x\n",
	hsi_inl(base, HSI_HST_CHANNELS_REG(port)));
	seq_printf(m, "ARBMODE\t\t: 0x%08x\n",
	hsi_inl(base, HSI_HST_ARBMODE_REG(port)));
	seq_printf(m, "TXSTATE\t\t: 0x%08x\n",
	hsi_inl(base, HSI_HST_TXSTATE_REG(port)));
	if (hsi_driver_device_is_hsi(pdev)) {
	seq_printf(m, "BUFSTATE P1\t: 0x%08x\n",
	hsi_inl(base, HSI_HST_BUFSTATE_REG(1)));
	seq_printf(m, "BUFSTATE P2\t: 0x%08x\n",
	hsi_inl(base, HSI_HST_BUFSTATE_REG(2)));
	} else {
	seq_printf(m, "BUFSTATE\t: 0x%08x\n",
	hsi_inl(base, HSI_HST_BUFSTATE_REG(port)));
	}
	seq_printf(m, "BREAK\t\t: 0x%08x\n",
	hsi_inl(base, HSI_HST_BREAK_REG(port)));
	for (ch = 0; ch < 8; ch++) {
	buff_offset = hsi_hst_buffer_reg(hsi_ctrl, port, ch);
	if (buff_offset >= 0)
	seq_printf(m, "BUFFER_CH%d\t: 0x%08x\n", ch,
	hsi_inl(base, buff_offset));
	}
	if (hsi_driver_device_is_hsi(pdev)) {
	for (fifo = 0; fifo < HSI_HST_FIFO_COUNT; fifo++) {
	seq_printf(m, "FIFO MAPPING%d\t: 0x%08x\n", fifo,
	hsi_inl(base,
	HSI_HST_MAPPING_FIFO_REG(fifo)));
	}
	}
	/* HSR */
	seq_printf(m, "\nHSR\n===\n");
	seq_printf(m, "MODE\t\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_MODE_REG(port)));
	seq_printf(m, "FRAMESIZE\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_FRAMESIZE_REG(port)));
	seq_printf(m, "CHANNELS\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_CHANNELS_REG(port)));
	seq_printf(m, "COUNTERS\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_COUNTERS_REG(port)));
	seq_printf(m, "RXSTATE\t\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_RXSTATE_REG(port)));
	if (hsi_driver_device_is_hsi(pdev)) {
	seq_printf(m, "BUFSTATE P1\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_BUFSTATE_REG(1)));
	seq_printf(m, "BUFSTATE P2\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_BUFSTATE_REG(2)));
	} else {
	seq_printf(m, "BUFSTATE\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_BUFSTATE_REG(port)));
	}
	seq_printf(m, "BREAK\t\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_BREAK_REG(port)));
	seq_printf(m, "ERROR\t\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_ERROR_REG(port)));
	seq_printf(m, "ERRORACK\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_ERRORACK_REG(port)));
	for (ch = 0; ch < 8; ch++) {
	buff_offset = hsi_hsr_buffer_reg(hsi_ctrl, port, ch);
	if (buff_offset >= 0)
	seq_printf(m, "BUFFER_CH%d\t: 0x%08x\n", ch,
	hsi_inl(base, buff_offset));
	}
	if (hsi_driver_device_is_hsi(pdev)) {
	for (fifo = 0; fifo < HSI_HSR_FIFO_COUNT; fifo++) {
	seq_printf(m, "FIFO MAPPING%d\t: 0x%08x\n", fifo,
	hsi_inl(base,
	HSI_HSR_MAPPING_FIFO_REG(fifo)));
	}
	seq_printf(m, "DLL\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_DLL_REG));
	seq_printf(m, "DIVISOR\t: 0x%08x\n",
	hsi_inl(base, HSI_HSR_DIVISOR_REG(port)));
	}

	hsi_clocks_disable(hsi_ctrl->dev, __func__);

	return 0;
	}

	static int hsi_debug_gdd_show(struct seq_file m, void p)
	{
	struct hsi_dev *hsi_ctrl = m->private;
	void __iomem *base = hsi_ctrl->base;
	int lch;
	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);

	hsi_clocks_enable(hsi_ctrl->dev, __func__);

	seq_printf(m, "GDD_MPU_STATUS\t: 0x%08x\n",
	hsi_inl(base, HSI_SYS_GDD_MPU_IRQ_STATUS_REG));
	seq_printf(m, "GDD_MPU_ENABLE\t: 0x%08x\n\n",
	hsi_inl(base, HSI_SYS_GDD_MPU_IRQ_ENABLE_REG));

	if (!hsi_driver_device_is_hsi(pdev)) {
	seq_printf(m, "HW_ID\t\t: 0x%08x\n",
	hsi_inl(base, HSI_SSI_GDD_HW_ID_REG));
	seq_printf(m, "PPORT_ID\t: 0x%08x\n",
	hsi_inl(base, HSI_SSI_GDD_PPORT_ID_REG));
	seq_printf(m, "MPORT_ID\t: 0x%08x\n",
	hsi_inl(base, HSI_SSI_GDD_MPORT_ID_REG));
	seq_printf(m, "TEST\t\t: 0x%08x\n",
	hsi_inl(base, HSI_SSI_GDD_TEST_REG));
	}

	seq_printf(m, "GCR\t\t: 0x%08x\n", hsi_inl(base, HSI_GDD_GCR_REG));

	for (lch = 0; lch < hsi_ctrl->gdd_chan_count; lch++) {
	seq_printf(m, "\nGDD LCH %d\n=========\n", lch);
	seq_printf(m, "CSDP\t\t: 0x%04x\n",
	hsi_inw(base, HSI_GDD_CSDP_REG(lch)));
	seq_printf(m, "CCR\t\t: 0x%04x\n",
	hsi_inw(base, HSI_GDD_CCR_REG(lch)));
	seq_printf(m, "CICR\t\t: 0x%04x\n",
	hsi_inw(base, HSI_GDD_CCIR_REG(lch)));
	seq_printf(m, "CSR\t\t: 0x%04x\n",
	hsi_inw(base, HSI_GDD_CSR_REG(lch)));
	seq_printf(m, "CSSA\t\t: 0x%08x\n",
	hsi_inl(base, HSI_GDD_CSSA_REG(lch)));
	seq_printf(m, "CDSA\t\t: 0x%08x\n",
	hsi_inl(base, HSI_GDD_CDSA_REG(lch)));
	seq_printf(m, "CEN\t\t: 0x%04x\n",
	hsi_inw(base, HSI_GDD_CEN_REG(lch)));
	seq_printf(m, "CSAC\t\t: 0x%04x\n",
	hsi_inw(base, HSI_GDD_CSAC_REG(lch)));
	seq_printf(m, "CDAC\t\t: 0x%04x\n",
	hsi_inw(base, HSI_GDD_CDAC_REG(lch)));
	if (!hsi_driver_device_is_hsi(pdev))
	seq_printf(m, "CLNK_CTRL\t: 0x%04x\n",
	hsi_inw(base,
	HSI_SSI_GDD_CLNK_CTRL_REG(lch)));
	}

	hsi_clocks_disable(hsi_ctrl->dev, __func__);

	return 0;
	}

	static int hsi_port_counters_open(struct inode inode, struct file file)
	{
	file->private_data = inode->i_private;
	return 0;
	}

	static int hsi_port_counters_release(struct inode inode, struct file file)
	{
	return 0;
	}

	static loff_t hsi_port_counters_seek(struct file *file, loff_t off, int whence)
	{
	return 0;
	}

	static ssize_t hsi_port_counters_read(struct file filep, char __user buff,
	size_t count, loff_t *offp)
	{
	ssize_t ret;
	struct hsi_port *hsi_port = filep->private_data;
	struct hsi_dev *hsi_ctrl = hsi_port->hsi_controller;
	void __iomem *base = hsi_ctrl->base;
	unsigned int port = hsi_port->port_number;
	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);
	char str[50];
	unsigned int reg;

	if (*offp > 0) {
	ret = 0;
	goto hsi_cnt_rd_bk;
	}

	hsi_clocks_enable(hsi_ctrl->dev, __func__);

	reg = hsi_inl(base, HSI_HSR_COUNTERS_REG(port));

	hsi_clocks_disable(hsi_ctrl->dev, __func__);

	if (hsi_driver_device_is_hsi(pdev)) {
	sprintf(str, "FT:%d, TB:%d, FB:%d\n",
	(unsigned int)(reg & HSI_COUNTERS_FT_MASK) >>
	HSI_COUNTERS_FT_OFFSET,
	(unsigned int)(reg & HSI_COUNTERS_TB_MASK) >>
	HSI_COUNTERS_TB_OFFSET,
	(unsigned int)(reg & HSI_COUNTERS_FB_MASK) >>
	HSI_COUNTERS_FB_OFFSET);
	} else {
	sprintf(str, "timeout:%d\n", (int)reg);
	}

	ret = strlen(str);
	if (copy_to_user((void __user *)buff, str, ret)) {
	dev_err(hsi_ctrl->dev, "copy_to_user failed\n");
	ret = 0;
	} else {
	*offp = ret;
	}

	hsi_cnt_rd_bk:
	return ret;
	}

	/*
	* Split the buffer `buf' into space-separated words.
	* Return the number of words or <0 on error.
	*/
	static int hsi_debug_tokenize(char buf, char words[], int maxwords)
	{
	int nwords = 0;

	while (*buf) {
	char *end;

	/* Skip leading whitespace */
	while (buf && isspace(buf))
	buf++;
	if (!*buf)
	break; /* oh, it was trailing whitespace */

	/* Run `end' over a word */
	for (end = buf; end && !isspace(end); end++)
	;
	/* `buf' is the start of the word, `end' is one past the end */

	if (nwords == maxwords)
	return -EINVAL; /* ran out of words[] before bytes */
	if (*end)
	end++ = '\0'; / terminate the word */
	words[nwords++] = buf;
	buf = end;
	}
	return nwords;
	}

	static ssize_t hsi_port_counters_write(struct file *filep,
	const char __user *buff, size_t count,
	loff_t *offp)
	{
	ssize_t ret;
	struct hsi_port *hsi_port = filep->private_data;
	struct hsi_dev *hsi_ctrl = hsi_port->hsi_controller;
	void __iomem *base = hsi_ctrl->base;
	unsigned int port = hsi_port->port_number;
	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);
	#define MAXWORDS 4
	int nwords;
	char *words[MAXWORDS];
	char tmpbuf[256];
	unsigned long reg, ft, tb, fb;

	if (count == 0)
	return 0;
	if (count > sizeof(tmpbuf) - 1)
	return -E2BIG;
	if (copy_from_user(tmpbuf, buff, count))
	return -EFAULT;
	tmpbuf[count] = '\0';
	dev_dbg(hsi_ctrl->dev, "%s: read %d bytes from userspace\n",
	__func__, (int)count);

	nwords = hsi_debug_tokenize(tmpbuf, words, MAXWORDS);
	if (nwords < 0) {
	dev_warn(hsi_ctrl->dev,
	"HSI counters write usage: echo <values> > counters\n");
	return -EINVAL;
	}

	hsi_clocks_enable(hsi_ctrl->dev, __func__);

	if (hsi_driver_device_is_hsi(pdev)) {
	if (nwords != 3) {
	dev_warn(hsi_ctrl->dev, "HSI counters write usage: "
	"echo \"FT TB FB\" > counters\n");
	ret = -EINVAL;
	goto hsi_cnt_w_bk1;
	}

	if (strict_strtoul(words[0], 0, &ft) \|\|
	strict_strtoul(words[1], 0, &tb) \|\|
	strict_strtoul(words[2], 0, &fb)) {
	dev_warn(hsi_ctrl->dev, "Not an unsigned long\n");
	ret = -EINVAL;
	goto hsi_cnt_w_bk1;
	}

	ft = clamp_val(ft, 0,
	HSI_COUNTERS_FT_MASK >> HSI_COUNTERS_FT_OFFSET);
	tb = clamp_val(tb, 0,
	HSI_COUNTERS_TB_MASK >> HSI_COUNTERS_TB_OFFSET);
	fb = clamp_val(fb, 0,
	HSI_COUNTERS_FB_MASK >> HSI_COUNTERS_FB_OFFSET);
	reg = (((ft << HSI_COUNTERS_FT_OFFSET) & HSI_COUNTERS_FT_MASK) \|
	((tb << HSI_COUNTERS_TB_OFFSET) & HSI_COUNTERS_TB_MASK) \|
	((fb << HSI_COUNTERS_FB_OFFSET) & HSI_COUNTERS_FB_MASK));
	} else {
	if (nwords != 1) {
	dev_warn(hsi_ctrl->dev, "HSI counters write usage: "
	"echo \"timeout\" > counters\n");
	ret = -EINVAL;
	goto hsi_cnt_w_bk1;
	}
	if (strict_strtoul(words[0], 0, &reg)) {
	dev_warn(hsi_ctrl->dev, "Not an unsigned long\n");
	ret = -EINVAL;
	goto hsi_cnt_w_bk1;
	}
	reg = clamp_val(reg, 0,
	(HSI_SSI_RX_TIMEOUT_MASK >> HSI_SSI_RX_TIMEOUT_OFFSET));
	}
	hsi_outl((unsigned int)reg, base, HSI_HSR_COUNTERS_REG(port));
	ret = count;
	*offp += count;

	hsi_cnt_w_bk1:

	hsi_clocks_disable(hsi_ctrl->dev, __func__);

	return ret;
	}

	static int hsi_regs_open(struct inode inode, struct file file)
	{
	return single_open(file, hsi_debug_show, inode->i_private);
	}

	static int hsi_port_regs_open(struct inode inode, struct file file)
	{
	return single_open(file, hsi_debug_port_show, inode->i_private);
	}

	static int hsi_gdd_regs_open(struct inode inode, struct file file)
	{
	return single_open(file, hsi_debug_gdd_show, inode->i_private);
	}

	static const struct file_operations hsi_regs_fops = {
	.open = hsi_regs_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	static const struct file_operations hsi_port_regs_fops = {
	.open = hsi_port_regs_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	static const struct file_operations hsi_port_counters_fops = {
	.open = hsi_port_counters_open,
	.read = hsi_port_counters_read,
	.write = hsi_port_counters_write,
	.llseek = hsi_port_counters_seek,
	.release = hsi_port_counters_release,
	};

	static const struct file_operations hsi_gdd_regs_fops = {
	.open = hsi_gdd_regs_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
	};

	int __init hsi_debug_add_ctrl(struct hsi_dev *hsi_ctrl)
	{
	struct platform_device *pdev = to_platform_device(hsi_ctrl->dev);
	unsigned char dir_name[HSI_DIR_NAME_SIZE];
	struct dentry *dir;
	unsigned int port;

	if (pdev->id < 0) {
	hsi_ctrl->dir = debugfs_create_dir(pdev->name, hsi_dir);
	} else {
	snprintf(dir_name, sizeof(dir_name), "%s%d", pdev->name,
	pdev->id);
	hsi_ctrl->dir = debugfs_create_dir(dir_name, hsi_dir);
	}
	if (IS_ERR(hsi_ctrl->dir))
	return PTR_ERR(hsi_ctrl->dir);

	debugfs_create_file("regs", S_IRUGO, hsi_ctrl->dir, hsi_ctrl,
	&hsi_regs_fops);

	for (port = 0; port < hsi_ctrl->max_p; port++) {
	snprintf(dir_name, sizeof(dir_name), "port%d", port + 1);
	dir = debugfs_create_dir(dir_name, hsi_ctrl->dir);
	if (IS_ERR(dir))
	goto rback;
	debugfs_create_file("regs", S_IRUGO, dir,
	&hsi_ctrl->hsi_port[port],
	&hsi_port_regs_fops);
	debugfs_create_file("counters", S_IRUGO \| S_IWUSR, dir,
	&hsi_ctrl->hsi_port[port],
	&hsi_port_counters_fops);
	}

	dir = debugfs_create_dir("gdd", hsi_ctrl->dir);
	if (IS_ERR(dir))
	goto rback;
	debugfs_create_file("regs", S_IRUGO, dir, hsi_ctrl, &hsi_gdd_regs_fops);

	return 0;
	rback:
	debugfs_remove_recursive(hsi_ctrl->dir);
	return PTR_ERR(dir);
	}

	void hsi_debug_remove_ctrl(struct hsi_dev *hsi_ctrl)
	{
	debugfs_remove_recursive(hsi_ctrl->dir);
	}

	int __init hsi_debug_init(void)
	{
	hsi_dir = debugfs_create_dir("hsi", NULL);
	if (IS_ERR(hsi_dir))
	return PTR_ERR(hsi_dir);

	return 0;
	}

	void hsi_debug_exit(void)
	{
	debugfs_remove_recursive(hsi_dir);
	}