drivers/staging/media/meson/vdec/esparser.c - hafnium/third_party/linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Copyright (C) 2018 BayLibre, SAS
  * Author: Maxime Jourdan <mjourdan@baylibre.com>
  *
  * The Elementary Stream Parser is a HW bitstream parser.
  * It reads bitstream buffers and feeds them to the VIFIFO
  */

 #include <linux/init.h>
 #include <linux/ioctl.h>
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/of_device.h>
 #include <linux/reset.h>
 #include <linux/interrupt.h>
 #include <media/videobuf2-dma-contig.h>
 #include <media/v4l2-mem2mem.h>

 #include "dos_regs.h"
 #include "esparser.h"
 #include "vdec_helpers.h"

 /* PARSER REGS (CBUS) */
 #define PARSER_CONTROL 0x00
 	#define ES_PACK_SIZE_BIT	8
 	#define ES_WRITE		BIT(5)
 	#define ES_SEARCH		BIT(1)
 	#define ES_PARSER_START		BIT(0)
 #define PARSER_FETCH_ADDR	0x4
 #define PARSER_FETCH_CMD	0x8
 #define PARSER_CONFIG 0x14
 	#define PS_CFG_MAX_FETCH_CYCLE_BIT	0
 	#define PS_CFG_STARTCODE_WID_24_BIT	10
 	#define PS_CFG_MAX_ES_WR_CYCLE_BIT	12
 	#define PS_CFG_PFIFO_EMPTY_CNT_BIT	16
 #define PFIFO_WR_PTR 0x18
 #define PFIFO_RD_PTR 0x1c
 #define PARSER_SEARCH_PATTERN 0x24
 	#define ES_START_CODE_PATTERN 0x00000100
 #define PARSER_SEARCH_MASK 0x28
 	#define ES_START_CODE_MASK	0xffffff00
 	#define FETCH_ENDIAN_BIT	27
 #define PARSER_INT_ENABLE	0x2c
 	#define PARSER_INT_HOST_EN_BIT	8
 #define PARSER_INT_STATUS	0x30
 	#define PARSER_INTSTAT_SC_FOUND	1
 #define PARSER_ES_CONTROL	0x5c
 #define PARSER_VIDEO_START_PTR	0x80
 #define PARSER_VIDEO_END_PTR	0x84
 #define PARSER_VIDEO_WP		0x88
 #define PARSER_VIDEO_HOLE	0x90

 #define SEARCH_PATTERN_LEN	512

 static DECLARE_WAIT_QUEUE_HEAD(wq);
 static int search_done;

 static irqreturn_t esparser_isr(int irq, void *dev)
 {
 	int int_status;
 	struct amvdec_core *core = dev;

 	int_status = amvdec_read_parser(core, PARSER_INT_STATUS);
 	amvdec_write_parser(core, PARSER_INT_STATUS, int_status);

 	if (int_status & PARSER_INTSTAT_SC_FOUND) {
 		amvdec_write_parser(core, PFIFO_RD_PTR, 0);
 		amvdec_write_parser(core, PFIFO_WR_PTR, 0);
 		search_done = 1;
 		wake_up_interruptible(&wq);
 	}

 	return IRQ_HANDLED;
 }

 /* Pad the packet to at least 4KiB bytes otherwise the VDEC unit won't trigger
  * ISRs.
  * Also append a start code 000001ff at the end to trigger
  * the ESPARSER interrupt.
  */
 static u32 esparser_pad_start_code(struct vb2_buffer *vb)
 {
 	u32 payload_size = vb2_get_plane_payload(vb, 0);
 	u32 pad_size = 0;
 	u8 *vaddr = vb2_plane_vaddr(vb, 0) + payload_size;

 	if (payload_size < ESPARSER_MIN_PACKET_SIZE) {
 		pad_size = ESPARSER_MIN_PACKET_SIZE - payload_size;
 		memset(vaddr, 0, pad_size);
 	}

 	memset(vaddr + pad_size, 0, SEARCH_PATTERN_LEN);
 	vaddr[pad_size]     = 0x00;
 	vaddr[pad_size + 1] = 0x00;
 	vaddr[pad_size + 2] = 0x01;
 	vaddr[pad_size + 3] = 0xff;

 	return pad_size;
 }

 static int
 esparser_write_data(struct amvdec_core *core, dma_addr_t addr, u32 size)
 {
 	amvdec_write_parser(core, PFIFO_RD_PTR, 0);
 	amvdec_write_parser(core, PFIFO_WR_PTR, 0);
 	amvdec_write_parser(core, PARSER_CONTROL,
 			    ES_WRITE |
 			    ES_PARSER_START |
 			    ES_SEARCH |
 			    (size << ES_PACK_SIZE_BIT));

 	amvdec_write_parser(core, PARSER_FETCH_ADDR, addr);
 	amvdec_write_parser(core, PARSER_FETCH_CMD,
 			    (7 << FETCH_ENDIAN_BIT) |
 			    (size + SEARCH_PATTERN_LEN));

 	search_done = 0;
 	return wait_event_interruptible_timeout(wq, search_done, (HZ / 5));
 }

 static u32 esparser_vififo_get_free_space(struct amvdec_session *sess)
 {
 	u32 vififo_usage;
 	struct amvdec_ops *vdec_ops = sess->fmt_out->vdec_ops;
 	struct amvdec_core *core = sess->core;

 	vififo_usage  = vdec_ops->vififo_level(sess);
 	vififo_usage += amvdec_read_parser(core, PARSER_VIDEO_HOLE);
 	vififo_usage += (6 * SZ_1K); // 6 KiB internal fifo

 	if (vififo_usage > sess->vififo_size) {
 		dev_warn(sess->core->dev,
 			 "VIFIFO usage (%u) > VIFIFO size (%u)\n",
 			 vififo_usage, sess->vififo_size);
 		return 0;
 	}

 	return sess->vififo_size - vififo_usage;
 }

 int esparser_queue_eos(struct amvdec_core *core, const u8 *data, u32 len)
 {
 	struct device *dev = core->dev;
 	void *eos_vaddr;
 	dma_addr_t eos_paddr;
 	int ret;

 	eos_vaddr = dma_alloc_coherent(dev, len + SEARCH_PATTERN_LEN,
 				       &eos_paddr, GFP_KERNEL);
 	if (!eos_vaddr)
 		return -ENOMEM;

 	memcpy(eos_vaddr, data, len);
 	ret = esparser_write_data(core, eos_paddr, len);
 	dma_free_coherent(dev, len + SEARCH_PATTERN_LEN,
 			  eos_vaddr, eos_paddr);

 	return ret;
 }

 static u32 esparser_get_offset(struct amvdec_session *sess)
 {
 	struct amvdec_core *core = sess->core;
 	u32 offset = amvdec_read_parser(core, PARSER_VIDEO_WP) -
 		     sess->vififo_paddr;

 	if (offset < sess->last_offset)
 		sess->wrap_count++;

 	sess->last_offset = offset;
 	offset += (sess->wrap_count * sess->vififo_size);

 	return offset;
 }

 static int
 esparser_queue(struct amvdec_session *sess, struct vb2_v4l2_buffer *vbuf)
 {
 	int ret;
 	struct vb2_buffer *vb = &vbuf->vb2_buf;
 	struct amvdec_core *core = sess->core;
 	struct amvdec_codec_ops *codec_ops = sess->fmt_out->codec_ops;
 	u32 num_dst_bufs = 0;
 	u32 payload_size = vb2_get_plane_payload(vb, 0);
 	dma_addr_t phy = vb2_dma_contig_plane_dma_addr(vb, 0);
 	u32 offset;
 	u32 pad_size;

 	if (codec_ops->num_pending_bufs)
 		num_dst_bufs = codec_ops->num_pending_bufs(sess);

 	num_dst_bufs += v4l2_m2m_num_dst_bufs_ready(sess->m2m_ctx);

 	if (esparser_vififo_get_free_space(sess) < payload_size ||
 	    atomic_read(&sess->esparser_queued_bufs) >= num_dst_bufs)
 		return -EAGAIN;

 	v4l2_m2m_src_buf_remove_by_buf(sess->m2m_ctx, vbuf);

 	offset = esparser_get_offset(sess);

 	amvdec_add_ts_reorder(sess, vb->timestamp, offset);
 	dev_dbg(core->dev, "esparser: ts = %llu pld_size = %u offset = %08X\n",
 		vb->timestamp, payload_size, offset);

 	pad_size = esparser_pad_start_code(vb);
 	ret = esparser_write_data(core, phy, payload_size + pad_size);

 	if (ret <= 0) {
 		dev_warn(core->dev, "esparser: input parsing error\n");
 		amvdec_remove_ts(sess, vb->timestamp);
 		v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
 		amvdec_write_parser(core, PARSER_FETCH_CMD, 0);

 		return 0;
 	}

 	/* We need to wait until we parse the first keyframe.
 	 * All buffers prior to the first keyframe must be dropped.
 	 */
 	if (!sess->keyframe_found)
 		usleep_range(1000, 2000);

 	if (sess->keyframe_found)
 		atomic_inc(&sess->esparser_queued_bufs);
 	else
 		amvdec_remove_ts(sess, vb->timestamp);

 	vbuf->flags = 0;
 	vbuf->field = V4L2_FIELD_NONE;
 	v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE);

 	return 0;
 }

 void esparser_queue_all_src(struct work_struct *work)
 {
 	struct v4l2_m2m_buffer *buf, *n;
 	struct amvdec_session *sess =
 		container_of(work, struct amvdec_session, esparser_queue_work);

 	mutex_lock(&sess->lock);
 	v4l2_m2m_for_each_src_buf_safe(sess->m2m_ctx, buf, n) {
 		if (sess->should_stop)
 			break;

 		if (esparser_queue(sess, &buf->vb) < 0)
 			break;
 	}
 	mutex_unlock(&sess->lock);
 }

 int esparser_power_up(struct amvdec_session *sess)
 {
 	struct amvdec_core *core = sess->core;
 	struct amvdec_ops *vdec_ops = sess->fmt_out->vdec_ops;

 	reset_control_reset(core->esparser_reset);
 	amvdec_write_parser(core, PARSER_CONFIG,
 			    (10 << PS_CFG_PFIFO_EMPTY_CNT_BIT) |
 			    (1  << PS_CFG_MAX_ES_WR_CYCLE_BIT) |
 			    (16 << PS_CFG_MAX_FETCH_CYCLE_BIT));

 	amvdec_write_parser(core, PFIFO_RD_PTR, 0);
 	amvdec_write_parser(core, PFIFO_WR_PTR, 0);

 	amvdec_write_parser(core, PARSER_SEARCH_PATTERN,
 			    ES_START_CODE_PATTERN);
 	amvdec_write_parser(core, PARSER_SEARCH_MASK, ES_START_CODE_MASK);

 	amvdec_write_parser(core, PARSER_CONFIG,
 			    (10 << PS_CFG_PFIFO_EMPTY_CNT_BIT) |
 			    (1  << PS_CFG_MAX_ES_WR_CYCLE_BIT) |
 			    (16 << PS_CFG_MAX_FETCH_CYCLE_BIT) |
 			    (2  << PS_CFG_STARTCODE_WID_24_BIT));

 	amvdec_write_parser(core, PARSER_CONTROL,
 			    (ES_SEARCH | ES_PARSER_START));

 	amvdec_write_parser(core, PARSER_VIDEO_START_PTR, sess->vififo_paddr);
 	amvdec_write_parser(core, PARSER_VIDEO_END_PTR,
 			    sess->vififo_paddr + sess->vififo_size - 8);
 	amvdec_write_parser(core, PARSER_ES_CONTROL,
 			    amvdec_read_parser(core, PARSER_ES_CONTROL) & ~1);

 	if (vdec_ops->conf_esparser)
 		vdec_ops->conf_esparser(sess);

 	amvdec_write_parser(core, PARSER_INT_STATUS, 0xffff);
 	amvdec_write_parser(core, PARSER_INT_ENABLE,
 			    BIT(PARSER_INT_HOST_EN_BIT));

 	return 0;
 }

 int esparser_init(struct platform_device *pdev, struct amvdec_core *core)
 {
 	struct device *dev = &pdev->dev;
 	int ret;
 	int irq;

 	irq = platform_get_irq_byname(pdev, "esparser");
 	if (irq < 0)
 		return irq;

 	ret = devm_request_irq(dev, irq, esparser_isr, IRQF_SHARED,
 			       "esparserirq", core);
 	if (ret) {
 		dev_err(dev, "Failed requesting ESPARSER IRQ\n");
 		return ret;
 	}

 	core->esparser_reset =
 		devm_reset_control_get_exclusive(dev, "esparser");
 	if (IS_ERR(core->esparser_reset)) {
 		dev_err(dev, "Failed to get esparser_reset\n");
 		return PTR_ERR(core->esparser_reset);
 	}

 	return 0;
 }
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* Copyright (C) 2018 BayLibre, SAS
	* Author: Maxime Jourdan <mjourdan@baylibre.com>
	*
	* The Elementary Stream Parser is a HW bitstream parser.
	* It reads bitstream buffers and feeds them to the VIFIFO
	*/

	#include <linux/init.h>
	#include <linux/ioctl.h>
	#include <linux/list.h>
	#include <linux/module.h>
	#include <linux/of_device.h>
	#include <linux/reset.h>
	#include <linux/interrupt.h>
	#include <media/videobuf2-dma-contig.h>
	#include <media/v4l2-mem2mem.h>

	#include "dos_regs.h"
	#include "esparser.h"
	#include "vdec_helpers.h"

	/* PARSER REGS (CBUS) */
	#define PARSER_CONTROL 0x00
	#define ES_PACK_SIZE_BIT 8
	#define ES_WRITE BIT(5)
	#define ES_SEARCH BIT(1)
	#define ES_PARSER_START BIT(0)
	#define PARSER_FETCH_ADDR 0x4
	#define PARSER_FETCH_CMD 0x8
	#define PARSER_CONFIG 0x14
	#define PS_CFG_MAX_FETCH_CYCLE_BIT 0
	#define PS_CFG_STARTCODE_WID_24_BIT 10
	#define PS_CFG_MAX_ES_WR_CYCLE_BIT 12
	#define PS_CFG_PFIFO_EMPTY_CNT_BIT 16
	#define PFIFO_WR_PTR 0x18
	#define PFIFO_RD_PTR 0x1c
	#define PARSER_SEARCH_PATTERN 0x24
	#define ES_START_CODE_PATTERN 0x00000100
	#define PARSER_SEARCH_MASK 0x28
	#define ES_START_CODE_MASK 0xffffff00
	#define FETCH_ENDIAN_BIT 27
	#define PARSER_INT_ENABLE 0x2c
	#define PARSER_INT_HOST_EN_BIT 8
	#define PARSER_INT_STATUS 0x30
	#define PARSER_INTSTAT_SC_FOUND 1
	#define PARSER_ES_CONTROL 0x5c
	#define PARSER_VIDEO_START_PTR 0x80
	#define PARSER_VIDEO_END_PTR 0x84
	#define PARSER_VIDEO_WP 0x88
	#define PARSER_VIDEO_HOLE 0x90

	#define SEARCH_PATTERN_LEN 512

	static DECLARE_WAIT_QUEUE_HEAD(wq);
	static int search_done;

	static irqreturn_t esparser_isr(int irq, void *dev)
	{
	int int_status;
	struct amvdec_core *core = dev;

	int_status = amvdec_read_parser(core, PARSER_INT_STATUS);
	amvdec_write_parser(core, PARSER_INT_STATUS, int_status);

	if (int_status & PARSER_INTSTAT_SC_FOUND) {
	amvdec_write_parser(core, PFIFO_RD_PTR, 0);
	amvdec_write_parser(core, PFIFO_WR_PTR, 0);
	search_done = 1;
	wake_up_interruptible(&wq);
	}

	return IRQ_HANDLED;
	}

	/* Pad the packet to at least 4KiB bytes otherwise the VDEC unit won't trigger
	* ISRs.
	* Also append a start code 000001ff at the end to trigger
	* the ESPARSER interrupt.
	*/
	static u32 esparser_pad_start_code(struct vb2_buffer *vb)
	{
	u32 payload_size = vb2_get_plane_payload(vb, 0);
	u32 pad_size = 0;
	u8 *vaddr = vb2_plane_vaddr(vb, 0) + payload_size;

	if (payload_size < ESPARSER_MIN_PACKET_SIZE) {
	pad_size = ESPARSER_MIN_PACKET_SIZE - payload_size;
	memset(vaddr, 0, pad_size);
	}

	memset(vaddr + pad_size, 0, SEARCH_PATTERN_LEN);
	vaddr[pad_size] = 0x00;
	vaddr[pad_size + 1] = 0x00;
	vaddr[pad_size + 2] = 0x01;
	vaddr[pad_size + 3] = 0xff;

	return pad_size;
	}

	static int
	esparser_write_data(struct amvdec_core *core, dma_addr_t addr, u32 size)
	{
	amvdec_write_parser(core, PFIFO_RD_PTR, 0);
	amvdec_write_parser(core, PFIFO_WR_PTR, 0);
	amvdec_write_parser(core, PARSER_CONTROL,
	ES_WRITE \|
	ES_PARSER_START \|
	ES_SEARCH \|
	(size << ES_PACK_SIZE_BIT));

	amvdec_write_parser(core, PARSER_FETCH_ADDR, addr);
	amvdec_write_parser(core, PARSER_FETCH_CMD,
	(7 << FETCH_ENDIAN_BIT) \|
	(size + SEARCH_PATTERN_LEN));

	search_done = 0;
	return wait_event_interruptible_timeout(wq, search_done, (HZ / 5));
	}

	static u32 esparser_vififo_get_free_space(struct amvdec_session *sess)
	{
	u32 vififo_usage;
	struct amvdec_ops *vdec_ops = sess->fmt_out->vdec_ops;
	struct amvdec_core *core = sess->core;

	vififo_usage = vdec_ops->vififo_level(sess);
	vififo_usage += amvdec_read_parser(core, PARSER_VIDEO_HOLE);
	vififo_usage += (6 * SZ_1K); // 6 KiB internal fifo

	if (vififo_usage > sess->vififo_size) {
	dev_warn(sess->core->dev,
	"VIFIFO usage (%u) > VIFIFO size (%u)\n",
	vififo_usage, sess->vififo_size);
	return 0;
	}

	return sess->vififo_size - vififo_usage;
	}

	int esparser_queue_eos(struct amvdec_core core, const u8 data, u32 len)
	{
	struct device *dev = core->dev;
	void *eos_vaddr;
	dma_addr_t eos_paddr;
	int ret;

	eos_vaddr = dma_alloc_coherent(dev, len + SEARCH_PATTERN_LEN,
	&eos_paddr, GFP_KERNEL);
	if (!eos_vaddr)
	return -ENOMEM;

	memcpy(eos_vaddr, data, len);
	ret = esparser_write_data(core, eos_paddr, len);
	dma_free_coherent(dev, len + SEARCH_PATTERN_LEN,
	eos_vaddr, eos_paddr);

	return ret;
	}

	static u32 esparser_get_offset(struct amvdec_session *sess)
	{
	struct amvdec_core *core = sess->core;
	u32 offset = amvdec_read_parser(core, PARSER_VIDEO_WP) -
	sess->vififo_paddr;

	if (offset < sess->last_offset)
	sess->wrap_count++;

	sess->last_offset = offset;
	offset += (sess->wrap_count * sess->vififo_size);

	return offset;
	}

	static int
	esparser_queue(struct amvdec_session sess, struct vb2_v4l2_buffer vbuf)
	{
	int ret;
	struct vb2_buffer *vb = &vbuf->vb2_buf;
	struct amvdec_core *core = sess->core;
	struct amvdec_codec_ops *codec_ops = sess->fmt_out->codec_ops;
	u32 num_dst_bufs = 0;
	u32 payload_size = vb2_get_plane_payload(vb, 0);
	dma_addr_t phy = vb2_dma_contig_plane_dma_addr(vb, 0);
	u32 offset;
	u32 pad_size;

	if (codec_ops->num_pending_bufs)
	num_dst_bufs = codec_ops->num_pending_bufs(sess);

	num_dst_bufs += v4l2_m2m_num_dst_bufs_ready(sess->m2m_ctx);

	if (esparser_vififo_get_free_space(sess) < payload_size \|\|
	atomic_read(&sess->esparser_queued_bufs) >= num_dst_bufs)
	return -EAGAIN;

	v4l2_m2m_src_buf_remove_by_buf(sess->m2m_ctx, vbuf);

	offset = esparser_get_offset(sess);

	amvdec_add_ts_reorder(sess, vb->timestamp, offset);
	dev_dbg(core->dev, "esparser: ts = %llu pld_size = %u offset = %08X\n",
	vb->timestamp, payload_size, offset);

	pad_size = esparser_pad_start_code(vb);
	ret = esparser_write_data(core, phy, payload_size + pad_size);

	if (ret <= 0) {
	dev_warn(core->dev, "esparser: input parsing error\n");
	amvdec_remove_ts(sess, vb->timestamp);
	v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_ERROR);
	amvdec_write_parser(core, PARSER_FETCH_CMD, 0);

	return 0;
	}

	/* We need to wait until we parse the first keyframe.
	* All buffers prior to the first keyframe must be dropped.
	*/
	if (!sess->keyframe_found)
	usleep_range(1000, 2000);

	if (sess->keyframe_found)
	atomic_inc(&sess->esparser_queued_bufs);
	else
	amvdec_remove_ts(sess, vb->timestamp);

	vbuf->flags = 0;
	vbuf->field = V4L2_FIELD_NONE;
	v4l2_m2m_buf_done(vbuf, VB2_BUF_STATE_DONE);

	return 0;
	}

	void esparser_queue_all_src(struct work_struct *work)
	{
	struct v4l2_m2m_buffer buf, n;
	struct amvdec_session *sess =
	container_of(work, struct amvdec_session, esparser_queue_work);

	mutex_lock(&sess->lock);
	v4l2_m2m_for_each_src_buf_safe(sess->m2m_ctx, buf, n) {
	if (sess->should_stop)
	break;

	if (esparser_queue(sess, &buf->vb) < 0)
	break;
	}
	mutex_unlock(&sess->lock);
	}

	int esparser_power_up(struct amvdec_session *sess)
	{
	struct amvdec_core *core = sess->core;
	struct amvdec_ops *vdec_ops = sess->fmt_out->vdec_ops;

	reset_control_reset(core->esparser_reset);
	amvdec_write_parser(core, PARSER_CONFIG,
	(10 << PS_CFG_PFIFO_EMPTY_CNT_BIT) \|
	(1 << PS_CFG_MAX_ES_WR_CYCLE_BIT) \|
	(16 << PS_CFG_MAX_FETCH_CYCLE_BIT));

	amvdec_write_parser(core, PFIFO_RD_PTR, 0);
	amvdec_write_parser(core, PFIFO_WR_PTR, 0);

	amvdec_write_parser(core, PARSER_SEARCH_PATTERN,
	ES_START_CODE_PATTERN);
	amvdec_write_parser(core, PARSER_SEARCH_MASK, ES_START_CODE_MASK);

	amvdec_write_parser(core, PARSER_CONFIG,
	(10 << PS_CFG_PFIFO_EMPTY_CNT_BIT) \|
	(1 << PS_CFG_MAX_ES_WR_CYCLE_BIT) \|
	(16 << PS_CFG_MAX_FETCH_CYCLE_BIT) \|
	(2 << PS_CFG_STARTCODE_WID_24_BIT));

	amvdec_write_parser(core, PARSER_CONTROL,
	(ES_SEARCH \| ES_PARSER_START));

	amvdec_write_parser(core, PARSER_VIDEO_START_PTR, sess->vififo_paddr);
	amvdec_write_parser(core, PARSER_VIDEO_END_PTR,
	sess->vififo_paddr + sess->vififo_size - 8);
	amvdec_write_parser(core, PARSER_ES_CONTROL,
	amvdec_read_parser(core, PARSER_ES_CONTROL) & ~1);

	if (vdec_ops->conf_esparser)
	vdec_ops->conf_esparser(sess);

	amvdec_write_parser(core, PARSER_INT_STATUS, 0xffff);
	amvdec_write_parser(core, PARSER_INT_ENABLE,
	BIT(PARSER_INT_HOST_EN_BIT));

	return 0;
	}

	int esparser_init(struct platform_device pdev, struct amvdec_core core)
	{
	struct device *dev = &pdev->dev;
	int ret;
	int irq;

	irq = platform_get_irq_byname(pdev, "esparser");
	if (irq < 0)
	return irq;

	ret = devm_request_irq(dev, irq, esparser_isr, IRQF_SHARED,
	"esparserirq", core);
	if (ret) {
	dev_err(dev, "Failed requesting ESPARSER IRQ\n");
	return ret;
	}

	core->esparser_reset =
	devm_reset_control_get_exclusive(dev, "esparser");
	if (IS_ERR(core->esparser_reset)) {
	dev_err(dev, "Failed to get esparser_reset\n");
	return PTR_ERR(core->esparser_reset);
	}

	return 0;
	}