drivers/bus/fsl-mc/mc-io.c

   1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
   2 /*
   3  * Copyright 2013-2016 Freescale Semiconductor Inc.
   4  *
   5  */
   6
   7 #include <linux/io.h>
   8 #include <linux/fsl/mc.h>
   9
  10 #include "fsl-mc-private.h"
  11
  12 static int fsl_mc_io_set_dpmcp(struct fsl_mc_io *mc_io,
  13                                struct fsl_mc_device *dpmcp_dev)
  14 {
  15         int error;
  16
  17         if (mc_io->dpmcp_dev)
  18                 return -EINVAL;
  19
  20         if (dpmcp_dev->mc_io)
  21                 return -EINVAL;
  22
  23         error = dpmcp_open(mc_io,
  24                            0,
  25                            dpmcp_dev->obj_desc.id,
  26                            &dpmcp_dev->mc_handle);
  27         if (error < 0)
  28                 return error;
  29
  30         mc_io->dpmcp_dev = dpmcp_dev;
  31         dpmcp_dev->mc_io = mc_io;
  32         return 0;
  33 }
  34
  35 static void fsl_mc_io_unset_dpmcp(struct fsl_mc_io *mc_io)
  36 {
  37         int error;
  38         struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev;
  39
  40         error = dpmcp_close(mc_io,
  41                             0,
  42                             dpmcp_dev->mc_handle);
  43         if (error < 0) {
  44                 dev_err(&dpmcp_dev->dev, "dpmcp_close() failed: %d\n",
  45                         error);
  46         }
  47
  48         mc_io->dpmcp_dev = NULL;
  49         dpmcp_dev->mc_io = NULL;
  50 }
  51
  52 /**
  53  * Creates an MC I/O object
  54  *
  55  * @dev: device to be associated with the MC I/O object
  56  * @mc_portal_phys_addr: physical address of the MC portal to use
  57  * @mc_portal_size: size in bytes of the MC portal
  58  * @dpmcp-dev: Pointer to the DPMCP object associated with this MC I/O
  59  * object or NULL if none.
  60  * @flags: flags for the new MC I/O object
  61  * @new_mc_io: Area to return pointer to newly created MC I/O object
  62  *
  63  * Returns '0' on Success; Error code otherwise.
  64  */
  65 int __must_check fsl_create_mc_io(struct device *dev,
  66                                   phys_addr_t mc_portal_phys_addr,
  67                                   u32 mc_portal_size,
  68                                   struct fsl_mc_device *dpmcp_dev,
  69                                   u32 flags, struct fsl_mc_io **new_mc_io)
  70 {
  71         int error;
  72         struct fsl_mc_io *mc_io;
  73         void __iomem *mc_portal_virt_addr;
  74         struct resource *res;
  75
  76         mc_io = devm_kzalloc(dev, sizeof(*mc_io), GFP_KERNEL);
  77         if (!mc_io)
  78                 return -ENOMEM;
  79
  80         mc_io->dev = dev;
  81         mc_io->flags = flags;
  82         mc_io->portal_phys_addr = mc_portal_phys_addr;
  83         mc_io->portal_size = mc_portal_size;
  84         if (flags & FSL_MC_IO_ATOMIC_CONTEXT_PORTAL)
  85                 spin_lock_init(&mc_io->spinlock);
  86         else
  87                 mutex_init(&mc_io->mutex);
  88
  89         res = devm_request_mem_region(dev,
  90                                       mc_portal_phys_addr,
  91                                       mc_portal_size,
  92                                       "mc_portal");
  93         if (!res) {
  94                 dev_err(dev,
  95                         "devm_request_mem_region failed for MC portal %pa\n",
  96                         &mc_portal_phys_addr);
  97                 return -EBUSY;
  98         }
  99
 100         mc_portal_virt_addr = devm_ioremap_nocache(dev,
 101                                                    mc_portal_phys_addr,
 102                                                    mc_portal_size);
 103         if (!mc_portal_virt_addr) {
 104                 dev_err(dev,
 105                         "devm_ioremap_nocache failed for MC portal %pa\n",
 106                         &mc_portal_phys_addr);
 107                 return -ENXIO;
 108         }
 109
 110         mc_io->portal_virt_addr = mc_portal_virt_addr;
 111         if (dpmcp_dev) {
 112                 error = fsl_mc_io_set_dpmcp(mc_io, dpmcp_dev);
 113                 if (error < 0)
 114                         goto error_destroy_mc_io;
 115         }
 116
 117         *new_mc_io = mc_io;
 118         return 0;
 119
 120 error_destroy_mc_io:
 121         fsl_destroy_mc_io(mc_io);
 122         return error;
 123 }
 124
 125 /**
 126  * Destroys an MC I/O object
 127  *
 128  * @mc_io: MC I/O object to destroy
 129  */
 130 void fsl_destroy_mc_io(struct fsl_mc_io *mc_io)
 131 {
 132         struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev;
 133
 134         if (dpmcp_dev)
 135                 fsl_mc_io_unset_dpmcp(mc_io);
 136
 137         devm_iounmap(mc_io->dev, mc_io->portal_virt_addr);
 138         devm_release_mem_region(mc_io->dev,
 139                                 mc_io->portal_phys_addr,
 140                                 mc_io->portal_size);
 141
 142         mc_io->portal_virt_addr = NULL;
 143         devm_kfree(mc_io->dev, mc_io);
 144 }
 145
 146 /**
 147  * fsl_mc_portal_allocate - Allocates an MC portal
 148  *
 149  * @mc_dev: MC device for which the MC portal is to be allocated
 150  * @mc_io_flags: Flags for the fsl_mc_io object that wraps the allocated
 151  * MC portal.
 152  * @new_mc_io: Pointer to area where the pointer to the fsl_mc_io object
 153  * that wraps the allocated MC portal is to be returned
 154  *
 155  * This function allocates an MC portal from the device's parent DPRC,
 156  * from the corresponding MC bus' pool of MC portals and wraps
 157  * it in a new fsl_mc_io object. If 'mc_dev' is a DPRC itself, the
 158  * portal is allocated from its own MC bus.
 159  */
 160 int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev,
 161                                         u16 mc_io_flags,
 162                                         struct fsl_mc_io **new_mc_io)
 163 {
 164         struct fsl_mc_device *mc_bus_dev;
 165         struct fsl_mc_bus *mc_bus;
 166         phys_addr_t mc_portal_phys_addr;
 167         size_t mc_portal_size;
 168         struct fsl_mc_device *dpmcp_dev;
 169         int error = -EINVAL;
 170         struct fsl_mc_resource *resource = NULL;
 171         struct fsl_mc_io *mc_io = NULL;
 172
 173         if (mc_dev->flags & FSL_MC_IS_DPRC) {
 174                 mc_bus_dev = mc_dev;
 175         } else {
 176                 if (!dev_is_fsl_mc(mc_dev->dev.parent))
 177                         return error;
 178
 179                 mc_bus_dev = to_fsl_mc_device(mc_dev->dev.parent);
 180         }
 181
 182         mc_bus = to_fsl_mc_bus(mc_bus_dev);
 183         *new_mc_io = NULL;
 184         error = fsl_mc_resource_allocate(mc_bus, FSL_MC_POOL_DPMCP, &resource);
 185         if (error < 0)
 186                 return error;
 187
 188         error = -EINVAL;
 189         dpmcp_dev = resource->data;
 190
 191         if (dpmcp_dev->obj_desc.ver_major < DPMCP_MIN_VER_MAJOR ||
 192             (dpmcp_dev->obj_desc.ver_major == DPMCP_MIN_VER_MAJOR &&
 193              dpmcp_dev->obj_desc.ver_minor < DPMCP_MIN_VER_MINOR)) {
 194                 dev_err(&dpmcp_dev->dev,
 195                         "ERROR: Version %d.%d of DPMCP not supported.\n",
 196                         dpmcp_dev->obj_desc.ver_major,
 197                         dpmcp_dev->obj_desc.ver_minor);
 198                 error = -ENOTSUPP;
 199                 goto error_cleanup_resource;
 200         }
 201
 202         mc_portal_phys_addr = dpmcp_dev->regions[0].start;
 203         mc_portal_size = resource_size(dpmcp_dev->regions);
 204
 205         error = fsl_create_mc_io(&mc_bus_dev->dev,
 206                                  mc_portal_phys_addr,
 207                                  mc_portal_size, dpmcp_dev,
 208                                  mc_io_flags, &mc_io);
 209         if (error < 0)
 210                 goto error_cleanup_resource;
 211
 212         *new_mc_io = mc_io;
 213         return 0;
 214
 215 error_cleanup_resource:
 216         fsl_mc_resource_free(resource);
 217         return error;
 218 }
 219 EXPORT_SYMBOL_GPL(fsl_mc_portal_allocate);
 220
 221 /**
 222  * fsl_mc_portal_free - Returns an MC portal to the pool of free MC portals
 223  * of a given MC bus
 224  *
 225  * @mc_io: Pointer to the fsl_mc_io object that wraps the MC portal to free
 226  */
 227 void fsl_mc_portal_free(struct fsl_mc_io *mc_io)
 228 {
 229         struct fsl_mc_device *dpmcp_dev;
 230         struct fsl_mc_resource *resource;
 231
 232         /*
 233          * Every mc_io obtained by calling fsl_mc_portal_allocate() is supposed
 234          * to have a DPMCP object associated with.
 235          */
 236         dpmcp_dev = mc_io->dpmcp_dev;
 237
 238         resource = dpmcp_dev->resource;
 239         if (!resource || resource->type != FSL_MC_POOL_DPMCP)
 240                 return;
 241
 242         if (resource->data != dpmcp_dev)
 243                 return;
 244
 245         fsl_destroy_mc_io(mc_io);
 246         fsl_mc_resource_free(resource);
 247 }
 248 EXPORT_SYMBOL_GPL(fsl_mc_portal_free);
 249
 250 /**
 251  * fsl_mc_portal_reset - Resets the dpmcp object for a given fsl_mc_io object
 252  *
 253  * @mc_io: Pointer to the fsl_mc_io object that wraps the MC portal to free
 254  */
 255 int fsl_mc_portal_reset(struct fsl_mc_io *mc_io)
 256 {
 257         int error;
 258         struct fsl_mc_device *dpmcp_dev = mc_io->dpmcp_dev;
 259
 260         error = dpmcp_reset(mc_io, 0, dpmcp_dev->mc_handle);
 261         if (error < 0) {
 262                 dev_err(&dpmcp_dev->dev, "dpmcp_reset() failed: %d\n", error);
 263                 return error;
 264         }
 265
 266         return 0;
 267 }
 268 EXPORT_SYMBOL_GPL(fsl_mc_portal_reset);