coresight-replicator: add CoreSight Replicator driver

obj-$(CONFIG_CORESIGHT_LINK_AND_SINK_TMC) += coresight-tmc.o

obj-$(CONFIG_CORESIGHT_SINK_TPIU) += coresight-tpiu.o

obj-$(CONFIG_CORESIGHT_SINK_ETBV10) += coresight-etb10.o

obj-$(CONFIG_CORESIGHT_LINKS_AND_SINKS) += coresight-funnel.o

obj-$(CONFIG_CORESIGHT_LINKS_AND_SINKS) += coresight-funnel.o \

					   coresight-replicator.o

/* Copyright (c) 2011-2012, 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/kernel.h>

#include <linux/module.h>

#include <linux/init.h>

#include <linux/device.h>

#include <linux/platform_device.h>

#include <linux/io.h>

#include <linux/err.h>

#include <linux/slab.h>

#include <linux/clk.h>

#include <linux/of.h>

#include <linux/coresight.h>

#include "coresight-priv.h"

/**

 * struct replicator_drvdata - specifics associated to a replicator component

 * @dev:	the device entity associated with this component

 * @csdev:	component vitals needed by the framework

 */

struct replicator_drvdata {

	struct device		*dev;

	struct coresight_device	*csdev;

};

static int replicator_enable(struct coresight_device *csdev, int inport,

			     int outport)

{

	struct replicator_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);

	dev_info(drvdata->dev, "REPLICATOR enabled\n");

	return 0;

}

static void replicator_disable(struct coresight_device *csdev, int inport,

			       int outport)

{

	struct replicator_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);

	dev_info(drvdata->dev, "REPLICATOR disabled\n");

}

static const struct coresight_ops_link replicator_link_ops = {

	.enable		= replicator_enable,

	.disable	= replicator_disable,

};

static const struct coresight_ops replicator_cs_ops = {

	.link_ops	= &replicator_link_ops,

};

static int replicator_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct coresight_platform_data *pdata = NULL;

	struct replicator_drvdata *drvdata;

	struct coresight_desc *desc;

	struct device_node *np = pdev->dev.of_node;

	if (np) {

		pdata = of_get_coresight_platform_data(dev, np);

		if (IS_ERR(pdata))

			return PTR_ERR(pdata);

		pdev->dev.platform_data = pdata;

	}

	drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);

	if (!drvdata)

		return -ENOMEM;

	drvdata->dev = &pdev->dev;

	platform_set_drvdata(pdev, drvdata);

	desc = devm_kzalloc(dev, sizeof(*desc), GFP_KERNEL);

	if (!desc)

		return -ENOMEM;

	desc->type = CORESIGHT_DEV_TYPE_LINK;

	desc->subtype.sink_subtype = CORESIGHT_DEV_SUBTYPE_LINK_SPLIT;

	desc->ops = &replicator_cs_ops;

	desc->pdata = pdev->dev.platform_data;

	desc->dev = &pdev->dev;

	drvdata->csdev = coresight_register(desc);

	if (IS_ERR(drvdata->csdev))

		return PTR_ERR(drvdata->csdev);

	dev_info(dev, "REPLICATOR initialized\n");

	return 0;

}

static int replicator_remove(struct platform_device *pdev)

{

	struct replicator_drvdata *drvdata = platform_get_drvdata(pdev);

	coresight_unregister(drvdata->csdev);

	return 0;

}

static struct of_device_id replicator_match[] = {

	{.compatible = "arm,coresight-replicator"},

	{}

};

static struct platform_driver replicator_driver = {

	.probe          = replicator_probe,

	.remove         = replicator_remove,

	.driver         = {

		.name   = "coresight-replicator",

		.owner	= THIS_MODULE,

		.of_match_table = replicator_match,

	},

};

static int __init replicator_init(void)

{

	return platform_driver_register(&replicator_driver);

}

module_init(replicator_init);

static void __exit replicator_exit(void)

{

	platform_driver_unregister(&replicator_driver);

}

module_exit(replicator_exit);

MODULE_LICENSE("GPL v2");

MODULE_DESCRIPTION("CoreSight Replicator driver");