mirror of
https://github.com/torvalds/linux.git
synced 2024-11-15 00:21:59 +00:00
1802d0beec
Based on 1 normalized pattern(s): this program 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 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 extracted by the scancode license scanner the SPDX license identifier GPL-2.0-only has been chosen to replace the boilerplate/reference in 655 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org> Reviewed-by: Richard Fontana <rfontana@redhat.com> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190527070034.575739538@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
340 lines
9.2 KiB
C
340 lines
9.2 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* FSI hub master driver
|
|
*
|
|
* Copyright (C) IBM Corporation 2016
|
|
*/
|
|
|
|
#include <linux/delay.h>
|
|
#include <linux/fsi.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include "fsi-master.h"
|
|
|
|
/* Control Registers */
|
|
#define FSI_MMODE 0x0 /* R/W: mode */
|
|
#define FSI_MDLYR 0x4 /* R/W: delay */
|
|
#define FSI_MCRSP 0x8 /* R/W: clock rate */
|
|
#define FSI_MENP0 0x10 /* R/W: enable */
|
|
#define FSI_MLEVP0 0x18 /* R: plug detect */
|
|
#define FSI_MSENP0 0x18 /* S: Set enable */
|
|
#define FSI_MCENP0 0x20 /* C: Clear enable */
|
|
#define FSI_MAEB 0x70 /* R: Error address */
|
|
#define FSI_MVER 0x74 /* R: master version/type */
|
|
#define FSI_MRESP0 0xd0 /* W: Port reset */
|
|
#define FSI_MESRB0 0x1d0 /* R: Master error status */
|
|
#define FSI_MRESB0 0x1d0 /* W: Reset bridge */
|
|
#define FSI_MECTRL 0x2e0 /* W: Error control */
|
|
|
|
/* MMODE: Mode control */
|
|
#define FSI_MMODE_EIP 0x80000000 /* Enable interrupt polling */
|
|
#define FSI_MMODE_ECRC 0x40000000 /* Enable error recovery */
|
|
#define FSI_MMODE_EPC 0x10000000 /* Enable parity checking */
|
|
#define FSI_MMODE_P8_TO_LSB 0x00000010 /* Timeout value LSB */
|
|
/* MSB=1, LSB=0 is 0.8 ms */
|
|
/* MSB=0, LSB=1 is 0.9 ms */
|
|
#define FSI_MMODE_CRS0SHFT 18 /* Clk rate selection 0 shift */
|
|
#define FSI_MMODE_CRS0MASK 0x3ff /* Clk rate selection 0 mask */
|
|
#define FSI_MMODE_CRS1SHFT 8 /* Clk rate selection 1 shift */
|
|
#define FSI_MMODE_CRS1MASK 0x3ff /* Clk rate selection 1 mask */
|
|
|
|
/* MRESB: Reset brindge */
|
|
#define FSI_MRESB_RST_GEN 0x80000000 /* General reset */
|
|
#define FSI_MRESB_RST_ERR 0x40000000 /* Error Reset */
|
|
|
|
/* MRESB: Reset port */
|
|
#define FSI_MRESP_RST_ALL_MASTER 0x20000000 /* Reset all FSI masters */
|
|
#define FSI_MRESP_RST_ALL_LINK 0x10000000 /* Reset all FSI port contr. */
|
|
#define FSI_MRESP_RST_MCR 0x08000000 /* Reset FSI master reg. */
|
|
#define FSI_MRESP_RST_PYE 0x04000000 /* Reset FSI parity error */
|
|
#define FSI_MRESP_RST_ALL 0xfc000000 /* Reset any error */
|
|
|
|
/* MECTRL: Error control */
|
|
#define FSI_MECTRL_EOAE 0x8000 /* Enable machine check when */
|
|
/* master 0 in error */
|
|
#define FSI_MECTRL_P8_AUTO_TERM 0x4000 /* Auto terminate */
|
|
|
|
#define FSI_ENGID_HUB_MASTER 0x1c
|
|
#define FSI_HUB_LINK_OFFSET 0x80000
|
|
#define FSI_HUB_LINK_SIZE 0x80000
|
|
#define FSI_HUB_MASTER_MAX_LINKS 8
|
|
|
|
#define FSI_LINK_ENABLE_SETUP_TIME 10 /* in mS */
|
|
|
|
/*
|
|
* FSI hub master support
|
|
*
|
|
* A hub master increases the number of potential target devices that the
|
|
* primary FSI master can access. For each link a primary master supports,
|
|
* each of those links can in turn be chained to a hub master with multiple
|
|
* links of its own.
|
|
*
|
|
* The hub is controlled by a set of control registers exposed as a regular fsi
|
|
* device (the hub->upstream device), and provides access to the downstream FSI
|
|
* bus as through an address range on the slave itself (->addr and ->size).
|
|
*
|
|
* [This differs from "cascaded" masters, which expose the entire downstream
|
|
* bus entirely through the fsi device address range, and so have a smaller
|
|
* accessible address space.]
|
|
*/
|
|
struct fsi_master_hub {
|
|
struct fsi_master master;
|
|
struct fsi_device *upstream;
|
|
uint32_t addr, size; /* slave-relative addr of */
|
|
/* master address space */
|
|
};
|
|
|
|
#define to_fsi_master_hub(m) container_of(m, struct fsi_master_hub, master)
|
|
|
|
static int hub_master_read(struct fsi_master *master, int link,
|
|
uint8_t id, uint32_t addr, void *val, size_t size)
|
|
{
|
|
struct fsi_master_hub *hub = to_fsi_master_hub(master);
|
|
|
|
if (id != 0)
|
|
return -EINVAL;
|
|
|
|
addr += hub->addr + (link * FSI_HUB_LINK_SIZE);
|
|
return fsi_slave_read(hub->upstream->slave, addr, val, size);
|
|
}
|
|
|
|
static int hub_master_write(struct fsi_master *master, int link,
|
|
uint8_t id, uint32_t addr, const void *val, size_t size)
|
|
{
|
|
struct fsi_master_hub *hub = to_fsi_master_hub(master);
|
|
|
|
if (id != 0)
|
|
return -EINVAL;
|
|
|
|
addr += hub->addr + (link * FSI_HUB_LINK_SIZE);
|
|
return fsi_slave_write(hub->upstream->slave, addr, val, size);
|
|
}
|
|
|
|
static int hub_master_break(struct fsi_master *master, int link)
|
|
{
|
|
uint32_t addr;
|
|
__be32 cmd;
|
|
|
|
addr = 0x4;
|
|
cmd = cpu_to_be32(0xc0de0000);
|
|
|
|
return hub_master_write(master, link, 0, addr, &cmd, sizeof(cmd));
|
|
}
|
|
|
|
static int hub_master_link_enable(struct fsi_master *master, int link)
|
|
{
|
|
struct fsi_master_hub *hub = to_fsi_master_hub(master);
|
|
int idx, bit;
|
|
__be32 reg;
|
|
int rc;
|
|
|
|
idx = link / 32;
|
|
bit = link % 32;
|
|
|
|
reg = cpu_to_be32(0x80000000 >> bit);
|
|
|
|
rc = fsi_device_write(hub->upstream, FSI_MSENP0 + (4 * idx), ®, 4);
|
|
|
|
mdelay(FSI_LINK_ENABLE_SETUP_TIME);
|
|
|
|
fsi_device_read(hub->upstream, FSI_MENP0 + (4 * idx), ®, 4);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static void hub_master_release(struct device *dev)
|
|
{
|
|
struct fsi_master_hub *hub = to_fsi_master_hub(dev_to_fsi_master(dev));
|
|
|
|
kfree(hub);
|
|
}
|
|
|
|
/* mmode encoders */
|
|
static inline u32 fsi_mmode_crs0(u32 x)
|
|
{
|
|
return (x & FSI_MMODE_CRS0MASK) << FSI_MMODE_CRS0SHFT;
|
|
}
|
|
|
|
static inline u32 fsi_mmode_crs1(u32 x)
|
|
{
|
|
return (x & FSI_MMODE_CRS1MASK) << FSI_MMODE_CRS1SHFT;
|
|
}
|
|
|
|
static int hub_master_init(struct fsi_master_hub *hub)
|
|
{
|
|
struct fsi_device *dev = hub->upstream;
|
|
__be32 reg;
|
|
int rc;
|
|
|
|
reg = cpu_to_be32(FSI_MRESP_RST_ALL_MASTER | FSI_MRESP_RST_ALL_LINK
|
|
| FSI_MRESP_RST_MCR | FSI_MRESP_RST_PYE);
|
|
rc = fsi_device_write(dev, FSI_MRESP0, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
/* Initialize the MFSI (hub master) engine */
|
|
reg = cpu_to_be32(FSI_MRESP_RST_ALL_MASTER | FSI_MRESP_RST_ALL_LINK
|
|
| FSI_MRESP_RST_MCR | FSI_MRESP_RST_PYE);
|
|
rc = fsi_device_write(dev, FSI_MRESP0, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
reg = cpu_to_be32(FSI_MECTRL_EOAE | FSI_MECTRL_P8_AUTO_TERM);
|
|
rc = fsi_device_write(dev, FSI_MECTRL, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
reg = cpu_to_be32(FSI_MMODE_EIP | FSI_MMODE_ECRC | FSI_MMODE_EPC
|
|
| fsi_mmode_crs0(1) | fsi_mmode_crs1(1)
|
|
| FSI_MMODE_P8_TO_LSB);
|
|
rc = fsi_device_write(dev, FSI_MMODE, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
reg = cpu_to_be32(0xffff0000);
|
|
rc = fsi_device_write(dev, FSI_MDLYR, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
reg = cpu_to_be32(~0);
|
|
rc = fsi_device_write(dev, FSI_MSENP0, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
/* Leave enabled long enough for master logic to set up */
|
|
mdelay(FSI_LINK_ENABLE_SETUP_TIME);
|
|
|
|
rc = fsi_device_write(dev, FSI_MCENP0, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
rc = fsi_device_read(dev, FSI_MAEB, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
reg = cpu_to_be32(FSI_MRESP_RST_ALL_MASTER | FSI_MRESP_RST_ALL_LINK);
|
|
rc = fsi_device_write(dev, FSI_MRESP0, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
rc = fsi_device_read(dev, FSI_MLEVP0, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
/* Reset the master bridge */
|
|
reg = cpu_to_be32(FSI_MRESB_RST_GEN);
|
|
rc = fsi_device_write(dev, FSI_MRESB0, ®, sizeof(reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
reg = cpu_to_be32(FSI_MRESB_RST_ERR);
|
|
return fsi_device_write(dev, FSI_MRESB0, ®, sizeof(reg));
|
|
}
|
|
|
|
static int hub_master_probe(struct device *dev)
|
|
{
|
|
struct fsi_device *fsi_dev = to_fsi_dev(dev);
|
|
struct fsi_master_hub *hub;
|
|
uint32_t reg, links;
|
|
__be32 __reg;
|
|
int rc;
|
|
|
|
rc = fsi_device_read(fsi_dev, FSI_MVER, &__reg, sizeof(__reg));
|
|
if (rc)
|
|
return rc;
|
|
|
|
reg = be32_to_cpu(__reg);
|
|
links = (reg >> 8) & 0xff;
|
|
dev_dbg(dev, "hub version %08x (%d links)\n", reg, links);
|
|
|
|
rc = fsi_slave_claim_range(fsi_dev->slave, FSI_HUB_LINK_OFFSET,
|
|
FSI_HUB_LINK_SIZE * links);
|
|
if (rc) {
|
|
dev_err(dev, "can't claim slave address range for links");
|
|
return rc;
|
|
}
|
|
|
|
hub = kzalloc(sizeof(*hub), GFP_KERNEL);
|
|
if (!hub) {
|
|
rc = -ENOMEM;
|
|
goto err_release;
|
|
}
|
|
|
|
hub->addr = FSI_HUB_LINK_OFFSET;
|
|
hub->size = FSI_HUB_LINK_SIZE * links;
|
|
hub->upstream = fsi_dev;
|
|
|
|
hub->master.dev.parent = dev;
|
|
hub->master.dev.release = hub_master_release;
|
|
hub->master.dev.of_node = of_node_get(dev_of_node(dev));
|
|
|
|
hub->master.n_links = links;
|
|
hub->master.read = hub_master_read;
|
|
hub->master.write = hub_master_write;
|
|
hub->master.send_break = hub_master_break;
|
|
hub->master.link_enable = hub_master_link_enable;
|
|
|
|
dev_set_drvdata(dev, hub);
|
|
|
|
hub_master_init(hub);
|
|
|
|
rc = fsi_master_register(&hub->master);
|
|
if (rc)
|
|
goto err_release;
|
|
|
|
/* At this point, fsi_master_register performs the device_initialize(),
|
|
* and holds the sole reference on master.dev. This means the device
|
|
* will be freed (via ->release) during any subsequent call to
|
|
* fsi_master_unregister. We add our own reference to it here, so we
|
|
* can perform cleanup (in _remove()) without it being freed before
|
|
* we're ready.
|
|
*/
|
|
get_device(&hub->master.dev);
|
|
return 0;
|
|
|
|
err_release:
|
|
fsi_slave_release_range(fsi_dev->slave, FSI_HUB_LINK_OFFSET,
|
|
FSI_HUB_LINK_SIZE * links);
|
|
return rc;
|
|
}
|
|
|
|
static int hub_master_remove(struct device *dev)
|
|
{
|
|
struct fsi_master_hub *hub = dev_get_drvdata(dev);
|
|
|
|
fsi_master_unregister(&hub->master);
|
|
fsi_slave_release_range(hub->upstream->slave, hub->addr, hub->size);
|
|
of_node_put(hub->master.dev.of_node);
|
|
|
|
/*
|
|
* master.dev will likely be ->release()ed after this, which free()s
|
|
* the hub
|
|
*/
|
|
put_device(&hub->master.dev);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct fsi_device_id hub_master_ids[] = {
|
|
{
|
|
.engine_type = FSI_ENGID_HUB_MASTER,
|
|
.version = FSI_VERSION_ANY,
|
|
},
|
|
{ 0 }
|
|
};
|
|
|
|
static struct fsi_driver hub_master_driver = {
|
|
.id_table = hub_master_ids,
|
|
.drv = {
|
|
.name = "fsi-master-hub",
|
|
.bus = &fsi_bus_type,
|
|
.probe = hub_master_probe,
|
|
.remove = hub_master_remove,
|
|
}
|
|
};
|
|
|
|
module_fsi_driver(hub_master_driver);
|
|
MODULE_LICENSE("GPL");
|