if (ret >= 0){
                ret = misc_register(&rtc_dev);
                if(ret < 0)
-                       i2c_bit_del_bus(&ioc_ops);
+                       i2c_del_adapter(&ioc_ops);
        }
 
        return ret;
 
 
        return i2c_add_adapter(adap);
 }
-
-
-int i2c_bit_del_bus(struct i2c_adapter *adap)
-{
-       return i2c_del_adapter(adap);
-}
-
 EXPORT_SYMBOL(i2c_bit_add_bus);
-EXPORT_SYMBOL(i2c_bit_del_bus);
 
 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
 MODULE_DESCRIPTION("I2C-Bus bit-banging algorithm");
 
 
        return rval;
 }
-
-int i2c_pca_del_bus(struct i2c_adapter *adap)
-{
-       return i2c_del_adapter(adap);
-}
-
 EXPORT_SYMBOL(i2c_pca_add_bus);
-EXPORT_SYMBOL(i2c_pca_del_bus);
 
 MODULE_AUTHOR("Ian Campbell <icampbell@arcom.com>");
 MODULE_DESCRIPTION("I2C-Bus PCA9564 algorithm");
 
 
        return rval;
 }
-
-
-int i2c_pcf_del_bus(struct i2c_adapter *adap)
-{
-       return i2c_del_adapter(adap);
-}
-
 EXPORT_SYMBOL(i2c_pcf_add_bus);
-EXPORT_SYMBOL(i2c_pcf_del_bus);
 
 MODULE_AUTHOR("Hans Berglund <hb@spacetec.no>");
 MODULE_DESCRIPTION("I2C-Bus PCF8584 algorithm");
 
 
        return i2c_add_adapter(adap);
 }
-
-
-int i2c_sgi_del_bus(struct i2c_adapter *adap)
-{
-       return i2c_del_adapter(adap);
-}
-
 EXPORT_SYMBOL(i2c_sgi_add_bus);
-EXPORT_SYMBOL(i2c_sgi_del_bus);
 
 MODULE_AUTHOR("Ladislav Michl <ladis@linux-mips.org>");
 MODULE_DESCRIPTION("I2C-Bus SGI algorithm");
 
 
 static void i2c_pcfisa_exit(void)
 {
-       i2c_pcf_del_bus(&pcf_isa_ops);
+       i2c_del_adapter(&pcf_isa_ops);
 
        if (irq > 0) {
                disable_irq(irq);
 
 static void __devexit hydra_remove(struct pci_dev *dev)
 {
        pdregw(hydra_bit_data.data, 0);         /* clear SCLK_OE and SDAT_OE */
-       i2c_bit_del_bus(&hydra_adap);
+       i2c_del_adapter(&hydra_adap);
        iounmap(hydra_bit_data.data);
        release_mem_region(pci_resource_start(dev, 0)+
                           offsetof(struct Hydra, CachePD), 4);
 
                return retval;
        retval = i2c_bit_add_bus(&i810_ddc_adapter);
        if (retval)
-               i2c_bit_del_bus(&i810_i2c_adapter);
+               i2c_del_adapter(&i810_i2c_adapter);
        return retval;
 }
 
 static void __devexit i810_remove(struct pci_dev *dev)
 {
-       i2c_bit_del_bus(&i810_ddc_adapter);
-       i2c_bit_del_bus(&i810_i2c_adapter);
+       i2c_del_adapter(&i810_ddc_adapter);
+       i2c_del_adapter(&i810_i2c_adapter);
        iounmap(ioaddr);
 }
 
 
 
        platform_set_drvdata(plat_dev, NULL);
 
-       i2c_bit_del_bus(&drv_data->adapter);
+       i2c_del_adapter(&drv_data->adapter);
 
        kfree(drv_data);
 
 
 
        platform_set_drvdata(plat_dev, NULL);
 
-       i2c_bit_del_bus(&drv_data->adapter);
+       i2c_del_adapter(&drv_data->adapter);
 
        kfree(drv_data);
 
 
        if (adapter_parm[type].init.val)
                line_set(0, &adapter_parm[type].init);
 
-       i2c_bit_del_bus(&parport_adapter);
+       i2c_del_adapter(&parport_adapter);
        release_region(base, 3);
 }
 
 
                        if (adapter_parm[type].init.val)
                                line_set(port, 0, &adapter_parm[type].init);
                                
-                       i2c_bit_del_bus(&adapter->adapter);
+                       i2c_del_adapter(&adapter->adapter);
                        parport_unregister_device(adapter->pdev);
                        if (prev)
                                prev->next = adapter->next;
 
 
 static void pca_isa_exit(void)
 {
-       i2c_pca_del_bus(&pca_isa_ops);
+       i2c_del_adapter(&pca_isa_ops);
 
        if (irq > 0) {
                disable_irq(irq);
 
                if (chip->i2c_bus[i].adap_ok == 0)
                        continue;
 
-               ret = i2c_bit_del_bus(&chip->i2c_bus[i].adap);
+               ret = i2c_del_adapter(&chip->i2c_bus[i].adap);
                if (ret) {
                        dev_err(&dev->dev, "%s not removed\n",
                                chip->i2c_bus[i].adap.name);
 
 
 static void __devexit savage4_remove(struct pci_dev *dev)
 {
-       i2c_bit_del_bus(&savage4_i2c_adapter);
+       i2c_del_adapter(&savage4_i2c_adapter);
        iounmap(ioaddr);
 }
 
 
 
 static void __devexit vt586b_remove(struct pci_dev *dev)
 {
-       i2c_bit_del_bus(&vt586b_adapter);
+       i2c_del_adapter(&vt586b_adapter);
        release_region(I2C_DIR, IOSPACE);
        pm_io_base = 0;
 }
 
                return retval;
        retval = i2c_bit_add_bus(&voodoo3_ddc_adapter);
        if (retval)
-               i2c_bit_del_bus(&voodoo3_i2c_adapter);
+               i2c_del_adapter(&voodoo3_i2c_adapter);
        return retval;
 }
 
 static void __devexit voodoo3_remove(struct pci_dev *dev)
 {
-       i2c_bit_del_bus(&voodoo3_i2c_adapter);
-       i2c_bit_del_bus(&voodoo3_ddc_adapter);
+       i2c_del_adapter(&voodoo3_i2c_adapter);
+       i2c_del_adapter(&voodoo3_ddc_adapter);
        iounmap(ioaddr);
 }
 
 
 
 static void scx200_i2c_cleanup(void)
 {
-       i2c_bit_del_bus(&scx200_i2c_ops);
+       i2c_del_adapter(&scx200_i2c_ops);
 }
 
 module_init(scx200_i2c_init);
 
 
                         }
 
-                        i2c_bit_del_bus(i2c_ad);
+                       i2c_del_adapter(i2c_ad);
                        kfree(i2c_ad);
                 }
         }
 
        /* dvb */
        ret = dvb_register_adapter(&pluto->dvb_adapter, DRIVER_NAME, THIS_MODULE, &pdev->dev);
        if (ret < 0)
-               goto err_i2c_bit_del_bus;
+               goto err_i2c_del_adapter;
 
        dvb_adapter = &pluto->dvb_adapter;
 
        dvb_dmx_release(dvbdemux);
 err_dvb_unregister_adapter:
        dvb_unregister_adapter(dvb_adapter);
-err_i2c_bit_del_bus:
-       i2c_bit_del_bus(&pluto->i2c_adap);
+err_i2c_del_adapter:
+       i2c_del_adapter(&pluto->i2c_adap);
 err_pluto_hw_exit:
        pluto_hw_exit(pluto);
 err_free_irq:
        dvb_dmxdev_release(&pluto->dmxdev);
        dvb_dmx_release(dvbdemux);
        dvb_unregister_adapter(dvb_adapter);
-       i2c_bit_del_bus(&pluto->i2c_adap);
+       i2c_del_adapter(&pluto->i2c_adap);
        pluto_hw_exit(pluto);
        free_irq(pdev->irq, pluto);
        pci_iounmap(pdev, pluto->io_mem);
 
        if (0 != btv->i2c_rc)
                return 0;
 
-       if (btv->use_i2c_hw) {
-               return i2c_del_adapter(&btv->c.i2c_adap);
-       } else {
-               return i2c_bit_del_bus(&btv->c.i2c_adap);
-       }
+       return i2c_del_adapter(&btv->c.i2c_adap);
 }
 
 /*
 
        mutex_lock(&devlist);
        cx88_ir_fini(core);
        if (0 == core->i2c_rc)
-               i2c_bit_del_bus(&core->i2c_adap);
+               i2c_del_adapter(&core->i2c_adap);
        list_del(&core->devlist);
        iounmap(core->lmmio);
        cx88_devcount--;
 
            dev->core->board != CX88_BOARD_DNTV_LIVE_DVB_T_PRO)
                return;
 
-       i2c_bit_del_bus(&vp3054_i2c->adap);
+       i2c_del_adapter(&vp3054_i2c->adap);
        kfree(vp3054_i2c);
 }
 
 
 
 static int vino_i2c_del_bus(void)
 {
-       return i2c_sgi_del_bus(&vino_i2c_adapter);
+       return i2c_del_adapter(&vino_i2c_adapter);
 }
 
 static int i2c_camera_command(unsigned int cmd, void *arg)
 
 static void
 zoran_unregister_i2c (struct zoran *zr)
 {
-       i2c_bit_del_bus((&zr->i2c_adapter));
+       i2c_del_adapter(&zr->i2c_adapter);
 }
 
 /* Check a zoran_params struct for correctness, insert default params */
 
 void radeon_delete_i2c_busses(struct radeonfb_info *rinfo)
 {
        if (rinfo->i2c[0].rinfo)
-               i2c_bit_del_bus(&rinfo->i2c[0].adapter);
+               i2c_del_adapter(&rinfo->i2c[0].adapter);
        rinfo->i2c[0].rinfo = NULL;
 
        if (rinfo->i2c[1].rinfo)
-               i2c_bit_del_bus(&rinfo->i2c[1].adapter);
+               i2c_del_adapter(&rinfo->i2c[1].adapter);
        rinfo->i2c[1].rinfo = NULL;
 
        if (rinfo->i2c[2].rinfo)
-               i2c_bit_del_bus(&rinfo->i2c[2].adapter);
+               i2c_del_adapter(&rinfo->i2c[2].adapter);
        rinfo->i2c[2].rinfo = NULL;
 
        if (rinfo->i2c[3].rinfo)
-               i2c_bit_del_bus(&rinfo->i2c[3].adapter);
+               i2c_del_adapter(&rinfo->i2c[3].adapter);
        rinfo->i2c[3].rinfo = NULL;
 }
 
 
 void i810_delete_i2c_busses(struct i810fb_par *par)
 {
         if (par->chan[0].par)
-                i2c_bit_del_bus(&par->chan[0].adapter);
+               i2c_del_adapter(&par->chan[0].adapter);
         par->chan[0].par = NULL;
 
        if (par->chan[1].par)
-               i2c_bit_del_bus(&par->chan[1].adapter);
+               i2c_del_adapter(&par->chan[1].adapter);
        par->chan[1].par = NULL;
 
        if (par->chan[2].par)
-               i2c_bit_del_bus(&par->chan[2].adapter);
+               i2c_del_adapter(&par->chan[2].adapter);
        par->chan[2].par = NULL;
 }
 
 
 
        for (i = 0; i < MAX_OUTPUTS; i++) {
                if (dinfo->output[i].i2c_bus.dinfo) {
-                       i2c_bit_del_bus(&dinfo->output[i].i2c_bus.adapter);
+                       i2c_del_adapter(&dinfo->output[i].i2c_bus.adapter);
                        dinfo->output[i].i2c_bus.dinfo = NULL;
                }
                if (dinfo->output[i].ddc_bus.dinfo) {
-                       i2c_bit_del_bus(&dinfo->output[i].ddc_bus.adapter);
+                       i2c_del_adapter(&dinfo->output[i].ddc_bus.adapter);
                        dinfo->output[i].ddc_bus.dinfo = NULL;
                }
        }
 
 
 static void i2c_bit_bus_del(struct i2c_bit_adapter* b) {
        if (b->initialized) {
-               i2c_bit_del_bus(&b->adapter);
+               i2c_del_adapter(&b->adapter);
                b->initialized = 0;
        }
 }
 
 void nvidia_delete_i2c_busses(struct nvidia_par *par)
 {
        if (par->chan[0].par)
-               i2c_bit_del_bus(&par->chan[0].adapter);
+               i2c_del_adapter(&par->chan[0].adapter);
        par->chan[0].par = NULL;
 
        if (par->chan[1].par)
-               i2c_bit_del_bus(&par->chan[1].adapter);
+               i2c_del_adapter(&par->chan[1].adapter);
        par->chan[1].par = NULL;
 
        if (par->chan[2].par)
-               i2c_bit_del_bus(&par->chan[2].adapter);
+               i2c_del_adapter(&par->chan[2].adapter);
        par->chan[2].par = NULL;
 
 }
 
 void riva_delete_i2c_busses(struct riva_par *par)
 {
        if (par->chan[0].par)
-               i2c_bit_del_bus(&par->chan[0].adapter);
+               i2c_del_adapter(&par->chan[0].adapter);
        par->chan[0].par = NULL;
 
        if (par->chan[1].par)
-               i2c_bit_del_bus(&par->chan[1].adapter);
+               i2c_del_adapter(&par->chan[1].adapter);
        par->chan[1].par = NULL;
 
        if (par->chan[2].par)
-               i2c_bit_del_bus(&par->chan[2].adapter);
+               i2c_del_adapter(&par->chan[2].adapter);
        par->chan[2].par = NULL;
 }
 
 
        struct savagefb_par *par = info->par;
 
        if (par->chan.par)
-               i2c_bit_del_bus(&par->chan.adapter);
+               i2c_del_adapter(&par->chan.adapter);
 
        par->chan.par = NULL;
 }
 
 };
 
 int i2c_bit_add_bus(struct i2c_adapter *);
-int i2c_bit_del_bus(struct i2c_adapter *);
 
 #endif /* _LINUX_I2C_ALGO_BIT_H */
 
 };
 
 int i2c_pca_add_bus(struct i2c_adapter *);
-int i2c_pca_del_bus(struct i2c_adapter *);
 
 #endif /* _LINUX_I2C_ALGO_PCA_H */
 
 };
 
 int i2c_pcf_add_bus(struct i2c_adapter *);
-int i2c_pcf_del_bus(struct i2c_adapter *);
 
 #endif /* _LINUX_I2C_ALGO_PCF_H */
 
 };
 
 int i2c_sgi_add_bus(struct i2c_adapter *);
-int i2c_sgi_del_bus(struct i2c_adapter *);
 
 #endif /* I2C_ALGO_SGI_H */