.driver = {
                .name = "as5011",
        },
-       .probe_new      = as5011_probe,
+       .probe          = as5011_probe,
        .remove         = as5011_remove,
        .id_table       = as5011_id,
 };
 
                .of_match_table = of_match_ptr(of_qwiic_match),
        },
        .id_table       = qwiic_id_table,
-       .probe_new      = qwiic_probe,
+       .probe          = qwiic_probe,
 };
 module_i2c_driver(qwiic_driver);
 
 
                .of_match_table = adp5588_of_match,
                .pm   = pm_sleep_ptr(&adp5588_dev_pm_ops),
        },
-       .probe_new = adp5588_probe,
+       .probe    = adp5588_probe,
        .remove   = adp5588_remove,
        .id_table = adp5588_id,
 };
 
                .name = KBUILD_MODNAME,
                .pm = pm_sleep_ptr(&adp5589_dev_pm_ops),
        },
-       .probe_new = adp5589_probe,
+       .probe = adp5589_probe,
        .id_table = adp5589_id,
 };
 
 
                .of_match_table = cap11xx_dt_ids,
        },
        .id_table       = cap11xx_i2c_ids,
-       .probe_new      = cap11xx_i2c_probe,
+       .probe          = cap11xx_i2c_probe,
 };
 
 module_i2c_driver(cap11xx_i2c_driver);
 
                .of_match_table = of_match_ptr(cypress_sf_of_match),
        },
        .id_table = cypress_sf_id_table,
-       .probe_new = cypress_sf_probe,
+       .probe = cypress_sf_probe,
 };
 module_i2c_driver(cypress_sf_driver);
 
 
                .name   = "dlink-dir685-touchkeys",
                .of_match_table = of_match_ptr(dir685_tk_of_match),
        },
-       .probe_new      = dir685_tk_probe,
+       .probe          = dir685_tk_probe,
        .id_table       = dir685_tk_id,
 };
 module_i2c_driver(dir685_tk_i2c_driver);
 
                .name   = "lm8323",
                .pm     = pm_sleep_ptr(&lm8323_pm_ops),
        },
-       .probe_new      = lm8323_probe,
+       .probe          = lm8323_probe,
        .remove         = lm8323_remove,
        .id_table       = lm8323_id,
 };
 
        .driver = {
                .name           = "lm8333",
        },
-       .probe_new      = lm8333_probe,
+       .probe          = lm8333_probe,
        .remove         = lm8333_remove,
        .id_table       = lm8333_id,
 };
 
                .name = "max7359",
                .pm   = pm_sleep_ptr(&max7359_pm),
        },
-       .probe_new      = max7359_probe,
+       .probe          = max7359_probe,
        .id_table       = max7359_ids,
 };
 
 
                .name   = "mcs_touchkey",
                .pm     = pm_sleep_ptr(&mcs_touchkey_pm_ops),
        },
-       .probe_new      = mcs_touchkey_probe,
+       .probe          = mcs_touchkey_probe,
        .remove         = mcs_touchkey_remove,
        .shutdown       = mcs_touchkey_shutdown,
        .id_table       = mcs_touchkey_id,
 
                .of_match_table = of_match_ptr(mpr121_touchkey_dt_match_table),
        },
        .id_table       = mpr121_id,
-       .probe_new      = mpr_touchkey_probe,
+       .probe          = mpr_touchkey_probe,
 };
 
 module_i2c_driver(mpr_touchkey_driver);
 
 MODULE_DEVICE_TABLE(of, ppkb_of_match);
 
 static struct i2c_driver ppkb_driver = {
-       .probe_new      = ppkb_probe,
+       .probe          = ppkb_probe,
        .driver         = {
                .name           = DRV_NAME,
                .of_match_table = ppkb_of_match,
 
                .of_match_table = of_match_ptr(qt1050_of_match),
                .pm = pm_sleep_ptr(&qt1050_pm_ops),
        },
-       .probe_new = qt1050_probe,
+       .probe = qt1050_probe,
 };
 
 module_i2c_driver(qt1050_driver);
 
                .pm     = pm_sleep_ptr(&qt1070_pm_ops),
        },
        .id_table       = qt1070_id,
-       .probe_new      = qt1070_probe,
+       .probe          = qt1070_probe,
        .remove         = qt1070_remove,
 };
 
 
        },
 
        .id_table       = qt2160_idtable,
-       .probe_new      = qt2160_probe,
+       .probe          = qt2160_probe,
        .remove         = qt2160_remove,
 };
 
 
                .name   = "tca6416-keypad",
                .pm     = pm_sleep_ptr(&tca6416_keypad_dev_pm_ops),
        },
-       .probe_new      = tca6416_keypad_probe,
+       .probe          = tca6416_keypad_probe,
        .remove         = tca6416_keypad_remove,
        .id_table       = tca6416_id,
 };
 
                .name   = "tca8418_keypad",
                .of_match_table = tca8418_dt_ids,
        },
-       .probe_new      = tca8418_keypad_probe,
+       .probe          = tca8418_keypad_probe,
        .id_table       = tca8418_id,
 };
 
 
                .pm = pm_sleep_ptr(&tm2_touchkey_pm_ops),
                .of_match_table = tm2_touchkey_of_match,
        },
-       .probe_new = tm2_touchkey_probe,
+       .probe = tm2_touchkey_probe,
        .id_table = tm2_touchkey_id_table,
 };
 module_i2c_driver(tm2_touchkey_driver);
 
                .name = "ad714x_captouch",
                .pm   = pm_sleep_ptr(&ad714x_pm),
        },
-       .probe_new = ad714x_i2c_probe,
+       .probe = ad714x_i2c_probe,
        .id_table = ad714x_id,
 };
 
 
                .pm = pm_sleep_ptr(&adxl34x_pm),
                .of_match_table = adxl34x_of_id,
        },
-       .probe_new = adxl34x_i2c_probe,
+       .probe    = adxl34x_i2c_probe,
        .remove   = adxl34x_i2c_remove,
        .id_table = adxl34x_id,
 };
 
        .driver = {
                .name = APANEL,
        },
-       .probe_new      = apanel_probe,
+       .probe          = apanel_probe,
        .shutdown       = apanel_shutdown,
        .id_table       = apanel_id,
 };
 
 MODULE_DEVICE_TABLE(i2c, atmel_captouch_id);
 
 static struct i2c_driver atmel_captouch_driver = {
-       .probe_new      = atmel_captouch_probe,
+       .probe          = atmel_captouch_probe,
        .id_table       = atmel_captouch_id,
        .driver         = {
                .name   = "atmel_captouch",
 
        },
        .class          = I2C_CLASS_HWMON,
        .id_table       = bma150_id,
-       .probe_new      = bma150_probe,
+       .probe          = bma150_probe,
        .remove         = bma150_remove,
 };
 
 
 MODULE_DEVICE_TABLE(i2c, cma3000_i2c_id);
 
 static struct i2c_driver cma3000_i2c_driver = {
-       .probe_new      = cma3000_i2c_probe,
+       .probe          = cma3000_i2c_probe,
        .remove         = cma3000_i2c_remove,
        .id_table       = cma3000_i2c_id,
        .driver = {
 
                .of_match_table = of_match_ptr(da7280_of_match),
                .pm = pm_sleep_ptr(&da7280_pm_ops),
        },
-       .probe_new = da7280_probe,
+       .probe = da7280_probe,
        .id_table = da7280_i2c_id,
 };
 module_i2c_driver(da7280_driver);
 
 MODULE_DEVICE_TABLE(of, drv260x_of_match);
 
 static struct i2c_driver drv260x_driver = {
-       .probe_new      = drv260x_probe,
+       .probe          = drv260x_probe,
        .driver         = {
                .name   = "drv260x-haptics",
                .of_match_table = drv260x_of_match,
 
 #endif
 
 static struct i2c_driver drv2665_driver = {
-       .probe_new      = drv2665_probe,
+       .probe          = drv2665_probe,
        .driver         = {
                .name   = "drv2665-haptics",
                .of_match_table = of_match_ptr(drv2665_of_match),
 
 #endif
 
 static struct i2c_driver drv2667_driver = {
-       .probe_new      = drv2667_probe,
+       .probe          = drv2667_probe,
        .driver         = {
                .name   = "drv2667-haptics",
                .of_match_table = of_match_ptr(drv2667_of_match),
 
                .name = DEVICE_NAME,
                .of_match_table = ibm_panel_match,
        },
-       .probe_new = ibm_panel_probe,
+       .probe = ibm_panel_probe,
        .remove = ibm_panel_remove,
 };
 module_i2c_driver(ibm_panel_driver);
 
                .of_match_table = iqs269_of_match,
                .pm = pm_sleep_ptr(&iqs269_pm),
        },
-       .probe_new = iqs269_probe,
+       .probe = iqs269_probe,
 };
 module_i2c_driver(iqs269_i2c_driver);
 
 
                .of_match_table = iqs626_of_match,
                .pm = pm_sleep_ptr(&iqs626_pm),
        },
-       .probe_new = iqs626_probe,
+       .probe = iqs626_probe,
 };
 module_i2c_driver(iqs626_i2c_driver);
 
 
                .name = "iqs7222",
                .of_match_table = iqs7222_of_match,
        },
-       .probe_new = iqs7222_probe,
+       .probe = iqs7222_probe,
 };
 module_i2c_driver(iqs7222_i2c_driver);
 
 
                .name   = NAME,
                .pm     = pm_sleep_ptr(&kxtj9_pm_ops),
        },
-       .probe_new      = kxtj9_probe,
+       .probe          = kxtj9_probe,
        .id_table       = kxtj9_id,
 };
 
 
                .name   = MMA8450_DRV_NAME,
                .of_match_table = mma8450_dt_ids,
        },
-       .probe_new      = mma8450_probe,
+       .probe          = mma8450_probe,
        .id_table       = mma8450_id,
 };
 
 
                .name  = DRV_NAME,
                .pm = pm_sleep_ptr(&pcf8574_kp_pm_ops),
        },
-       .probe_new = pcf8574_kp_probe,
+       .probe    = pcf8574_kp_probe,
        .remove   = pcf8574_kp_remove,
        .id_table = pcf8574_kp_id,
 };
 
                .of_match_table = of_match_ptr(cyapa_of_match),
        },
 
-       .probe_new = cyapa_probe,
+       .probe = cyapa_probe,
        .id_table = cyapa_id_table,
 };
 
 
                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .dev_groups = elan_sysfs_groups,
        },
-       .probe_new      = elan_probe,
+       .probe          = elan_probe,
        .id_table       = elan_id,
 };
 
 
                .pm     = pm_sleep_ptr(&synaptics_i2c_pm),
        },
 
-       .probe_new      = synaptics_i2c_probe,
+       .probe          = synaptics_i2c_probe,
        .remove         = synaptics_i2c_remove,
 
        .id_table       = synaptics_i2c_id_table,
 
                .of_match_table = of_match_ptr(rmi_i2c_of_match),
        },
        .id_table       = rmi_id,
-       .probe_new      = rmi_i2c_probe,
+       .probe          = rmi_i2c_probe,
 };
 
 module_i2c_driver(rmi_i2c_driver);
 
                .pm     = pm_ptr(&rmi_smb_pm),
        },
        .id_table       = rmi_id,
-       .probe_new      = rmi_smb_probe,
+       .probe          = rmi_smb_probe,
        .remove         = rmi_smb_remove,
 };
 
 
                .pm     = &ad7879_pm_ops,
                .of_match_table = of_match_ptr(ad7879_i2c_dt_ids),
        },
-       .probe_new      = ad7879_i2c_probe,
+       .probe          = ad7879_i2c_probe,
        .id_table       = ad7879_id,
 };
 
 
                .of_match_table = ar1021_i2c_of_match,
        },
 
-       .probe_new      = ar1021_i2c_probe,
+       .probe          = ar1021_i2c_probe,
        .id_table       = ar1021_i2c_id,
 };
 module_i2c_driver(ar1021_i2c_driver);
 
                .acpi_match_table = ACPI_PTR(mxt_acpi_id),
                .pm     = pm_sleep_ptr(&mxt_pm_ops),
        },
-       .probe_new      = mxt_probe,
+       .probe          = mxt_probe,
        .remove         = mxt_remove,
        .id_table       = mxt_id,
 };
 
                .pm     = pm_sleep_ptr(&auo_pixcir_pm_ops),
                .of_match_table = of_match_ptr(auo_pixcir_ts_dt_idtable),
        },
-       .probe_new      = auo_pixcir_probe,
+       .probe          = auo_pixcir_probe,
        .id_table       = auo_pixcir_idtable,
 };
 
 
                .name   =       DRIVER_TP,
                .pm     =       pm_sleep_ptr(&bu21013_dev_pm_ops),
        },
-       .probe_new      =       bu21013_probe,
+       .probe          =       bu21013_probe,
        .remove         =       bu21013_remove,
        .id_table       =       bu21013_id,
 };
 
                .pm             = pm_sleep_ptr(&bu21029_pm_ops),
        },
        .id_table       = bu21029_ids,
-       .probe_new      = bu21029_probe,
+       .probe          = bu21029_probe,
 };
 module_i2c_driver(bu21029_driver);
 
 
                .pm     = pm_sleep_ptr(&icn8318_pm_ops),
                .of_match_table = icn8318_of_match,
        },
-       .probe_new = icn8318_probe,
+       .probe = icn8318_probe,
        .id_table = icn8318_i2c_id,
 };
 
 
                .pm     = pm_sleep_ptr(&icn8505_pm_ops),
                .acpi_match_table = icn8505_acpi_match,
        },
-       .probe_new = icn8505_probe,
+       .probe = icn8505_probe,
 };
 
 module_i2c_driver(icn8505_driver);
 
                .of_match_table = cy8ctma140_of_match,
        },
        .id_table       = cy8ctma140_idtable,
-       .probe_new      = cy8ctma140_probe,
+       .probe          = cy8ctma140_probe,
 };
 module_i2c_driver(cy8ctma140_driver);
 
 
                .pm     = pm_sleep_ptr(&cy8ctmg110_pm),
        },
        .id_table       = cy8ctmg110_idtable,
-       .probe_new      = cy8ctmg110_probe,
+       .probe          = cy8ctmg110_probe,
 };
 
 module_i2c_driver(cy8ctmg110_driver);
 
                .name   = CYTTSP4_I2C_NAME,
                .pm     = pm_ptr(&cyttsp4_pm_ops),
        },
-       .probe_new      = cyttsp4_i2c_probe,
+       .probe          = cyttsp4_i2c_probe,
        .remove         = cyttsp4_i2c_remove,
        .id_table       = cyttsp4_i2c_id,
 };
 
                .of_match_table = cyttsp5_of_match,
                .pm = &cyttsp5_pm,
        },
-       .probe_new = cyttsp5_i2c_probe,
+       .probe = cyttsp5_i2c_probe,
        .id_table = cyttsp5_i2c_id,
 };
 module_i2c_driver(cyttsp5_i2c_driver);
 
                .pm     = pm_sleep_ptr(&cyttsp_pm_ops),
                .of_match_table = cyttsp_of_i2c_match,
        },
-       .probe_new      = cyttsp_i2c_probe,
+       .probe          = cyttsp_i2c_probe,
        .id_table       = cyttsp_i2c_id,
 };
 
 
                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .id_table = edt_ft5x06_ts_id,
-       .probe_new = edt_ft5x06_ts_probe,
+       .probe    = edt_ft5x06_ts_probe,
        .remove   = edt_ft5x06_ts_remove,
 };
 
 
                .pm = pm_sleep_ptr(&eeti_ts_pm),
                .of_match_table = of_match_ptr(of_eeti_ts_match),
        },
-       .probe_new = eeti_ts_probe,
+       .probe = eeti_ts_probe,
        .id_table = eeti_ts_id,
 };
 
 
                .of_match_table = egalax_ts_dt_ids,
        },
        .id_table       = egalax_ts_id,
-       .probe_new      = egalax_ts_probe,
+       .probe          = egalax_ts_probe,
 };
 
 module_i2c_driver(egalax_ts_driver);
 
                .pm     = pm_sleep_ptr(&ektf2127_pm_ops),
                .of_match_table = of_match_ptr(ektf2127_of_match),
        },
-       .probe_new = ektf2127_probe,
+       .probe = ektf2127_probe,
        .id_table = ektf2127_i2c_id,
 };
 module_i2c_driver(ektf2127_driver);
 
 #endif
 
 static struct i2c_driver elants_i2c_driver = {
-       .probe_new = elants_i2c_probe,
+       .probe = elants_i2c_probe,
        .id_table = elants_i2c_id,
        .driver = {
                .name = DEVICE_NAME,
 
                .of_match_table = of_match_ptr(exc3000_of_match),
        },
        .id_table       = exc3000_id,
-       .probe_new      = exc3000_probe,
+       .probe          = exc3000_probe,
 };
 
 module_i2c_driver(exc3000_driver);
 
 #endif
 
 static struct i2c_driver goodix_ts_driver = {
-       .probe_new = goodix_ts_probe,
+       .probe = goodix_ts_probe,
        .remove = goodix_ts_remove,
        .id_table = goodix_ts_id,
        .driver = {
 
                .pm                     = pm_sleep_ptr(&hideep_pm_ops),
        },
        .id_table       = hideep_i2c_id,
-       .probe_new      = hideep_probe,
+       .probe          = hideep_probe,
 };
 
 module_i2c_driver(hideep_driver);
 
 #endif
 
 static struct i2c_driver himax_ts_driver = {
-       .probe_new = himax_probe,
+       .probe = himax_probe,
        .id_table = himax_ts_id,
        .driver = {
                .name = "Himax-hx83112b-TS",
 
                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .id_table = hycon_hy46xx_id,
-       .probe_new = hycon_hy46xx_probe,
+       .probe = hycon_hy46xx_probe,
 };
 
 module_i2c_driver(hycon_hy46xx_driver);
 
                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .id_table = hyn_tpd_id,
-       .probe_new = hyn_probe,
+       .probe = hyn_probe,
 };
 
 module_i2c_driver(hynitron_i2c_driver);
 
                .of_match_table = ili210x_dt_ids,
        },
        .id_table = ili210x_i2c_id,
-       .probe_new = ili210x_i2c_probe,
+       .probe = ili210x_i2c_probe,
 };
 
 module_i2c_driver(ili210x_ts_driver);
 
                .of_match_table = of_match_ptr(ilitek_ts_i2c_match),
                .acpi_match_table = ACPI_PTR(ilitekts_acpi_id),
        },
-       .probe_new = ilitek_ts_i2c_probe,
+       .probe = ilitek_ts_i2c_probe,
        .id_table = ilitek_ts_i2c_id,
 };
 module_i2c_driver(ilitek_ts_i2c_driver);
 
                .pm = pm_sleep_ptr(&imagis_pm_ops),
                .of_match_table = of_match_ptr(imagis_of_match),
        },
-       .probe_new = imagis_probe,
+       .probe = imagis_probe,
 };
 
 module_i2c_driver(imagis_ts_driver);
 
                .pm             = pm_sleep_ptr(&iqs5xx_pm),
        },
        .id_table       = iqs5xx_id,
-       .probe_new      = iqs5xx_probe,
+       .probe          = iqs5xx_probe,
 };
 module_i2c_driver(iqs5xx_i2c_driver);
 
 
                .of_match_table = max11801_ts_dt_ids,
        },
        .id_table       = max11801_ts_id,
-       .probe_new      = max11801_ts_probe,
+       .probe          = max11801_ts_probe,
 };
 
 module_i2c_driver(max11801_ts_driver);
 
 MODULE_DEVICE_TABLE(i2c, mcs5000_ts_id);
 
 static struct i2c_driver mcs5000_ts_driver = {
-       .probe_new      = mcs5000_ts_probe,
+       .probe          = mcs5000_ts_probe,
        .driver = {
                .name = "mcs5000_ts",
                .pm   = pm_sleep_ptr(&mcs5000_ts_pm),
 
 
 static struct i2c_driver mip4_driver = {
        .id_table = mip4_i2c_ids,
-       .probe_new = mip4_probe,
+       .probe = mip4_probe,
        .driver = {
                .name = MIP4_DEVICE_NAME,
                .of_match_table = of_match_ptr(mip4_of_match),
 
                .name = "migor_ts",
                .pm = pm_sleep_ptr(&migor_ts_pm),
        },
-       .probe_new = migor_ts_probe,
+       .probe = migor_ts_probe,
        .remove = migor_ts_remove,
        .id_table = migor_ts_id,
 };
 
                .pm     = pm_sleep_ptr(&mms114_pm_ops),
                .of_match_table = of_match_ptr(mms114_dt_match),
        },
-       .probe_new      = mms114_probe,
+       .probe          = mms114_probe,
        .id_table       = mms114_id,
 };
 
 
 MODULE_DEVICE_TABLE(of, msg2638_of_match);
 
 static struct i2c_driver msg2638_ts_driver = {
-       .probe_new = msg2638_ts_probe,
+       .probe = msg2638_ts_probe,
        .driver = {
                .name = "MStar-TS",
                .pm = pm_sleep_ptr(&msg2638_pm_ops),
 
                .name   = "novatek-nvt-ts",
                .pm     = pm_sleep_ptr(&nvt_ts_pm_ops),
        },
-       .probe_new = nvt_ts_probe,
+       .probe = nvt_ts_probe,
        .id_table = nvt_ts_i2c_id,
 };
 
 
                .pm     = pm_sleep_ptr(&pixcir_dev_pm_ops),
                .of_match_table = of_match_ptr(pixcir_of_match),
        },
-       .probe_new      = pixcir_i2c_ts_probe,
+       .probe          = pixcir_i2c_ts_probe,
        .id_table       = pixcir_i2c_ts_id,
 };
 
 
 #endif
 
 static struct i2c_driver raydium_i2c_driver = {
-       .probe_new = raydium_i2c_probe,
+       .probe = raydium_i2c_probe,
        .id_table = raydium_i2c_id,
        .driver = {
                .name = "raydium_ts",
 
        .driver = {
                .name = BU21023_NAME,
        },
-       .probe_new = rohm_bu21023_i2c_probe,
+       .probe = rohm_bu21023_i2c_probe,
        .id_table = rohm_bu21023_i2c_id,
 };
 module_i2c_driver(rohm_bu21023_i2c_driver);
 
                .of_match_table = of_match_ptr(s6sy761_of_match),
                .pm = pm_ptr(&s6sy761_pm_ops),
        },
-       .probe_new = s6sy761_probe,
+       .probe = s6sy761_probe,
        .remove = s6sy761_remove,
        .id_table = s6sy761_id,
 };
 
 #endif
 
 static struct i2c_driver silead_ts_driver = {
-       .probe_new = silead_ts_probe,
+       .probe = silead_ts_probe,
        .id_table = silead_ts_id,
        .driver = {
                .name = SILEAD_TS_NAME,
 
                .name   = SIS_I2C_NAME,
                .of_match_table = of_match_ptr(sis_ts_dt_ids),
        },
-       .probe_new      = sis_ts_probe,
+       .probe          = sis_ts_probe,
        .id_table       = sis_ts_id,
 };
 module_i2c_driver(sis_ts_driver);
 
 MODULE_DEVICE_TABLE(of, st1232_ts_dt_ids);
 
 static struct i2c_driver st1232_ts_driver = {
-       .probe_new      = st1232_ts_probe,
+       .probe          = st1232_ts_probe,
        .id_table       = st1232_ts_id,
        .driver = {
                .name   = ST1232_TS_NAME,
 
                .pm = pm_ptr(&stmfts_pm_ops),
                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
-       .probe_new = stmfts_probe,
+       .probe = stmfts_probe,
        .remove = stmfts_remove,
        .id_table = stmfts_id,
 };
 
                .of_match_table = of_match_ptr(sx8654_of_match),
        },
        .id_table = sx8654_id_table,
-       .probe_new = sx8654_probe,
+       .probe = sx8654_probe,
 };
 module_i2c_driver(sx8654_driver);
 
 
                .pm     = pm_sleep_ptr(&tsc200x_pm_ops),
        },
        .id_table       = tsc2004_idtable,
-       .probe_new      = tsc2004_probe,
+       .probe          = tsc2004_probe,
        .remove         = tsc2004_remove,
 };
 module_i2c_driver(tsc2004_driver);
 
                .of_match_table = tsc2007_of_match,
        },
        .id_table       = tsc2007_idtable,
-       .probe_new      = tsc2007_probe,
+       .probe          = tsc2007_probe,
 };
 
 module_i2c_driver(tsc2007_driver);
 
                .pm     = pm_sleep_ptr(&wacom_i2c_pm),
        },
 
-       .probe_new      = wacom_i2c_probe,
+       .probe          = wacom_i2c_probe,
        .id_table       = wacom_i2c_id,
 };
 module_i2c_driver(wacom_i2c_driver);
 
 MODULE_DEVICE_TABLE(acpi, wdt87xx_acpi_id);
 
 static struct i2c_driver wdt87xx_driver = {
-       .probe_new      = wdt87xx_ts_probe,
+       .probe          = wdt87xx_ts_probe,
        .id_table       = wdt87xx_dev_id,
        .driver = {
                .name   = WDT87XX_NAME,
 
                .name = "zet6223",
                .of_match_table = zet6223_of_match,
        },
-       .probe_new = zet6223_probe,
+       .probe = zet6223_probe,
        .id_table = zet6223_id
 };
 module_i2c_driver(zet6223_driver);
 
                .pm     = pm_sleep_ptr(&zforce_pm_ops),
                .of_match_table = of_match_ptr(zforce_dt_idtable),
        },
-       .probe_new      = zforce_probe,
+       .probe          = zforce_probe,
        .id_table       = zforce_idtable,
 };
 
 
 #endif
 
 static struct i2c_driver zinitix_ts_driver = {
-       .probe_new = zinitix_ts_probe,
+       .probe = zinitix_ts_probe,
        .driver = {
                .name = "Zinitix-TS",
                .pm = pm_sleep_ptr(&zinitix_pm_ops),