spi_master_put(uwire->bitbang.master);
 }
 
-static int uwire_probe(struct platform_device *pdev)
+static int __init uwire_probe(struct platform_device *pdev)
 {
        struct spi_master       *master;
        struct uwire_spi        *uwire;
        return status;
 }
 
-static int uwire_remove(struct platform_device *pdev)
+static int __exit uwire_remove(struct platform_device *pdev)
 {
        struct uwire_spi        *uwire = dev_get_drvdata(&pdev->dev);
        int                     status;
                .bus            = &platform_bus_type,
                .owner          = THIS_MODULE,
        },
-       .probe          = uwire_probe,
-       .remove         = uwire_remove,
+       .remove         = __exit_p(uwire_remove),
        // suspend ... unuse ck
        // resume ... use ck
 };
                omap_writel(val | 0x00AAA000, OMAP730_IO_CONF_9);
        }
 
-       return platform_driver_register(&uwire_driver);
+       return platform_driver_probe(&uwire_driver, uwire_probe);
 }
 
 static void __exit omap_uwire_exit(void)
 
        kfree(chip);
 }
 
-static int init_queue(struct driver_data *drv_data)
+static int __init init_queue(struct driver_data *drv_data)
 {
        INIT_LIST_HEAD(&drv_data->queue);
        spin_lock_init(&drv_data->lock);
        return 0;
 }
 
-static int pxa2xx_spi_probe(struct platform_device *pdev)
+static int __init pxa2xx_spi_probe(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
        struct pxa2xx_spi_master *platform_info;
                .bus = &platform_bus_type,
                .owner = THIS_MODULE,
        },
-       .probe = pxa2xx_spi_probe,
-       .remove = __devexit_p(pxa2xx_spi_remove),
+       .remove = pxa2xx_spi_remove,
        .shutdown = pxa2xx_spi_shutdown,
        .suspend = pxa2xx_spi_suspend,
        .resume = pxa2xx_spi_resume,
 
 static int __init pxa2xx_spi_init(void)
 {
-       platform_driver_register(&driver);
-
-       return 0;
+       return platform_driver_probe(&driver, pxa2xx_spi_probe);
 }
 module_init(pxa2xx_spi_init);
 
 
        kfree(spi_get_ctldata(spi));
 }
 
-static int init_queue(struct driver_data *drv_data)
+static int __init init_queue(struct driver_data *drv_data)
 {
        INIT_LIST_HEAD(&drv_data->queue);
        spin_lock_init(&drv_data->lock);
        return 0;
 }
 
-static int spi_imx_probe(struct platform_device *pdev)
+static int __init spi_imx_probe(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
        struct spi_imx_master *platform_info;
        return status;
 }
 
-static int __devexit spi_imx_remove(struct platform_device *pdev)
+static int __exit spi_imx_remove(struct platform_device *pdev)
 {
        struct driver_data *drv_data = platform_get_drvdata(pdev);
        int irq;
                .bus = &platform_bus_type,
                .owner = THIS_MODULE,
        },
-       .probe = spi_imx_probe,
-       .remove = __devexit_p(spi_imx_remove),
+       .remove = __exit_p(spi_imx_remove),
        .shutdown = spi_imx_shutdown,
        .suspend = spi_imx_suspend,
        .resume = spi_imx_resume,
 
 static int __init spi_imx_init(void)
 {
-       return platform_driver_register(&driver);
+       return platform_driver_probe(&driver, spi_imx_probe);
 }
 module_init(spi_imx_init);
 
 
        return ret;
 }
 
-static int __devexit mpc83xx_spi_remove(struct platform_device *dev)
+static int __exit mpc83xx_spi_remove(struct platform_device *dev)
 {
        struct mpc83xx_spi *mpc83xx_spi;
        struct spi_master *master;
 
 MODULE_ALIAS("mpc83xx_spi");                   /* for platform bus hotplug */
 static struct platform_driver mpc83xx_spi_driver = {
-       .probe = mpc83xx_spi_probe,
-       .remove = __devexit_p(mpc83xx_spi_remove),
+       .remove = __exit_p(mpc83xx_spi_remove),
        .driver = {
                   .name = "mpc83xx_spi",
        },
 
 static int __init mpc83xx_spi_init(void)
 {
-       return platform_driver_register(&mpc83xx_spi_driver);
+       return platform_driver_probe(&mpc83xx_spi_driver, mpc83xx_spi_probe);
 }
 
 static void __exit mpc83xx_spi_exit(void)
 
        return IRQ_HANDLED;
 }
 
-static int s3c24xx_spi_probe(struct platform_device *pdev)
+static int __init s3c24xx_spi_probe(struct platform_device *pdev)
 {
        struct s3c24xx_spi *hw;
        struct spi_master *master;
        return err;
 }
 
-static int s3c24xx_spi_remove(struct platform_device *dev)
+static int __exit s3c24xx_spi_remove(struct platform_device *dev)
 {
        struct s3c24xx_spi *hw = platform_get_drvdata(dev);
 
 
 MODULE_ALIAS("s3c2410_spi");                   /* for platform bus hotplug */
 static struct platform_driver s3c24xx_spidrv = {
-       .probe          = s3c24xx_spi_probe,
-       .remove         = s3c24xx_spi_remove,
+       .remove         = __exit_p(s3c24xx_spi_remove),
        .suspend        = s3c24xx_spi_suspend,
        .resume         = s3c24xx_spi_resume,
        .driver         = {
 
 static int __init s3c24xx_spi_init(void)
 {
-        return platform_driver_register(&s3c24xx_spidrv);
+        return platform_driver_probe(&s3c24xx_spidrv, s3c24xx_spi_probe);
 }
 
 static void __exit s3c24xx_spi_exit(void)