return 0;
 }
 
-static int rt1011_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt1011_i2c_probe(struct i2c_client *i2c)
 {
        struct rt1011_priv *rt1011;
        int ret;
                .of_match_table = of_match_ptr(rt1011_of_match),
                .acpi_match_table = ACPI_PTR(rt1011_acpi_match)
        },
-       .probe = rt1011_i2c_probe,
+       .probe_new = rt1011_i2c_probe,
        .shutdown = rt1011_i2c_shutdown,
        .id_table = rt1011_i2c_id,
 };
 
                &rt1015->pdata.power_up_delay_ms);
 }
 
-static int rt1015_i2c_probe(struct i2c_client *i2c,
-       const struct i2c_device_id *id)
+static int rt1015_i2c_probe(struct i2c_client *i2c)
 {
        struct rt1015_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt1015_priv *rt1015;
                .of_match_table = of_match_ptr(rt1015_of_match),
                .acpi_match_table = ACPI_PTR(rt1015_acpi_match),
        },
-       .probe = rt1015_i2c_probe,
+       .probe_new = rt1015_i2c_probe,
        .shutdown = rt1015_i2c_shutdown,
        .id_table = rt1015_i2c_id,
 };
 
 MODULE_DEVICE_TABLE(acpi, rt1016_acpi_match);
 #endif
 
-static int rt1016_i2c_probe(struct i2c_client *i2c,
-       const struct i2c_device_id *id)
+static int rt1016_i2c_probe(struct i2c_client *i2c)
 {
        struct rt1016_priv *rt1016;
        int ret;
                .of_match_table = of_match_ptr(rt1016_of_match),
                .acpi_match_table = ACPI_PTR(rt1016_acpi_match),
        },
-       .probe = rt1016_i2c_probe,
+       .probe_new = rt1016_i2c_probe,
        .shutdown = rt1016_i2c_shutdown,
        .id_table = rt1016_i2c_id,
 };
 
 MODULE_DEVICE_TABLE(acpi, rt1019_acpi_match);
 #endif
 
-static int rt1019_i2c_probe(struct i2c_client *i2c,
-       const struct i2c_device_id *id)
+static int rt1019_i2c_probe(struct i2c_client *i2c)
 {
        struct rt1019_priv *rt1019;
        int ret;
                .of_match_table = of_match_ptr(rt1019_of_match),
                .acpi_match_table = ACPI_PTR(rt1019_acpi_match),
        },
-       .probe = rt1019_i2c_probe,
+       .probe_new = rt1019_i2c_probe,
        .id_table = rt1019_i2c_id,
 };
 module_i2c_driver(rt1019_i2c_driver);
 
        regcache_cache_bypass(rt1305->regmap, false);
 }
 
-static int rt1305_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt1305_i2c_probe(struct i2c_client *i2c)
 {
        struct rt1305_priv *rt1305;
        int ret;
                .acpi_match_table = ACPI_PTR(rt1305_acpi_match)
 #endif
        },
-       .probe = rt1305_i2c_probe,
+       .probe_new = rt1305_i2c_probe,
        .shutdown = rt1305_i2c_shutdown,
        .id_table = rt1305_i2c_id,
 };
 
        regmap_write(rt1308->regmap, RT1308_PVDD_OFFSET_CTL, 0x10000000);
 }
 
-static int rt1308_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt1308_i2c_probe(struct i2c_client *i2c)
 {
        struct rt1308_priv *rt1308;
        int ret;
                .of_match_table = of_match_ptr(rt1308_of_match),
                .acpi_match_table = ACPI_PTR(rt1308_acpi_match),
        },
-       .probe = rt1308_i2c_probe,
+       .probe_new = rt1308_i2c_probe,
        .shutdown = rt1308_i2c_shutdown,
        .id_table = rt1308_i2c_id,
 };
 
 MODULE_DEVICE_TABLE(acpi, rt274_acpi_match);
 #endif
 
-static int rt274_i2c_probe(struct i2c_client *i2c,
-                          const struct i2c_device_id *id)
+static int rt274_i2c_probe(struct i2c_client *i2c)
 {
        struct rt274_priv *rt274;
 
                   .of_match_table = of_match_ptr(rt274_of_match),
 #endif
                   },
-       .probe = rt274_i2c_probe,
+       .probe_new = rt274_i2c_probe,
        .remove = rt274_i2c_remove,
        .id_table = rt274_i2c_id,
 };
 
        { }
 };
 
-static int rt286_i2c_probe(struct i2c_client *i2c,
-                          const struct i2c_device_id *id)
+static int rt286_i2c_probe(struct i2c_client *i2c)
 {
        struct rt286_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt286_priv *rt286;
                   .name = "rt286",
                   .acpi_match_table = ACPI_PTR(rt286_acpi_match),
                   },
-       .probe = rt286_i2c_probe,
+       .probe_new = rt286_i2c_probe,
        .remove = rt286_i2c_remove,
        .id_table = rt286_i2c_id,
 };
 
        { }
 };
 
-static int rt298_i2c_probe(struct i2c_client *i2c,
-                          const struct i2c_device_id *id)
+static int rt298_i2c_probe(struct i2c_client *i2c)
 {
        struct rt298_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt298_priv *rt298;
                   .name = "rt298",
                   .acpi_match_table = ACPI_PTR(rt298_acpi_match),
                   },
-       .probe = rt298_i2c_probe,
+       .probe_new = rt298_i2c_probe,
        .remove = rt298_i2c_remove,
        .id_table = rt298_i2c_id,
 };
 
        return 0;
 }
 
-static int rt5514_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5514_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5514_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt5514_priv *rt5514;
                .of_match_table = of_match_ptr(rt5514_of_match),
                .pm = &rt5514_i2_pm_ops,
        },
-       .probe = rt5514_i2c_probe,
+       .probe_new = rt5514_i2c_probe,
        .id_table = rt5514_i2c_id,
 };
 module_i2c_driver(rt5514_i2c_driver);
 
 MODULE_DEVICE_TABLE(of, rt5616_of_match);
 #endif
 
-static int rt5616_i2c_probe(struct i2c_client *i2c,
-                           const struct i2c_device_id *id)
+static int rt5616_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5616_priv *rt5616;
        unsigned int val;
                .name = "rt5616",
                .of_match_table = of_match_ptr(rt5616_of_match),
        },
-       .probe = rt5616_i2c_probe,
+       .probe_new = rt5616_i2c_probe,
        .remove = rt5616_i2c_remove,
        .shutdown = rt5616_i2c_shutdown,
        .id_table = rt5616_i2c_id,
 
        .use_single_write = true,
 };
 
-static int rt5631_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5631_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5631_priv *rt5631;
        int ret;
                .name = "rt5631",
                .of_match_table = of_match_ptr(rt5631_i2c_dt_ids),
        },
-       .probe = rt5631_i2c_probe,
+       .probe_new = rt5631_i2c_probe,
        .remove   = rt5631_i2c_remove,
        .id_table = rt5631_i2c_id,
 };
 
        return 0;
 }
 
-static int rt5640_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5640_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5640_priv *rt5640;
        int ret;
                .acpi_match_table = ACPI_PTR(rt5640_acpi_match),
                .of_match_table = of_match_ptr(rt5640_of_match),
        },
-       .probe = rt5640_i2c_probe,
+       .probe_new = rt5640_i2c_probe,
        .id_table = rt5640_i2c_id,
 };
 module_i2c_driver(rt5640_i2c_driver);
 
        return 0;
 }
 
-static int rt5645_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5645_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5645_platform_data *pdata = NULL;
        const struct dmi_system_id *dmi_data;
                .of_match_table = of_match_ptr(rt5645_of_match),
                .acpi_match_table = ACPI_PTR(rt5645_acpi_match),
        },
-       .probe = rt5645_i2c_probe,
+       .probe_new = rt5645_i2c_probe,
        .remove = rt5645_i2c_remove,
        .shutdown = rt5645_i2c_shutdown,
        .id_table = rt5645_i2c_id,
 
  * Note this function MUST not look at device-properties, see the comment
  * above rt5651_apply_properties().
  */
-static int rt5651_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5651_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5651_priv *rt5651;
        int ret;
                .acpi_match_table = ACPI_PTR(rt5651_acpi_match),
                .of_match_table = of_match_ptr(rt5651_of_match),
        },
-       .probe = rt5651_i2c_probe,
+       .probe_new = rt5651_i2c_probe,
        .id_table = rt5651_i2c_id,
 };
 module_i2c_driver(rt5651_i2c_driver);
 
                RT5659_IL_IRQ_MASK, RT5659_IL_IRQ_EN);
 }
 
-static int rt5659_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5659_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5659_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt5659_priv *rt5659;
                .of_match_table = of_match_ptr(rt5659_of_match),
                .acpi_match_table = ACPI_PTR(rt5659_acpi_match),
        },
-       .probe = rt5659_i2c_probe,
+       .probe_new = rt5659_i2c_probe,
        .shutdown = rt5659_i2c_shutdown,
        .id_table = rt5659_i2c_id,
 };
 
        return 0;
 }
 
-static int rt5660_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5660_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5660_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt5660_priv *rt5660;
                .acpi_match_table = ACPI_PTR(rt5660_acpi_match),
                .of_match_table = of_match_ptr(rt5660_of_match),
        },
-       .probe = rt5660_i2c_probe,
+       .probe_new = rt5660_i2c_probe,
        .id_table = rt5660_i2c_id,
 };
 module_i2c_driver(rt5660_i2c_driver);
 
        return 0;
 }
 
-static int rt5663_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5663_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5663_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt5663_priv *rt5663;
                .acpi_match_table = ACPI_PTR(rt5663_acpi_match),
                .of_match_table = of_match_ptr(rt5663_of_match),
        },
-       .probe = rt5663_i2c_probe,
+       .probe_new = rt5663_i2c_probe,
        .remove = rt5663_i2c_remove,
        .shutdown = rt5663_i2c_shutdown,
        .id_table = rt5663_i2c_id,
 
        rt5665_calibrate(rt5665);
 }
 
-static int rt5665_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5665_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5665_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt5665_priv *rt5665;
                .of_match_table = of_match_ptr(rt5665_of_match),
                .acpi_match_table = ACPI_PTR(rt5665_acpi_match),
        },
-       .probe = rt5665_i2c_probe,
+       .probe_new = rt5665_i2c_probe,
        .shutdown = rt5665_i2c_shutdown,
        .id_table = rt5665_i2c_id,
 };
 
 
 }
 
-static int rt5668_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5668_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5668_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt5668_priv *rt5668;
                .of_match_table = of_match_ptr(rt5668_of_match),
                .acpi_match_table = ACPI_PTR(rt5668_acpi_match),
        },
-       .probe = rt5668_i2c_probe,
+       .probe_new = rt5668_i2c_probe,
        .shutdown = rt5668_i2c_shutdown,
        .id_table = rt5668_i2c_id,
 };
 
 }
 EXPORT_SYMBOL_GPL(rt5670_components);
 
-static int rt5670_i2c_probe(struct i2c_client *i2c,
-                   const struct i2c_device_id *id)
+static int rt5670_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5670_priv *rt5670;
        int ret;
                .name = "rt5670",
                .acpi_match_table = ACPI_PTR(rt5670_acpi_match),
        },
-       .probe = rt5670_i2c_probe,
+       .probe_new = rt5670_i2c_probe,
        .remove   = rt5670_i2c_remove,
        .id_table = rt5670_i2c_id,
 };
 
        regulator_bulk_disable(ARRAY_SIZE(rt5682->supplies), rt5682->supplies);
 }
 
-static int rt5682_i2c_probe(struct i2c_client *i2c,
-               const struct i2c_device_id *id)
+static int rt5682_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5682_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt5682_priv *rt5682;
                .acpi_match_table = rt5682_acpi_match,
                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
-       .probe = rt5682_i2c_probe,
+       .probe_new = rt5682_i2c_probe,
        .remove = rt5682_i2c_remove,
        .shutdown = rt5682_i2c_shutdown,
        .id_table = rt5682_i2c_id,
 
                dev_err(dev, "Failed to disable supply MICVDD: %d\n", ret);
 }
 
-static int rt5682s_i2c_probe(struct i2c_client *i2c,
-               const struct i2c_device_id *id)
+static int rt5682s_i2c_probe(struct i2c_client *i2c)
 {
        struct rt5682s_platform_data *pdata = dev_get_platdata(&i2c->dev);
        struct rt5682s_priv *rt5682s;
                .acpi_match_table = rt5682s_acpi_match,
                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
-       .probe = rt5682s_i2c_probe,
+       .probe_new = rt5682s_i2c_probe,
        .remove = rt5682s_i2c_remove,
        .shutdown = rt5682s_i2c_shutdown,
        .id_table = rt5682s_i2c_id,