Commit ff428d05 authored by Scott Branden's avatar Scott Branden Committed by Greg Kroah-Hartman
Browse files

misc: bcm-vk: add get_card_info, peerlog_info, and proc_mon_info 



Add support to get card_info (details about card),
peerlog_info (to get details of peerlog on card),
and proc_mon_info (process monitoring on card).

This info is used for collection of logs via direct
read of BAR space and by sysfs access (in a follow on commit).

Co-developed-by: default avatarDesmond Yan <desmond.yan@broadcom.com>
Acked-by: default avatarOlof Johansson <olof@lixom.net>
Signed-off-by: default avatarDesmond Yan <desmond.yan@broadcom.com>
Signed-off-by: default avatarScott Branden <scott.branden@broadcom.com>
Link: https://lore.kernel.org/r/20210120175827.14820-9-scott.branden@broadcom.com


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 7367e0ad

drivers/misc/bcm-vk/bcm_vk.h

+60 −0
Original line number Diff line number Diff line
@@ -205,6 +205,21 @@ enum pci_barno { 


#define BCM_VK_NUM_TTY 2



/* VK device max power state, supports 3, full, reduced and low */

#define MAX_OPP 3

#define MAX_CARD_INFO_TAG_SIZE 64



struct bcm_vk_card_info {

	u32 version;

	char os_tag[MAX_CARD_INFO_TAG_SIZE];

	char cmpt_tag[MAX_CARD_INFO_TAG_SIZE];

	u32 cpu_freq_mhz;

	u32 cpu_scale[MAX_OPP];

	u32 ddr_freq_mhz;

	u32 ddr_size_MB;

	u32 video_core_freq_mhz;

};



/* DAUTH related info */

struct bcm_vk_dauth_key {

	char store[VK_BAR1_DAUTH_STORE_SIZE];
@@ -215,10 +230,49 @@ struct bcm_vk_dauth_info { 
	struct bcm_vk_dauth_key keys[VK_BAR1_DAUTH_MAX];

};



/*

 * Control structure of logging messages from the card.  This

 * buffer is for logmsg that comes from vk

 */

struct bcm_vk_peer_log {

	u32 rd_idx;

	u32 wr_idx;

	u32 buf_size;

	u32 mask;

	char data[0];

};



/* max buf size allowed */

#define BCM_VK_PEER_LOG_BUF_MAX SZ_16K

/* max size per line of peer log */

#define BCM_VK_PEER_LOG_LINE_MAX  256



/*

 * single entry for processing type + utilization

 */

#define BCM_VK_PROC_TYPE_TAG_LEN 8

struct bcm_vk_proc_mon_entry_t {

	char tag[BCM_VK_PROC_TYPE_TAG_LEN];

	u32 used;

	u32 max; /**< max capacity */

};



/**

 * Structure for run time utilization

 */

#define BCM_VK_PROC_MON_MAX 8 /* max entries supported */

struct bcm_vk_proc_mon_info {

	u32 num; /**< no of entries */

	u32 entry_size; /**< per entry size */

	struct bcm_vk_proc_mon_entry_t entries[BCM_VK_PROC_MON_MAX];

};



struct bcm_vk {

	struct pci_dev *pdev;

	void __iomem *bar[MAX_BAR];



	struct bcm_vk_card_info card_info;

	struct bcm_vk_proc_mon_info proc_mon_info;

	struct bcm_vk_dauth_info dauth_info;



	/* mutex to protect the ioctls */
@@ -240,6 +294,12 @@ struct bcm_vk { 
	dma_addr_t tdma_addr; /* test dma segment bus addr */



	struct notifier_block panic_nb;



	/* offset of the peer log control in BAR2 */

	u32 peerlog_off;

	struct bcm_vk_peer_log peerlog_info; /* record of peer log info */

	/* offset of processing monitoring info in BAR2 */

	u32 proc_mon_off;

};



/* wq offload work items bits definitions */

drivers/misc/bcm-vk/bcm_vk_dev.c

+105 −0
Original line number Diff line number Diff line
@@ -172,6 +172,104 @@ static inline int bcm_vk_wait(struct bcm_vk *vk, enum pci_barno bar, 
	return 0;

}



static void bcm_vk_get_card_info(struct bcm_vk *vk)

{

	struct device *dev = &vk->pdev->dev;

	u32 offset;

	int i;

	u8 *dst;

	struct bcm_vk_card_info *info = &vk->card_info;



	/* first read the offset from spare register */

	offset = vkread32(vk, BAR_0, BAR_CARD_STATIC_INFO);

	offset &= (pci_resource_len(vk->pdev, BAR_2 * 2) - 1);



	/* based on the offset, read info to internal card info structure */

	dst = (u8 *)info;

	for (i = 0; i < sizeof(*info); i++)

		*dst++ = vkread8(vk, BAR_2, offset++);



#define CARD_INFO_LOG_FMT "version   : %x\n" \

			  "os_tag    : %s\n" \

			  "cmpt_tag  : %s\n" \

			  "cpu_freq  : %d MHz\n" \

			  "cpu_scale : %d full, %d lowest\n" \

			  "ddr_freq  : %d MHz\n" \

			  "ddr_size  : %d MB\n" \

			  "video_freq: %d MHz\n"

	dev_dbg(dev, CARD_INFO_LOG_FMT, info->version, info->os_tag,

		info->cmpt_tag, info->cpu_freq_mhz, info->cpu_scale[0],

		info->cpu_scale[MAX_OPP - 1], info->ddr_freq_mhz,

		info->ddr_size_MB, info->video_core_freq_mhz);



	/*

	 * get the peer log pointer, only need the offset, and get record

	 * of the log buffer information which would be used for checking

	 * before dump, in case the BAR2 memory has been corrupted.

	 */

	vk->peerlog_off = offset;

	memcpy_fromio(&vk->peerlog_info, vk->bar[BAR_2] + vk->peerlog_off,

		      sizeof(vk->peerlog_info));



	/*

	 * Do a range checking and if out of bound, the record will be zeroed

	 * which guarantees that nothing would be dumped.  In other words,

	 * peer dump is disabled.

	 */

	if ((vk->peerlog_info.buf_size > BCM_VK_PEER_LOG_BUF_MAX) ||

	    (vk->peerlog_info.mask != (vk->peerlog_info.buf_size - 1)) ||

	    (vk->peerlog_info.rd_idx > vk->peerlog_info.mask) ||

	    (vk->peerlog_info.wr_idx > vk->peerlog_info.mask)) {

		dev_err(dev, "Peer log disabled - range error: Size 0x%x(0x%x), [Rd Wr] = [%d %d]\n",

			vk->peerlog_info.buf_size,

			vk->peerlog_info.mask,

			vk->peerlog_info.rd_idx,

			vk->peerlog_info.wr_idx);

		memset(&vk->peerlog_info, 0, sizeof(vk->peerlog_info));

	} else {

		dev_dbg(dev, "Peer log: Size 0x%x(0x%x), [Rd Wr] = [%d %d]\n",

			vk->peerlog_info.buf_size,

			vk->peerlog_info.mask,

			vk->peerlog_info.rd_idx,

			vk->peerlog_info.wr_idx);

	}

}



static void bcm_vk_get_proc_mon_info(struct bcm_vk *vk)

{

	struct device *dev = &vk->pdev->dev;

	struct bcm_vk_proc_mon_info *mon = &vk->proc_mon_info;

	u32 num, entry_size, offset, buf_size;

	u8 *dst;



	/* calculate offset which is based on peerlog offset */

	buf_size = vkread32(vk, BAR_2,

			    vk->peerlog_off

			    + offsetof(struct bcm_vk_peer_log, buf_size));

	offset = vk->peerlog_off + sizeof(struct bcm_vk_peer_log)

		 + buf_size;



	/* first read the num and entry size */

	num = vkread32(vk, BAR_2, offset);

	entry_size = vkread32(vk, BAR_2, offset + sizeof(num));



	/* check for max allowed */

	if (num > BCM_VK_PROC_MON_MAX) {

		dev_err(dev, "Processing monitoring entry %d exceeds max %d\n",

			num, BCM_VK_PROC_MON_MAX);

		return;

	}

	mon->num = num;

	mon->entry_size = entry_size;



	vk->proc_mon_off = offset;



	/* read it once that will capture those static info */

	dst = (u8 *)&mon->entries[0];

	offset += sizeof(num) + sizeof(entry_size);

	memcpy_fromio(dst, vk->bar[BAR_2] + offset, num * entry_size);

}



static int bcm_vk_sync_card_info(struct bcm_vk *vk)

{

	u32 rdy_marker = vkread32(vk, BAR_1, VK_BAR1_MSGQ_DEF_RDY);
@@ -193,6 +291,13 @@ static int bcm_vk_sync_card_info(struct bcm_vk *vk) 
		vkwrite32(vk, nr_scratch_pages * PAGE_SIZE, BAR_1,

			  VK_BAR1_SCRATCH_SZ_ADDR);

	}



	/* get static card info, only need to read once */

	bcm_vk_get_card_info(vk);



	/* get the proc mon info once */

	bcm_vk_get_proc_mon_info(vk);



	return 0;

}