300 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * FSI hub master driver4 *5 * Copyright (C) IBM Corporation 20166 */7 8#include <linux/delay.h>9#include <linux/fsi.h>10#include <linux/module.h>11#include <linux/of.h>12#include <linux/slab.h>13 14#include "fsi-master.h"15 16#define FSI_ENGID_HUB_MASTER 0x1c17 18#define FSI_LINK_ENABLE_SETUP_TIME 10 /* in mS */19 20/*21 * FSI hub master support22 *23 * A hub master increases the number of potential target devices that the24 * primary FSI master can access. For each link a primary master supports,25 * each of those links can in turn be chained to a hub master with multiple26 * links of its own.27 *28 * The hub is controlled by a set of control registers exposed as a regular fsi29 * device (the hub->upstream device), and provides access to the downstream FSI30 * bus as through an address range on the slave itself (->addr and ->size).31 *32 * [This differs from "cascaded" masters, which expose the entire downstream33 * bus entirely through the fsi device address range, and so have a smaller34 * accessible address space.]35 */36struct fsi_master_hub {37 struct fsi_master master;38 struct fsi_device *upstream;39 uint32_t addr, size; /* slave-relative addr of */40 /* master address space */41};42 43#define to_fsi_master_hub(m) container_of(m, struct fsi_master_hub, master)44 45static int hub_master_read(struct fsi_master *master, int link,46 uint8_t id, uint32_t addr, void *val, size_t size)47{48 struct fsi_master_hub *hub = to_fsi_master_hub(master);49 50 if (id != 0)51 return -EINVAL;52 53 addr += hub->addr + (link * FSI_HUB_LINK_SIZE);54 return fsi_slave_read(hub->upstream->slave, addr, val, size);55}56 57static int hub_master_write(struct fsi_master *master, int link,58 uint8_t id, uint32_t addr, const void *val, size_t size)59{60 struct fsi_master_hub *hub = to_fsi_master_hub(master);61 62 if (id != 0)63 return -EINVAL;64 65 addr += hub->addr + (link * FSI_HUB_LINK_SIZE);66 return fsi_slave_write(hub->upstream->slave, addr, val, size);67}68 69static int hub_master_break(struct fsi_master *master, int link)70{71 uint32_t addr;72 __be32 cmd;73 74 addr = 0x4;75 cmd = cpu_to_be32(0xc0de0000);76 77 return hub_master_write(master, link, 0, addr, &cmd, sizeof(cmd));78}79 80static int hub_master_link_enable(struct fsi_master *master, int link,81 bool enable)82{83 struct fsi_master_hub *hub = to_fsi_master_hub(master);84 int idx, bit;85 __be32 reg;86 int rc;87 88 idx = link / 32;89 bit = link % 32;90 91 reg = cpu_to_be32(0x80000000 >> bit);92 93 if (!enable)94 return fsi_device_write(hub->upstream, FSI_MCENP0 + (4 * idx),95 ®, 4);96 97 rc = fsi_device_write(hub->upstream, FSI_MSENP0 + (4 * idx), ®, 4);98 if (rc)99 return rc;100 101 mdelay(FSI_LINK_ENABLE_SETUP_TIME);102 103 return 0;104}105 106static void hub_master_release(struct device *dev)107{108 struct fsi_master_hub *hub = to_fsi_master_hub(to_fsi_master(dev));109 110 kfree(hub);111}112 113/* mmode encoders */114static inline u32 fsi_mmode_crs0(u32 x)115{116 return (x & FSI_MMODE_CRS0MASK) << FSI_MMODE_CRS0SHFT;117}118 119static inline u32 fsi_mmode_crs1(u32 x)120{121 return (x & FSI_MMODE_CRS1MASK) << FSI_MMODE_CRS1SHFT;122}123 124static int hub_master_init(struct fsi_master_hub *hub)125{126 struct fsi_device *dev = hub->upstream;127 __be32 reg;128 int rc;129 130 reg = cpu_to_be32(FSI_MRESP_RST_ALL_MASTER | FSI_MRESP_RST_ALL_LINK131 | FSI_MRESP_RST_MCR | FSI_MRESP_RST_PYE);132 rc = fsi_device_write(dev, FSI_MRESP0, ®, sizeof(reg));133 if (rc)134 return rc;135 136 /* Initialize the MFSI (hub master) engine */137 reg = cpu_to_be32(FSI_MRESP_RST_ALL_MASTER | FSI_MRESP_RST_ALL_LINK138 | FSI_MRESP_RST_MCR | FSI_MRESP_RST_PYE);139 rc = fsi_device_write(dev, FSI_MRESP0, ®, sizeof(reg));140 if (rc)141 return rc;142 143 reg = cpu_to_be32(FSI_MECTRL_EOAE | FSI_MECTRL_P8_AUTO_TERM);144 rc = fsi_device_write(dev, FSI_MECTRL, ®, sizeof(reg));145 if (rc)146 return rc;147 148 reg = cpu_to_be32(FSI_MMODE_EIP | FSI_MMODE_ECRC | FSI_MMODE_EPC149 | fsi_mmode_crs0(1) | fsi_mmode_crs1(1)150 | FSI_MMODE_P8_TO_LSB);151 rc = fsi_device_write(dev, FSI_MMODE, ®, sizeof(reg));152 if (rc)153 return rc;154 155 reg = cpu_to_be32(0xffff0000);156 rc = fsi_device_write(dev, FSI_MDLYR, ®, sizeof(reg));157 if (rc)158 return rc;159 160 reg = cpu_to_be32(~0);161 rc = fsi_device_write(dev, FSI_MSENP0, ®, sizeof(reg));162 if (rc)163 return rc;164 165 /* Leave enabled long enough for master logic to set up */166 mdelay(FSI_LINK_ENABLE_SETUP_TIME);167 168 rc = fsi_device_write(dev, FSI_MCENP0, ®, sizeof(reg));169 if (rc)170 return rc;171 172 rc = fsi_device_read(dev, FSI_MAEB, ®, sizeof(reg));173 if (rc)174 return rc;175 176 reg = cpu_to_be32(FSI_MRESP_RST_ALL_MASTER | FSI_MRESP_RST_ALL_LINK);177 rc = fsi_device_write(dev, FSI_MRESP0, ®, sizeof(reg));178 if (rc)179 return rc;180 181 rc = fsi_device_read(dev, FSI_MLEVP0, ®, sizeof(reg));182 if (rc)183 return rc;184 185 /* Reset the master bridge */186 reg = cpu_to_be32(FSI_MRESB_RST_GEN);187 rc = fsi_device_write(dev, FSI_MRESB0, ®, sizeof(reg));188 if (rc)189 return rc;190 191 reg = cpu_to_be32(FSI_MRESB_RST_ERR);192 return fsi_device_write(dev, FSI_MRESB0, ®, sizeof(reg));193}194 195static int hub_master_probe(struct device *dev)196{197 struct fsi_device *fsi_dev = to_fsi_dev(dev);198 struct fsi_master_hub *hub;199 uint32_t reg, links;200 __be32 __reg;201 int rc;202 203 rc = fsi_device_read(fsi_dev, FSI_MVER, &__reg, sizeof(__reg));204 if (rc)205 return rc;206 207 reg = be32_to_cpu(__reg);208 links = (reg >> 8) & 0xff;209 dev_dbg(dev, "hub version %08x (%d links)\n", reg, links);210 211 rc = fsi_slave_claim_range(fsi_dev->slave, FSI_HUB_LINK_OFFSET,212 FSI_HUB_LINK_SIZE * links);213 if (rc) {214 dev_err(dev, "can't claim slave address range for links");215 return rc;216 }217 218 hub = kzalloc(sizeof(*hub), GFP_KERNEL);219 if (!hub) {220 rc = -ENOMEM;221 goto err_release;222 }223 224 hub->addr = FSI_HUB_LINK_OFFSET;225 hub->size = FSI_HUB_LINK_SIZE * links;226 hub->upstream = fsi_dev;227 228 hub->master.dev.parent = dev;229 hub->master.dev.release = hub_master_release;230 hub->master.dev.of_node = of_node_get(dev_of_node(dev));231 232 hub->master.n_links = links;233 hub->master.read = hub_master_read;234 hub->master.write = hub_master_write;235 hub->master.send_break = hub_master_break;236 hub->master.link_enable = hub_master_link_enable;237 238 dev_set_drvdata(dev, hub);239 240 hub_master_init(hub);241 242 rc = fsi_master_register(&hub->master);243 if (rc)244 goto err_release;245 246 /* At this point, fsi_master_register performs the device_initialize(),247 * and holds the sole reference on master.dev. This means the device248 * will be freed (via ->release) during any subsequent call to249 * fsi_master_unregister. We add our own reference to it here, so we250 * can perform cleanup (in _remove()) without it being freed before251 * we're ready.252 */253 get_device(&hub->master.dev);254 return 0;255 256err_release:257 fsi_slave_release_range(fsi_dev->slave, FSI_HUB_LINK_OFFSET,258 FSI_HUB_LINK_SIZE * links);259 return rc;260}261 262static int hub_master_remove(struct device *dev)263{264 struct fsi_master_hub *hub = dev_get_drvdata(dev);265 266 fsi_master_unregister(&hub->master);267 fsi_slave_release_range(hub->upstream->slave, hub->addr, hub->size);268 of_node_put(hub->master.dev.of_node);269 270 /*271 * master.dev will likely be ->release()ed after this, which free()s272 * the hub273 */274 put_device(&hub->master.dev);275 276 return 0;277}278 279static const struct fsi_device_id hub_master_ids[] = {280 {281 .engine_type = FSI_ENGID_HUB_MASTER,282 .version = FSI_VERSION_ANY,283 },284 { 0 }285};286 287static struct fsi_driver hub_master_driver = {288 .id_table = hub_master_ids,289 .drv = {290 .name = "fsi-master-hub",291 .bus = &fsi_bus_type,292 .probe = hub_master_probe,293 .remove = hub_master_remove,294 }295};296 297module_fsi_driver(hub_master_driver);298MODULE_DESCRIPTION("FSI hub master driver");299MODULE_LICENSE("GPL");300