static int mcp23s08_probe_one(struct mcp23s08 *mcp, struct device *dev,
                              void *data, unsigned addr, unsigned type,
-                             struct mcp23s08_platform_data *pdata, int cs)
+                             unsigned int base, int cs)
 {
        int status, ret;
        bool mirror = false;
        if (IS_ERR(mcp->regmap))
                return PTR_ERR(mcp->regmap);
 
-       mcp->chip.base = pdata->base;
+       mcp->chip.base = base;
        mcp->chip.can_sleep = true;
        mcp->chip.parent = dev;
        mcp->chip.owner = THIS_MODULE;
        if (ret < 0)
                goto fail;
 
-       mcp->irq_controller = pdata->irq_controller;
+       mcp->irq_controller =
+               device_property_read_bool(dev, "interrupt-controller");
        if (mcp->irq && mcp->irq_controller) {
                mcp->irq_active_high =
-                       of_property_read_bool(mcp->chip.parent->of_node,
+                       device_property_read_bool(dev,
                                              "microchip,irq-active-high");
 
-               mirror = pdata->mirror;
+               mirror = device_property_read_bool(dev, "microchip,irq-mirror");
        }
 
        if ((status & IOCON_SEQOP) || !(status & IOCON_HAEN) || mirror ||
        if (!pdata) {
                pdata = &local_pdata;
                pdata->base = -1;
-
-               pdata->irq_controller = device_property_read_bool(
-                       &client->dev, "interrupt-controller");
-               pdata->mirror = device_property_read_bool(
-                       &client->dev, "microchip,irq-mirror");
        }
 
        mcp = devm_kzalloc(&client->dev, sizeof(*mcp), GFP_KERNEL);
 
        mcp->irq = client->irq;
        status = mcp23s08_probe_one(mcp, &client->dev, client, client->addr,
-                                   id->driver_data, pdata, 0);
+                                   id->driver_data, pdata->base, 0);
        if (status)
                return status;
 
                pdata = &local_pdata;
                pdata->base = -1;
 
-               pdata->irq_controller = device_property_read_bool(&spi->dev,
-                       "interrupt-controller");
-               pdata->mirror = device_property_read_bool(&spi->dev,
-                       "microchip,irq-mirror");
-
                status = device_property_read_u32(&spi->dev,
                        "microchip,spi-present-mask", &spi_present_mask);
                if (status) {
                data->mcp[addr] = &data->chip[chips];
                data->mcp[addr]->irq = spi->irq;
                status = mcp23s08_probe_one(data->mcp[addr], &spi->dev, spi,
-                                           0x40 | (addr << 1), type, pdata,
-                                           addr);
+                                           0x40 | (addr << 1), type,
+                                           pdata->base, addr);
                if (status < 0)
                        return status;
 
 
         * base to base+15 (or base+31 for s17 variant).
         */
        unsigned        base;
-       /* Marks the device as a interrupt controller.
-        * NOTE: The interrupt functionality is only supported for i2c
-        * versions of the chips. The spi chips can also do the interrupts,
-        * but this is not supported by the linux driver yet.
-        */
-       bool            irq_controller;
-
-       /* Sets the mirror flag in the IOCON register. Devices
-        * with two interrupt outputs (these are the devices ending with 17 and
-        * those that have 16 IOs) have two IO banks: IO 0-7 form bank 1 and
-        * IO 8-15 are bank 2. These chips have two different interrupt outputs:
-        * One for bank 1 and another for bank 2. If irq-mirror is set, both
-        * interrupts are generated regardless of the bank that an input change
-        * occurred on. If it is not set, the interrupt are only generated for
-        * the bank they belong to.
-        * On devices with only one interrupt output this property is useless.
-        */
-       bool            mirror;
 };