drivers/fsi/fsi-master-hub.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * FSI hub master driver
   4  *
   5  * Copyright (C) IBM Corporation 2016
   6  */
   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            0x1c
  17
  18 #define FSI_LINK_ENABLE_SETUP_TIME      10      /* in mS */
  19
  20 /*
  21  * FSI hub master support
  22  *
  23  * A hub master increases the number of potential target devices that the
  24  * 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 multiple
  26  * links of its own.
  27  *
  28  * The hub is controlled by a set of control registers exposed as a regular fsi
  29  * device (the hub->upstream device), and provides access to the downstream FSI
  30  * bus as through an address range on the slave itself (->addr and ->size).
  31  *
  32  * [This differs from "cascaded" masters, which expose the entire downstream
  33  * bus entirely through the fsi device address range, and so have a smaller
  34  * accessible address space.]
  35  */
  36 struct 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
  45 static 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
  57 static 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
  69 static 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
  80 static 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                                         &reg, 4);
  96
  97         rc = fsi_device_write(hub->upstream, FSI_MSENP0 + (4 * idx), &reg, 4);
  98         if (rc)
  99                 return rc;
 100
 101         mdelay(FSI_LINK_ENABLE_SETUP_TIME);
 102
 103         return 0;
 104 }
 105
 106 static void hub_master_release(struct device *dev)
 107 {
 108         struct fsi_master_hub *hub = to_fsi_master_hub(dev_to_fsi_master(dev));
 109
 110         kfree(hub);
 111 }
 112
 113 /* mmode encoders */
 114 static inline u32 fsi_mmode_crs0(u32 x)
 115 {
 116         return (x & FSI_MMODE_CRS0MASK) << FSI_MMODE_CRS0SHFT;
 117 }
 118
 119 static inline u32 fsi_mmode_crs1(u32 x)
 120 {
 121         return (x & FSI_MMODE_CRS1MASK) << FSI_MMODE_CRS1SHFT;
 122 }
 123
 124 static 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_LINK
 131                         | FSI_MRESP_RST_MCR | FSI_MRESP_RST_PYE);
 132         rc = fsi_device_write(dev, FSI_MRESP0, &reg, 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_LINK
 138                         | FSI_MRESP_RST_MCR | FSI_MRESP_RST_PYE);
 139         rc = fsi_device_write(dev, FSI_MRESP0, &reg, 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, &reg, sizeof(reg));
 145         if (rc)
 146                 return rc;
 147
 148         reg = cpu_to_be32(FSI_MMODE_EIP | FSI_MMODE_ECRC | FSI_MMODE_EPC
 149                         | fsi_mmode_crs0(1) | fsi_mmode_crs1(1)
 150                         | FSI_MMODE_P8_TO_LSB);
 151         rc = fsi_device_write(dev, FSI_MMODE, &reg, sizeof(reg));
 152         if (rc)
 153                 return rc;
 154
 155         reg = cpu_to_be32(0xffff0000);
 156         rc = fsi_device_write(dev, FSI_MDLYR, &reg, sizeof(reg));
 157         if (rc)
 158                 return rc;
 159
 160         reg = cpu_to_be32(~0);
 161         rc = fsi_device_write(dev, FSI_MSENP0, &reg, 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, &reg, sizeof(reg));
 169         if (rc)
 170                 return rc;
 171
 172         rc = fsi_device_read(dev, FSI_MAEB, &reg, 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, &reg, sizeof(reg));
 178         if (rc)
 179                 return rc;
 180
 181         rc = fsi_device_read(dev, FSI_MLEVP0, &reg, 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, &reg, 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, &reg, sizeof(reg));
 193 }
 194
 195 static 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 device
 248          * will be freed (via ->release) during any subsequent call to
 249          * fsi_master_unregister.  We add our own reference to it here, so we
 250          * can perform cleanup (in _remove()) without it being freed before
 251          * we're ready.
 252          */
 253         get_device(&hub->master.dev);
 254         return 0;
 255
 256 err_release:
 257         fsi_slave_release_range(fsi_dev->slave, FSI_HUB_LINK_OFFSET,
 258                         FSI_HUB_LINK_SIZE * links);
 259         return rc;
 260 }
 261
 262 static 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()s
 272          * the hub
 273          */
 274         put_device(&hub->master.dev);
 275
 276         return 0;
 277 }
 278
 279 static 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
 287 static 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
 297 module_fsi_driver(hub_master_driver);
 298 MODULE_LICENSE("GPL");