[mirror_ubuntu-hirsute-kernel.git] / drivers / rapidio / switches / idtcps.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * IDT CPS RapidIO switches support
 *
 * Copyright 2009-2010 Integrated Device Technology, Inc.
 * Alexandre Bounine <alexandre.bounine@idt.com>
 */

#include <linux/rio.h>
#include <linux/rio_drv.h>
#include <linux/rio_ids.h>
#include <linux/module.h>
#include "../rio.h"

#define CPS_DEFAULT_ROUTE	0xde
#define CPS_NO_ROUTE		0xdf

#define IDTCPS_RIO_DOMAIN 0xf20020

static int
idtcps_route_add_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
		       u16 table, u16 route_destid, u8 route_port)
{
	u32 result;

	if (route_port == RIO_INVALID_ROUTE)
		route_port = CPS_DEFAULT_ROUTE;

	if (table == RIO_GLOBAL_TABLE) {
		rio_mport_write_config_32(mport, destid, hopcount,
				RIO_STD_RTE_CONF_DESTID_SEL_CSR, route_destid);

		rio_mport_read_config_32(mport, destid, hopcount,
				RIO_STD_RTE_CONF_PORT_SEL_CSR, &result);

		result = (0xffffff00 & result) | (u32)route_port;
		rio_mport_write_config_32(mport, destid, hopcount,
				RIO_STD_RTE_CONF_PORT_SEL_CSR, result);
	}

	return 0;
}

static int
idtcps_route_get_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
		       u16 table, u16 route_destid, u8 *route_port)
{
	u32 result;

	if (table == RIO_GLOBAL_TABLE) {
		rio_mport_write_config_32(mport, destid, hopcount,
				RIO_STD_RTE_CONF_DESTID_SEL_CSR, route_destid);

		rio_mport_read_config_32(mport, destid, hopcount,
				RIO_STD_RTE_CONF_PORT_SEL_CSR, &result);

		if (CPS_DEFAULT_ROUTE == (u8)result ||
		    CPS_NO_ROUTE == (u8)result)
			*route_port = RIO_INVALID_ROUTE;
		else
			*route_port = (u8)result;
	}

	return 0;
}

static int
idtcps_route_clr_table(struct rio_mport *mport, u16 destid, u8 hopcount,
		       u16 table)
{
	u32 i;

	if (table == RIO_GLOBAL_TABLE) {
		for (i = 0x80000000; i <= 0x800000ff;) {
			rio_mport_write_config_32(mport, destid, hopcount,
				RIO_STD_RTE_CONF_DESTID_SEL_CSR, i);
			rio_mport_write_config_32(mport, destid, hopcount,
				RIO_STD_RTE_CONF_PORT_SEL_CSR,
				(CPS_DEFAULT_ROUTE << 24) |
				(CPS_DEFAULT_ROUTE << 16) |
				(CPS_DEFAULT_ROUTE << 8) | CPS_DEFAULT_ROUTE);
			i += 4;
		}
	}

	return 0;
}

static int
idtcps_set_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
		       u8 sw_domain)
{
	/*
	 * Switch domain configuration operates only at global level
	 */
	rio_mport_write_config_32(mport, destid, hopcount,
				  IDTCPS_RIO_DOMAIN, (u32)sw_domain);
	return 0;
}

static int
idtcps_get_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
		       u8 *sw_domain)
{
	u32 regval;

	/*
	 * Switch domain configuration operates only at global level
	 */
	rio_mport_read_config_32(mport, destid, hopcount,
				IDTCPS_RIO_DOMAIN, &regval);

	*sw_domain = (u8)(regval & 0xff);

	return 0;
}

static struct rio_switch_ops idtcps_switch_ops = {
	.owner = THIS_MODULE,
	.add_entry = idtcps_route_add_entry,
	.get_entry = idtcps_route_get_entry,
	.clr_table = idtcps_route_clr_table,
	.set_domain = idtcps_set_domain,
	.get_domain = idtcps_get_domain,
	.em_init = NULL,
	.em_handle = NULL,
};

static int idtcps_probe(struct rio_dev *rdev, const struct rio_device_id *id)
{
	pr_debug("RIO: %s for %s\n", __func__, rio_name(rdev));

	spin_lock(&rdev->rswitch->lock);

	if (rdev->rswitch->ops) {
		spin_unlock(&rdev->rswitch->lock);
		return -EINVAL;
	}

	rdev->rswitch->ops = &idtcps_switch_ops;

	if (rdev->do_enum) {
		/* set TVAL = ~50us */
		rio_write_config_32(rdev,
			rdev->phys_efptr + RIO_PORT_LINKTO_CTL_CSR, 0x8e << 8);
		/* Ensure that default routing is disabled on startup */
		rio_write_config_32(rdev,
				    RIO_STD_RTE_DEFAULT_PORT, CPS_NO_ROUTE);
	}

	spin_unlock(&rdev->rswitch->lock);
	return 0;
}

static void idtcps_remove(struct rio_dev *rdev)
{
	pr_debug("RIO: %s for %s\n", __func__, rio_name(rdev));
	spin_lock(&rdev->rswitch->lock);
	if (rdev->rswitch->ops != &idtcps_switch_ops) {
		spin_unlock(&rdev->rswitch->lock);
		return;
	}
	rdev->rswitch->ops = NULL;
	spin_unlock(&rdev->rswitch->lock);
}

static const struct rio_device_id idtcps_id_table[] = {
	{RIO_DEVICE(RIO_DID_IDTCPS6Q, RIO_VID_IDT)},
	{RIO_DEVICE(RIO_DID_IDTCPS8, RIO_VID_IDT)},
	{RIO_DEVICE(RIO_DID_IDTCPS10Q, RIO_VID_IDT)},
	{RIO_DEVICE(RIO_DID_IDTCPS12, RIO_VID_IDT)},
	{RIO_DEVICE(RIO_DID_IDTCPS16, RIO_VID_IDT)},
	{RIO_DEVICE(RIO_DID_IDT70K200, RIO_VID_IDT)},
	{ 0, }	/* terminate list */
};

static struct rio_driver idtcps_driver = {
	.name = "idtcps",
	.id_table = idtcps_id_table,
	.probe = idtcps_probe,
	.remove = idtcps_remove,
};

static int __init idtcps_init(void)
{
	return rio_register_driver(&idtcps_driver);
}

static void __exit idtcps_exit(void)
{
	rio_unregister_driver(&idtcps_driver);
}

device_initcall(idtcps_init);
module_exit(idtcps_exit);

MODULE_DESCRIPTION("IDT CPS Gen.1 Serial RapidIO switch family driver");
MODULE_AUTHOR("Integrated Device Technology, Inc.");
MODULE_LICENSE("GPL");
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
07590ff0 AB	2	/*
	3	* IDT CPS RapidIO switches support
	4	*
058f88d6 AB	5	* Copyright 2009-2010 Integrated Device Technology, Inc.
058f88d6 AB	6	* Alexandre Bounine <alexandre.bounine@idt.com>
07590ff0 AB	7	*/
	8
	9	#include <linux/rio.h>
	10	#include <linux/rio_drv.h>
	11	#include <linux/rio_ids.h>
2ec3ba69	12	#include <linux/module.h>
07590ff0 AB	13	#include "../rio.h"
07590ff0 AB	14
679395fd AB	15	#define CPS_DEFAULT_ROUTE 0xde
679395fd AB	16	#define CPS_NO_ROUTE 0xdf
07590ff0	17
7a88d628 AB	18	#define IDTCPS_RIO_DOMAIN 0xf20020
7a88d628 AB	19
07590ff0 AB	20	static int
	21	idtcps_route_add_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
	22	u16 table, u16 route_destid, u8 route_port)
	23	{
	24	u32 result;
	25
0bf2461f AB	26	if (route_port == RIO_INVALID_ROUTE)
	27	route_port = CPS_DEFAULT_ROUTE;
	28
07590ff0 AB	29	if (table == RIO_GLOBAL_TABLE) {
	30	rio_mport_write_config_32(mport, destid, hopcount,
	31	RIO_STD_RTE_CONF_DESTID_SEL_CSR, route_destid);
	32
	33	rio_mport_read_config_32(mport, destid, hopcount,
	34	RIO_STD_RTE_CONF_PORT_SEL_CSR, &result);
	35
	36	result = (0xffffff00 & result) \| (u32)route_port;
	37	rio_mport_write_config_32(mport, destid, hopcount,
	38	RIO_STD_RTE_CONF_PORT_SEL_CSR, result);
	39	}
	40
	41	return 0;
	42	}
	43
	44	static int
	45	idtcps_route_get_entry(struct rio_mport *mport, u16 destid, u8 hopcount,
	46	u16 table, u16 route_destid, u8 *route_port)
	47	{
	48	u32 result;
	49
	50	if (table == RIO_GLOBAL_TABLE) {
	51	rio_mport_write_config_32(mport, destid, hopcount,
	52	RIO_STD_RTE_CONF_DESTID_SEL_CSR, route_destid);
	53
	54	rio_mport_read_config_32(mport, destid, hopcount,
	55	RIO_STD_RTE_CONF_PORT_SEL_CSR, &result);
	56
679395fd AB	57	if (CPS_DEFAULT_ROUTE == (u8)result \|\|
	58	CPS_NO_ROUTE == (u8)result)
	59	*route_port = RIO_INVALID_ROUTE;
	60	else
	61	*route_port = (u8)result;
07590ff0 AB	62	}
	63
	64	return 0;
	65	}
	66
	67	static int
	68	idtcps_route_clr_table(struct rio_mport *mport, u16 destid, u8 hopcount,
	69	u16 table)
	70	{
	71	u32 i;
	72
	73	if (table == RIO_GLOBAL_TABLE) {
	74	for (i = 0x80000000; i <= 0x800000ff;) {
	75	rio_mport_write_config_32(mport, destid, hopcount,
	76	RIO_STD_RTE_CONF_DESTID_SEL_CSR, i);
	77	rio_mport_write_config_32(mport, destid, hopcount,
	78	RIO_STD_RTE_CONF_PORT_SEL_CSR,
679395fd AB	79	(CPS_DEFAULT_ROUTE << 24) \|
	80	(CPS_DEFAULT_ROUTE << 16) \|
	81	(CPS_DEFAULT_ROUTE << 8) \| CPS_DEFAULT_ROUTE);
07590ff0 AB	82	i += 4;
	83	}
	84	}
	85
	86	return 0;
	87	}
	88
7a88d628 AB	89	static int
	90	idtcps_set_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
	91	u8 sw_domain)
	92	{
	93	/*
	94	* Switch domain configuration operates only at global level
	95	*/
	96	rio_mport_write_config_32(mport, destid, hopcount,
	97	IDTCPS_RIO_DOMAIN, (u32)sw_domain);
	98	return 0;
	99	}
	100
	101	static int
	102	idtcps_get_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
	103	u8 *sw_domain)
	104	{
	105	u32 regval;
	106
	107	/*
	108	* Switch domain configuration operates only at global level
	109	*/
	110	rio_mport_read_config_32(mport, destid, hopcount,
	111	IDTCPS_RIO_DOMAIN, &regval);
	112
	113	*sw_domain = (u8)(regval & 0xff);
	114
	115	return 0;
	116	}
	117
2ec3ba69 AB	118	static struct rio_switch_ops idtcps_switch_ops = {
	119	.owner = THIS_MODULE,
	120	.add_entry = idtcps_route_add_entry,
	121	.get_entry = idtcps_route_get_entry,
	122	.clr_table = idtcps_route_clr_table,
	123	.set_domain = idtcps_set_domain,
	124	.get_domain = idtcps_get_domain,
	125	.em_init = NULL,
	126	.em_handle = NULL,
	127	};
	128
	129	static int idtcps_probe(struct rio_dev rdev, const struct rio_device_id id)
058f88d6 AB	130	{
058f88d6 AB	131	pr_debug("RIO: %s for %s\n", __func__, rio_name(rdev));
2ec3ba69 AB	132
	133	spin_lock(&rdev->rswitch->lock);
	134
	135	if (rdev->rswitch->ops) {
	136	spin_unlock(&rdev->rswitch->lock);
	137	return -EINVAL;
	138	}
	139
	140	rdev->rswitch->ops = &idtcps_switch_ops;
	141
	142	if (rdev->do_enum) {
dd5648c9	143	/* set TVAL = ~50us */
a93192a5	144	rio_write_config_32(rdev,
dd5648c9	145	rdev->phys_efptr + RIO_PORT_LINKTO_CTL_CSR, 0x8e << 8);
0bf2461f AB	146	/* Ensure that default routing is disabled on startup */
	147	rio_write_config_32(rdev,
	148	RIO_STD_RTE_DEFAULT_PORT, CPS_NO_ROUTE);
dd5648c9 AB	149	}
dd5648c9 AB	150
2ec3ba69	151	spin_unlock(&rdev->rswitch->lock);
058f88d6 AB	152	return 0;
	153	}
	154
2ec3ba69 AB	155	static void idtcps_remove(struct rio_dev *rdev)
	156	{
	157	pr_debug("RIO: %s for %s\n", __func__, rio_name(rdev));
	158	spin_lock(&rdev->rswitch->lock);
	159	if (rdev->rswitch->ops != &idtcps_switch_ops) {
	160	spin_unlock(&rdev->rswitch->lock);
	161	return;
	162	}
	163	rdev->rswitch->ops = NULL;
	164	spin_unlock(&rdev->rswitch->lock);
	165	}
	166
c1b1418a	167	static const struct rio_device_id idtcps_id_table[] = {
2ec3ba69 AB	168	{RIO_DEVICE(RIO_DID_IDTCPS6Q, RIO_VID_IDT)},
	169	{RIO_DEVICE(RIO_DID_IDTCPS8, RIO_VID_IDT)},
	170	{RIO_DEVICE(RIO_DID_IDTCPS10Q, RIO_VID_IDT)},
	171	{RIO_DEVICE(RIO_DID_IDTCPS12, RIO_VID_IDT)},
	172	{RIO_DEVICE(RIO_DID_IDTCPS16, RIO_VID_IDT)},
	173	{RIO_DEVICE(RIO_DID_IDT70K200, RIO_VID_IDT)},
	174	{ 0, } /* terminate list */
	175	};
	176
	177	static struct rio_driver idtcps_driver = {
	178	.name = "idtcps",
	179	.id_table = idtcps_id_table,
	180	.probe = idtcps_probe,
	181	.remove = idtcps_remove,
	182	};
	183
	184	static int __init idtcps_init(void)
	185	{
	186	return rio_register_driver(&idtcps_driver);
	187	}
	188
	189	static void __exit idtcps_exit(void)
	190	{
	191	rio_unregister_driver(&idtcps_driver);
	192	}
	193
	194	device_initcall(idtcps_init);
	195	module_exit(idtcps_exit);
	196
	197	MODULE_DESCRIPTION("IDT CPS Gen.1 Serial RapidIO switch family driver");
	198	MODULE_AUTHOR("Integrated Device Technology, Inc.");
	199	MODULE_LICENSE("GPL");