struct ocelot *ocelot = &felix->ocelot;
        phy_interface_t *port_phy_modes;
        resource_size_t switch_base;
+       struct resource res;
        int port, i, err;
 
        ocelot->num_phys_ports = num_phys_ports;
 
        for (i = 0; i < TARGET_MAX; i++) {
                struct regmap *target;
-               struct resource *res;
 
                if (!felix->info->target_io_res[i].name)
                        continue;
 
-               res = &felix->info->target_io_res[i];
-               res->flags = IORESOURCE_MEM;
-               res->start += switch_base;
-               res->end += switch_base;
+               memcpy(&res, &felix->info->target_io_res[i], sizeof(res));
+               res.flags = IORESOURCE_MEM;
+               res.start += switch_base;
+               res.end += switch_base;
 
-               target = ocelot_regmap_init(ocelot, res);
+               target = ocelot_regmap_init(ocelot, &res);
                if (IS_ERR(target)) {
                        dev_err(ocelot->dev,
                                "Failed to map device memory space\n");
        for (port = 0; port < num_phys_ports; port++) {
                struct ocelot_port *ocelot_port;
                void __iomem *port_regs;
-               struct resource *res;
 
                ocelot_port = devm_kzalloc(ocelot->dev,
                                           sizeof(struct ocelot_port),
                        return -ENOMEM;
                }
 
-               res = &felix->info->port_io_res[port];
-               res->flags = IORESOURCE_MEM;
-               res->start += switch_base;
-               res->end += switch_base;
+               memcpy(&res, &felix->info->port_io_res[port], sizeof(res));
+               res.flags = IORESOURCE_MEM;
+               res.start += switch_base;
+               res.end += switch_base;
 
-               port_regs = devm_ioremap_resource(ocelot->dev, res);
+               port_regs = devm_ioremap_resource(ocelot->dev, &res);
                if (IS_ERR(port_regs)) {
                        dev_err(ocelot->dev,
                                "failed to map registers for port %d\n", port);
 
 
 /* Platform-specific information */
 struct felix_info {
-       struct resource                 *target_io_res;
-       struct resource                 *port_io_res;
-       struct resource                 *imdio_res;
+       const struct resource           *target_io_res;
+       const struct resource           *port_io_res;
+       const struct resource           *imdio_res;
        const struct reg_field          *regfields;
        const u32 *const                *map;
        const struct ocelot_ops         *ops;
 
        [GCB]   = vsc9959_gcb_regmap,
 };
 
-/* Addresses are relative to the PCI device's base address and
- * will be fixed up at ioremap time.
- */
-static struct resource vsc9959_target_io_res[] = {
+/* Addresses are relative to the PCI device's base address */
+static const struct resource vsc9959_target_io_res[] = {
        [ANA] = {
                .start  = 0x0280000,
                .end    = 0x028ffff,
        },
 };
 
-static struct resource vsc9959_port_io_res[] = {
+static const struct resource vsc9959_port_io_res[] = {
        {
                .start  = 0x0100000,
                .end    = 0x010ffff,
 /* Port MAC 0 Internal MDIO bus through which the SerDes acting as an
  * SGMII/QSGMII MAC PCS can be found.
  */
-static struct resource vsc9959_imdio_res = {
+static const struct resource vsc9959_imdio_res = {
        .start          = 0x8030,
        .end            = 0x8040,
        .name           = "imdio",
        struct device *dev = ocelot->dev;
        resource_size_t imdio_base;
        void __iomem *imdio_regs;
-       struct resource *res;
+       struct resource res;
        struct enetc_hw *hw;
        struct mii_bus *bus;
        int port;
        imdio_base = pci_resource_start(felix->pdev,
                                        felix->info->imdio_pci_bar);
 
-       res = felix->info->imdio_res;
-       res->flags = IORESOURCE_MEM;
-       res->start += imdio_base;
-       res->end += imdio_base;
+       memcpy(&res, felix->info->imdio_res, sizeof(res));
+       res.flags = IORESOURCE_MEM;
+       res.start += imdio_base;
+       res.end += imdio_base;
 
-       imdio_regs = devm_ioremap_resource(dev, res);
+       imdio_regs = devm_ioremap_resource(dev, &res);
        if (IS_ERR(imdio_regs)) {
                dev_err(dev, "failed to map internal MDIO registers\n");
                return PTR_ERR(imdio_regs);