[Kernel] Add device ops feature.

bsp/qemu-vexpress-a9/drivers/drv_clcd.c

@@ -5,8 +5,8 @@
 #include <rtthread.h>
 #include "drv_clcd.h"
 
-#define CLCD_WIDTH  480
-#define CLCD_HEIGHT 320
+#define CLCD_WIDTH  640
+#define CLCD_HEIGHT 480
 
 #define CLCD_DEVICE(dev)    (struct drv_clcd_device*)(dev)
 
@@ -78,6 +78,18 @@ static rt_err_t drv_clcd_control(struct rt_device *device, int cmd, void *args)
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops clcd_ops = 
+{
+    drv_clcd_init,
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    drv_clcd_control
+};
+#endif
+
 int drv_clcd_hw_init(void)
 {
     PL111MMIO   *plio;
@@ -107,8 +119,13 @@ int drv_clcd_hw_init(void)
     plio->control = 0x1921 | (0x6 << 1);
 
     device->type    = RT_Device_Class_Graphic;
+#ifdef RT_USING_DEVICE_OPS
+    device->ops     = &clcd_ops;
+#else
     device->init    = drv_clcd_init;
     device->control = drv_clcd_control;
+#endif
+
     rt_device_register(device, "lcd", RT_DEVICE_FLAG_RDWR);
 
     return 0;

bsp/qemu-vexpress-a9/drivers/drv_smc911x.c

@@ -485,6 +485,18 @@ struct pbuf *smc911x_emac_rx(rt_device_t dev)
     return p;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops smc911x_emac_ops = 
+{
+    smc911x_emac_init,
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    smc911x_emac_control
+};
+#endif
+
 int smc911x_emac_hw_init(void)
 {
     _emac.iobase = VEXPRESS_ETH_BASE;
@@ -507,12 +519,16 @@ int smc911x_emac_hw_init(void)
     _emac.enetaddr[4] = 0x22;
     _emac.enetaddr[5] = 0x33;
 
+#ifdef RT_USING_DEVICE_OPS
+    _emac.parent.parent.ops        = &smc911x_emac_ops;
+#else
     _emac.parent.parent.init       = smc911x_emac_init;
     _emac.parent.parent.open       = RT_NULL;
     _emac.parent.parent.close      = RT_NULL;
     _emac.parent.parent.read       = RT_NULL;
     _emac.parent.parent.write      = RT_NULL;
     _emac.parent.parent.control    = smc911x_emac_control;
+#endif
     _emac.parent.parent.user_data  = RT_NULL;
     _emac.parent.eth_rx     = smc911x_emac_rx;
     _emac.parent.eth_tx     = smc911x_emac_tx;
@@ -540,12 +556,3 @@ int smc911x_emac_hw_init(void)
     return 0;
 }
 INIT_APP_EXPORT(smc911x_emac_hw_init);
-
-#include <finsh.h>
-int emac(int argc, char** argv)
-{
-    rt_hw_interrupt_umask(_emac.irqno);
-
-    return 0;
-}
-MSH_CMD_EXPORT(emac, emac dump);

components/drivers/audio/audio.c

@@ -421,6 +421,18 @@ static rt_err_t _audio_dev_control(struct rt_device *dev, int cmd, void *args)
     return result;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops audio_ops =
+{
+    _audio_dev_init,
+    _audio_dev_open,
+    _audio_dev_close,
+    _audio_dev_read,
+    _audio_dev_write,
+    _audio_dev_control
+};
+#endif
+
 rt_err_t rt_audio_register(struct rt_audio_device *audio, const char *name, rt_uint32_t flag, void *data)
 {
     struct rt_device *device;
@@ -431,12 +443,16 @@ rt_err_t rt_audio_register(struct rt_audio_device *audio, const char *name, rt_u
     device->rx_indicate = RT_NULL;
     device->tx_complete = RT_NULL;
 
+#ifdef RT_USING_DEVICE_OPS
+    device->ops  = &audio_ops;
+#else
     device->init    = _audio_dev_init;
     device->open    = _audio_dev_open;
     device->close   = _audio_dev_close;
     device->read    = _audio_dev_read;
     device->write   = _audio_dev_write;
     device->control = _audio_dev_control;
+#endif
     device->user_data = data;
 
     //init memory pool for replay

components/drivers/audio/audio_pipe.c

@@ -201,6 +201,18 @@ static rt_err_t rt_pipe_control(rt_device_t dev, int cmd, void *args)
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops audio_pipe_ops
+{
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    rt_pipe_read,
+    rt_pipe_write,
+    rt_pipe_control
+};
+#endif
+
 /**
  * This function will initialize a pipe device and put it under control of
  * resource management.
@@ -233,12 +245,16 @@ rt_err_t rt_audio_pipe_init(struct rt_audio_pipe *pipe,
 
     /* create pipe */
     pipe->parent.type    = RT_Device_Class_Pipe;
+#ifdef RT_USING_DEVICE_OPS
+    pipe->parent.ops     = &audio_pipe_ops;
+#else
     pipe->parent.init    = RT_NULL;
     pipe->parent.open    = RT_NULL;
     pipe->parent.close   = RT_NULL;
     pipe->parent.read    = rt_pipe_read;
     pipe->parent.write   = rt_pipe_write;
     pipe->parent.control = rt_pipe_control;
+#endif
 
     return rt_device_register(&(pipe->parent), name, RT_DEVICE_FLAG_RDWR);
 }

components/drivers/can/can.c

@@ -687,6 +687,18 @@ static void cantimeout(void *arg)
     }
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops can_device_ops =
+{
+    rt_can_init,
+    rt_can_open,
+    rt_can_close,
+    rt_can_read,
+    rt_can_write,
+    rt_can_control
+};
+#endif
+
 /*
  * can register
  */
@@ -712,12 +724,17 @@ rt_err_t rt_hw_can_register(struct rt_can_device *can,
 #ifdef RT_CAN_USING_BUS_HOOK
     can->bus_hook       = RT_NULL;
 #endif /*RT_CAN_USING_BUS_HOOK*/
+
+#ifdef RT_USING_DEVICE_OPS
+    device->ops         = &can_device_ops;
+#else
     device->init        = rt_can_init;
     device->open        = rt_can_open;
     device->close       = rt_can_close;
     device->read        = rt_can_read;
     device->write       = rt_can_write;
     device->control     = rt_can_control;
+#endif
     can->ops            = ops;
 
     can->status_indicate.ind  = RT_NULL;

components/drivers/hwtimer/hwtimer.c

@@ -35,13 +35,13 @@ rt_inline rt_uint32_t timeout_calc(rt_hwtimer_t *timer, rt_hwtimerval_t *tv)
     float devi_min = 1;
     float devi;
 
-    /* 把定时器溢出时间和定时时间换算成秒 */
+    /* changed to second */
     overflow = timer->info->maxcnt/(float)timer->freq;
     tv_sec = tv->sec + tv->usec/(float)1000000;
 
     if (tv_sec < (1/(float)timer->freq))
     {
-        /* 定时时间小于计数周期 */
+        /* little timeout */
         i = 0;
         timeout = 1/(float)timer->freq;
     }
@@ -55,7 +55,7 @@ rt_inline rt_uint32_t timeout_calc(rt_hwtimer_t *timer, rt_hwtimerval_t *tv)
             {
                 counter = timeout*timer->freq;
                 devi = tv_sec - (counter/(float)timer->freq)*i;
-                /* 计算最小误差 */
+                /* Minimum calculation error */
                 if (devi > devi_min)
                 {
                     i = index;
@@ -89,7 +89,7 @@ static rt_err_t rt_hwtimer_init(struct rt_device *dev)
     rt_hwtimer_t *timer;
 
     timer = (rt_hwtimer_t *)dev;
-    /* 尝试将默认计数频率设为1Mhz */
+    /* try to change to 1MHz */
     if ((1000000 <= timer->info->maxfreq) && (1000000 >= timer->info->minfreq))
     {
         timer->freq = 1000000;
@@ -330,6 +330,18 @@ void rt_device_hwtimer_isr(rt_hwtimer_t *timer)
     }
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops hwtimer_ops = 
+{
+    rt_hwtimer_init,
+    rt_hwtimer_open,
+    rt_hwtimer_close,
+    rt_hwtimer_read,
+    rt_hwtimer_write,
+    rt_hwtimer_control
+};
+#endif
+
 rt_err_t rt_device_hwtimer_register(rt_hwtimer_t *timer, const char *name, void *user_data)
 {
     struct rt_device *device;
@@ -344,12 +356,16 @@ rt_err_t rt_device_hwtimer_register(rt_hwtimer_t *timer, const char *name, void
     device->rx_indicate = RT_NULL;
     device->tx_complete = RT_NULL;
 
+#ifdef RT_USING_DEVICE_OPS
+    device->ops         = &hwtimer_ops;
+#else
     device->init        = rt_hwtimer_init;
     device->open        = rt_hwtimer_open;
     device->close       = rt_hwtimer_close;
     device->read        = rt_hwtimer_read;
     device->write       = rt_hwtimer_write;
     device->control     = rt_hwtimer_control;
+#endif
     device->user_data   = user_data;
 
     return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);

components/drivers/i2c/fm24clxx.c

@@ -132,6 +132,18 @@ static rt_size_t fm24clxx_write(rt_device_t dev, rt_off_t pos, const void *buffe
     return (ret == 2) ? size : 0;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device fm24clxx_ops =
+{
+    fm24clxx_init,
+    fm24clxx_open,
+    fm24clxx_close,
+    fm24clxx_read,
+    fm24clxx_write,
+    fm24clxx_control
+};
+#endif
+
 rt_err_t fm24clxx_register(const char *fm_device_name, const char *i2c_bus, void *user_data)
 {
     static struct fm24clxx_device fm24clxx_drv;
@@ -145,12 +157,17 @@ rt_err_t fm24clxx_register(const char *fm_device_name, const char *i2c_bus, void
 
     fm24clxx_drv.bus = bus;
     fm24clxx_drv.parent.type      = RT_Device_Class_Block;
+#ifdef RT_USING_DEVICE_OPS
+    fm24clxx_drv.parent.ops       = &fm24clxx_ops;
+#else
     fm24clxx_drv.parent.init      = fm24clxx_init;
     fm24clxx_drv.parent.open      = fm24clxx_open;
     fm24clxx_drv.parent.close     = fm24clxx_close;
     fm24clxx_drv.parent.read      = fm24clxx_read;
     fm24clxx_drv.parent.write     = fm24clxx_write;
     fm24clxx_drv.parent.control   = fm24clxx_control;
+#endif
+
     fm24clxx_drv.parent.user_data = user_data;
 
     return rt_device_register(&fm24clxx_drv.parent, fm_device_name, RT_DEVICE_FLAG_RDWR);

components/drivers/i2c/i2c_dev.c

@@ -102,6 +102,18 @@ static rt_err_t i2c_bus_device_control(rt_device_t dev,
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops i2c_ops = 
+{
+    RT_NULL, 
+    RT_NULL,
+    RT_NULL,
+    i2c_bus_device_read,
+    i2c_bus_device_write,
+    i2c_bus_device_control
+};
+#endif
+
 rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device *bus,
                                        const char               *name)
 {
@@ -115,12 +127,16 @@ rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device *bus,
     /* set device type */
     device->type    = RT_Device_Class_I2CBUS;
     /* initialize device interface */
+#ifdef RT_USING_DEVICE_OPS
+    device->ops     = &i2c_ops;
+#else
     device->init    = RT_NULL;
     device->open    = RT_NULL;
     device->close   = RT_NULL;
     device->read    = i2c_bus_device_read;
     device->write   = i2c_bus_device_write;
     device->control = i2c_bus_device_control;
+#endif
 
     /* register to device manager */
     rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);

components/drivers/misc/pin.c

@@ -76,18 +76,34 @@ static rt_err_t  _pin_control(rt_device_t dev, int cmd, void *args)
     return 0;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops pin_ops =
+{
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    _pin_read,
+    _pin_write,
+    _pin_control
+};
+#endif
+
 int rt_device_pin_register(const char *name, const struct rt_pin_ops *ops, void *user_data)
 {
     _hw_pin.parent.type         = RT_Device_Class_Miscellaneous;
     _hw_pin.parent.rx_indicate  = RT_NULL;
     _hw_pin.parent.tx_complete  = RT_NULL;
 
+#ifdef RT_USING_DEVICE_OPS
+    _hw_pin.parent.ops          = &pin_ops;
+#else
     _hw_pin.parent.init         = RT_NULL;
     _hw_pin.parent.open         = RT_NULL;
     _hw_pin.parent.close        = RT_NULL;
     _hw_pin.parent.read         = _pin_read;
     _hw_pin.parent.write        = _pin_write;
     _hw_pin.parent.control      = _pin_control;
+#endif
 
     _hw_pin.ops                 = ops;
     _hw_pin.parent.user_data    = user_data;
@@ -117,6 +133,7 @@ rt_err_t rt_pin_dettach_irq(rt_int32_t pin)
     }
     return RT_ENOSYS;
 }
+
 rt_err_t rt_pin_irq_enable(rt_base_t pin, rt_uint32_t enabled)
 {
     RT_ASSERT(_hw_pin.ops != RT_NULL);
@@ -126,6 +143,7 @@ rt_err_t rt_pin_irq_enable(rt_base_t pin, rt_uint32_t enabled)
     }
     return RT_ENOSYS;
 }
+
 /* RT-Thread Hardware PIN APIs */
 void rt_pin_mode(rt_base_t pin, rt_base_t mode)
 {

components/drivers/mtd/mtd_nand.c

@@ -69,6 +69,18 @@ static rt_err_t _mtd_control(rt_device_t dev, int cmd, void *args)
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops mtd_nand_ops = 
+{
+    _mtd_init,
+    _mtd_open,
+    _mtd_close,
+    _mtd_read,
+    _mtd_write,
+    _mtd_control
+};
+#endif
+
 rt_err_t rt_mtd_nand_register_device(const char                *name,
                                      struct rt_mtd_nand_device *device)
 {
@@ -79,12 +91,16 @@ rt_err_t rt_mtd_nand_register_device(const char                *name,
 
     /* set device class and generic device interface */
     dev->type        = RT_Device_Class_MTD;
+#ifdef RT_USING_DEVICE_OPS
+	dev->ops         = &mtd_nand_ops;
+#else
     dev->init        = _mtd_init;
     dev->open        = _mtd_open;
     dev->read        = _mtd_read;
     dev->write       = _mtd_write;
     dev->close       = _mtd_close;
     dev->control     = _mtd_control;
+#endif
 
     dev->rx_indicate = RT_NULL;
     dev->tx_complete = RT_NULL;

components/drivers/mtd/mtd_nor.c

@@ -65,6 +65,18 @@ static rt_err_t _mtd_control(rt_device_t dev, int cmd, void *args)
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops mtd_nor_ops = 
+{
+    _mtd_init,
+    _mtd_open,
+    _mtd_close,
+    _mtd_read,
+    _mtd_write,
+    _mtd_control
+};
+#endif
+
 rt_err_t rt_mtd_nor_register_device(const char               *name,
                                     struct rt_mtd_nor_device *device)
 {
@@ -75,12 +87,16 @@ rt_err_t rt_mtd_nor_register_device(const char               *name,
 
     /* set device class and generic device interface */
     dev->type        = RT_Device_Class_MTD;
+#ifdef RT_USING_DEVICE_OPS
+    dev->ops         = &mtd_nor_ops;
+#else
     dev->init        = _mtd_init;
     dev->open        = _mtd_open;
     dev->read        = _mtd_read;
     dev->write       = _mtd_write;
     dev->close       = _mtd_close;
     dev->control     = _mtd_control;
+#endif
 
     dev->rx_indicate = RT_NULL;
     dev->tx_complete = RT_NULL;

components/drivers/rtc/soft_rtc.c

@@ -68,6 +68,18 @@ static rt_err_t soft_rtc_control(rt_device_t dev, int cmd, void *args)
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops soft_rtc_ops = 
+{
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    soft_rtc_control
+};
+#endif
+
 int rt_soft_rtc_init(void)
 {
     static rt_bool_t init_ok = RT_FALSE;
@@ -86,12 +98,16 @@ int rt_soft_rtc_init(void)
     soft_rtc_dev.type    = RT_Device_Class_RTC;
 
     /* register rtc device */
+#ifdef RT_USING_DEVICE_OPS
+    soft_rtc_dev.ops     = &soft_rtc_ops;
+#else
     soft_rtc_dev.init    = RT_NULL;
     soft_rtc_dev.open    = RT_NULL;
     soft_rtc_dev.close   = RT_NULL;
     soft_rtc_dev.read    = RT_NULL;
     soft_rtc_dev.write   = RT_NULL;
     soft_rtc_dev.control = soft_rtc_control;
+#endif
 
     /* no private */
     soft_rtc_dev.user_data = RT_NULL;

components/drivers/sdio/block_dev.c

@@ -319,6 +319,18 @@ static rt_int32_t mmcsd_set_blksize(struct rt_mmcsd_card *card)
     return 0;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops mmcsd_blk_ops = 
+{
+    rt_mmcsd_init,
+    rt_mmcsd_open,
+    rt_mmcsd_close,
+    rt_mmcsd_read,
+    rt_mmcsd_write,
+    rt_mmcsd_control
+};
+#endif
+
 rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
 {
     rt_int32_t err = 0;
@@ -367,12 +379,16 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
     
                 /* register mmcsd device */
                 blk_dev->dev.type = RT_Device_Class_Block;
+#ifdef RT_USING_DEVICE_OPS
+                blk_dev->dev.ops  = &mmcsd_blk_ops;
+#else
                 blk_dev->dev.init = rt_mmcsd_init;
                 blk_dev->dev.open = rt_mmcsd_open;
                 blk_dev->dev.close = rt_mmcsd_close;
                 blk_dev->dev.read = rt_mmcsd_read;
                 blk_dev->dev.write = rt_mmcsd_write;
                 blk_dev->dev.control = rt_mmcsd_control;
+#endif
                 blk_dev->dev.user_data = blk_dev;
 
                 blk_dev->card = card;
@@ -396,12 +412,16 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card)
     
                     /* register mmcsd device */
                     blk_dev->dev.type  = RT_Device_Class_Block;
+#ifdef RT_USING_DEVICE_OPS
+                    blk_dev->dev.ops  = &mmcsd_blk_ops;
+#else
                     blk_dev->dev.init = rt_mmcsd_init;
                     blk_dev->dev.open = rt_mmcsd_open;
                     blk_dev->dev.close = rt_mmcsd_close;
                     blk_dev->dev.read = rt_mmcsd_read;
                     blk_dev->dev.write = rt_mmcsd_write;
                     blk_dev->dev.control = rt_mmcsd_control;
+#endif
                     blk_dev->dev.user_data = blk_dev;
 
                     blk_dev->card = card;
@@ -482,6 +502,3 @@ int rt_mmcsd_blk_init(void)
     /* nothing */
     return 0;
 }
-
-INIT_PREV_EXPORT(rt_mmcsd_blk_init);
-

components/drivers/serial/serial.c

@@ -1072,6 +1072,18 @@ static rt_err_t rt_serial_control(struct rt_device *dev,
     return ret;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops serial_ops = 
+{
+    rt_serial_init,
+    rt_serial_open,
+    rt_serial_close,
+    rt_serial_read,
+    rt_serial_write,
+    rt_serial_control
+};
+#endif
+
 /*
  * serial register
  */
@@ -1090,12 +1102,16 @@ rt_err_t rt_hw_serial_register(struct rt_serial_device *serial,
     device->rx_indicate = RT_NULL;
     device->tx_complete = RT_NULL;
 
+#ifdef RT_USING_DEVICE_OPS
+    device->ops         = &serial_ops;
+#else
     device->init        = rt_serial_init;
     device->open        = rt_serial_open;
     device->close       = rt_serial_close;
     device->read        = rt_serial_read;
     device->write       = rt_serial_write;
     device->control     = rt_serial_control;
+#endif
     device->user_data   = data;
 
     /* register a character device */

components/drivers/spi/enc28j60.c

@@ -741,6 +741,18 @@ static struct pbuf *enc28j60_rx(rt_device_t dev)
     return p;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops enc28j60_ops = 
+{
+    enc28j60_init,
+    enc28j60_open,
+    enc28j60_close,
+    enc28j60_read,
+    enc28j60_write,
+    enc28j60_control
+};
+#endif
+
 rt_err_t enc28j60_attach(const char *spi_device_name)
 {
     struct rt_spi_device *spi_device;
@@ -802,12 +814,16 @@ rt_err_t enc28j60_attach(const char *spi_device_name)
 
     /* init rt-thread device struct */
     enc28j60_dev.parent.parent.type    = RT_Device_Class_NetIf;
+#ifdef RT_USING_DEVICE_OPS
+    enc28j60_dev.parent.parent.ops     = &enc28j60_ops;
+#else
     enc28j60_dev.parent.parent.init    = enc28j60_init;
     enc28j60_dev.parent.parent.open    = enc28j60_open;
     enc28j60_dev.parent.parent.close   = enc28j60_close;
     enc28j60_dev.parent.parent.read    = enc28j60_read;
     enc28j60_dev.parent.parent.write   = enc28j60_write;
     enc28j60_dev.parent.parent.control = enc28j60_control;
+#endif
 
     /* init rt-thread ethernet device struct */
     enc28j60_dev.parent.eth_rx  = enc28j60_rx;

components/drivers/spi/spi_dev.c

@@ -69,6 +69,18 @@ static rt_err_t _spi_bus_device_control(rt_device_t dev,
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops spi_bus_ops = 
+{
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    _spi_bus_device_read,
+    _spi_bus_device_write,
+    _spi_bus_device_control
+};
+#endif
+
 rt_err_t rt_spi_bus_device_init(struct rt_spi_bus *bus, const char *name)
 {
     struct rt_device *device;
@@ -79,12 +91,16 @@ rt_err_t rt_spi_bus_device_init(struct rt_spi_bus *bus, const char *name)
     /* set device type */
     device->type    = RT_Device_Class_SPIBUS;
     /* initialize device interface */
+#ifdef RT_USING_DEVICE_OPS
+    device->ops     = &spi_bus_ops;
+#else
     device->init    = RT_NULL;
     device->open    = RT_NULL;
     device->close   = RT_NULL;
     device->read    = _spi_bus_device_read;
     device->write   = _spi_bus_device_write;
     device->control = _spi_bus_device_control;
+#endif
 
     /* register to device manager */
     return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);
@@ -134,6 +150,18 @@ static rt_err_t _spidev_device_control(rt_device_t dev,
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops spi_device_ops = 
+{
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    _spidev_device_read,
+    _spidev_device_write,
+    _spidev_device_control
+};
+#endif
+
 rt_err_t rt_spidev_device_init(struct rt_spi_device *dev, const char *name)
 {
     struct rt_device *device;
@@ -143,12 +171,16 @@ rt_err_t rt_spidev_device_init(struct rt_spi_device *dev, const char *name)
 
     /* set device type */
     device->type    = RT_Device_Class_SPIDevice;
+#ifdef RT_USING_DEVICE_OPS
+    device->ops     = &spi_device_ops;
+#else
     device->init    = RT_NULL;
     device->open    = RT_NULL;
     device->close   = RT_NULL;
     device->read    = _spidev_device_read;
     device->write   = _spidev_device_write;
     device->control = _spidev_device_control;
+#endif
 
     /* register to device manager */
     return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);

components/drivers/spi/spi_flash_gd.c

@@ -254,6 +254,18 @@ static rt_size_t w25qxx_flash_write(rt_device_t dev,
     return size;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops gd_device_ops =
+{
+    w25qxx_flash_init,
+    w25qxx_flash_open,
+    w25qxx_flash_close,
+    w25qxx_flash_read,
+    w25qxx_flash_write,
+    w25qxx_flash_control
+};
+#endif
+
 rt_err_t gd_init(const char * flash_device_name, const char * spi_device_name)
 {
     struct rt_spi_device * rt_spi_device;
@@ -330,12 +342,16 @@ rt_err_t gd_init(const char * flash_device_name, const char * spi_device_name)
 
     /* register device */
     spi_flash_device.flash_device.type    = RT_Device_Class_Block;
+#ifdef RT_USING_DEVICE_OPS
+    spi_flash_device.flash_device.ops     = &gd_device_ops;
+#else
     spi_flash_device.flash_device.init    = w25qxx_flash_init;
     spi_flash_device.flash_device.open    = w25qxx_flash_open;
     spi_flash_device.flash_device.close   = w25qxx_flash_close;
     spi_flash_device.flash_device.read    = w25qxx_flash_read;
     spi_flash_device.flash_device.write   = w25qxx_flash_write;
     spi_flash_device.flash_device.control = w25qxx_flash_control;
+#endif
     /* no private */
     spi_flash_device.flash_device.user_data = RT_NULL;
 

components/drivers/spi/spi_flash_sfud.c

@@ -225,6 +225,18 @@ sfud_err sfud_spi_port_init(sfud_flash *flash) {
     return result;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops flash_device_ops = 
+{
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    rt_sfud_read,
+    rt_sfud_write,
+    rt_sfud_control
+};
+#endif
+
 /**
  * Probe SPI flash by SFUD(Serial Flash Universal Driver) driver library and though SPI device.
  *
@@ -294,12 +306,16 @@ rt_spi_flash_device_t rt_sfud_flash_probe(const char *spi_flash_dev_name, const
 
         /* register device */
         rtt_dev->flash_device.type = RT_Device_Class_Block;
+#ifdef RT_USING_DEVICE_OPS
+        rtt_dev->flash_device.ops  = &flash_device_ops;
+#else
         rtt_dev->flash_device.init = RT_NULL;
         rtt_dev->flash_device.open = RT_NULL;
         rtt_dev->flash_device.close = RT_NULL;
         rtt_dev->flash_device.read = rt_sfud_read;
         rtt_dev->flash_device.write = rt_sfud_write;
         rtt_dev->flash_device.control = rt_sfud_control;
+#endif
 
         rt_device_register(&(rtt_dev->flash_device), spi_flash_dev_name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
 

components/drivers/spi/spi_flash_sst25vfxx.c

@@ -254,6 +254,18 @@ static rt_size_t sst25vfxx_flash_write(rt_device_t dev, rt_off_t pos, const void
     return size;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops sst25vfxx_device_ops =
+{
+    sst25vfxx_flash_init,
+    sst25vfxx_flash_open,
+    sst25vfxx_flash_close,
+    sst25vfxx_flash_read,
+    sst25vfxx_flash_write,
+    sst25vfxx_flash_control
+};
+#endif
+
 rt_err_t sst25vfxx_init(const char * flash_device_name, const char * spi_device_name)
 {
     struct rt_spi_device * rt_spi_device;
@@ -340,12 +352,16 @@ rt_err_t sst25vfxx_init(const char * flash_device_name, const char * spi_device_
 
     /* register device */
     spi_flash->flash_device.type    = RT_Device_Class_Block;
+#ifdef RT_USING_DEVICE_OPS
+    spi_flash->flash_device.ops     = &sst25vfxx_device_ops;
+#else
     spi_flash->flash_device.init    = sst25vfxx_flash_init;
     spi_flash->flash_device.open    = sst25vfxx_flash_open;
     spi_flash->flash_device.close   = sst25vfxx_flash_close;
     spi_flash->flash_device.read    = sst25vfxx_flash_read;
     spi_flash->flash_device.write   = sst25vfxx_flash_write;
     spi_flash->flash_device.control = sst25vfxx_flash_control;
+#endif
     /* no private */
     spi_flash->flash_device.user_data = RT_NULL;
 

components/drivers/spi/spi_flash_w25qxx.c

@@ -264,6 +264,18 @@ static rt_size_t w25qxx_flash_write(rt_device_t dev,
     return size;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops w25qxx_device_ops =
+{
+    w25qxx_flash_init,
+    w25qxx_flash_open,
+    w25qxx_flash_close,
+    w25qxx_flash_read,
+    w25qxx_flash_write,
+    w25qxx_flash_control
+};
+#endif
+
 rt_err_t w25qxx_init(const char * flash_device_name, const char * spi_device_name)
 {
     struct rt_spi_device * rt_spi_device;
@@ -375,12 +387,16 @@ rt_err_t w25qxx_init(const char * flash_device_name, const char * spi_device_nam
 
     /* register device */
     spi_flash_device.flash_device.type    = RT_Device_Class_Block;
+#ifdef RT_USING_DEVICE_OPS
+    spi_flash_device.flash_device.ops     = &w25qxx_device_ops;
+#else
     spi_flash_device.flash_device.init    = w25qxx_flash_init;
     spi_flash_device.flash_device.open    = w25qxx_flash_open;
     spi_flash_device.flash_device.close   = w25qxx_flash_close;
     spi_flash_device.flash_device.read    = w25qxx_flash_read;
     spi_flash_device.flash_device.write   = w25qxx_flash_write;
     spi_flash_device.flash_device.control = w25qxx_flash_control;
+#endif
     /* no private */
     spi_flash_device.flash_device.user_data = RT_NULL;
 

components/drivers/spi/spi_msd.c

@@ -47,10 +47,14 @@ static void MSD_release_cs(struct rt_spi_device *device);
 
 static rt_err_t _wait_token(struct rt_spi_device *device, uint8_t token);
 static rt_err_t _wait_ready(struct rt_spi_device *device);
+static rt_err_t  rt_msd_init(rt_device_t dev);
+static rt_err_t  rt_msd_open(rt_device_t dev, rt_uint16_t oflag);
+static rt_err_t  rt_msd_close(rt_device_t dev);
 static rt_size_t rt_msd_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
 static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
 static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
 static rt_size_t rt_msd_sdhc_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
+static rt_err_t rt_msd_control(rt_device_t dev, int cmd, void *args);
 
 static rt_err_t MSD_take_owner(struct rt_spi_device *spi_device)
 {
@@ -461,6 +465,28 @@ static rt_err_t _write_block(struct rt_spi_device *device, const void *buffer, u
     return _wait_ready(device);
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops msd_ops = 
+{
+    rt_msd_init,
+    rt_msd_open,
+    rt_msd_close,
+    rt_msd_read,
+    rt_msd_write,
+    rt_msd_control
+};
+
+const static struct rt_device_ops msd_sdhc_ops = 
+{
+    rt_msd_init,
+    rt_msd_open,
+    rt_msd_close,
+    rt_msd_sdhc_read,
+    rt_msd_sdhc_write,
+    rt_msd_control
+};
+#endif
+
 /* RT-Thread Device Driver Interface */
 static rt_err_t rt_msd_init(rt_device_t dev)
 {
@@ -893,13 +919,21 @@ static rt_err_t rt_msd_init(rt_device_t dev)
 
     if (msd->card_type == MSD_CARD_TYPE_SD_SDHC)
     {
+#ifdef RT_USING_DEVICE_OPS
+        dev->ops   = &msd_sdhc_ops;
+#else
         dev->read  = rt_msd_sdhc_read;
         dev->write = rt_msd_sdhc_write;
+#endif
     }
     else
     {
+#ifdef RT_USING_DEVICE_OPS
+        dev->ops   = &msd_ops;
+#else
         dev->read  = rt_msd_read;
         dev->write = rt_msd_write;
+#endif
     }
 
     /* set CRC */
@@ -1674,12 +1708,16 @@ rt_err_t msd_init(const char *sd_device_name, const char *spi_device_name)
     _msd_device.geometry.sector_count = 0;
     _msd_device.geometry.block_size = 0;
 
+#ifdef RT_USING_DEVICE_OPS
+    _msd_device.parent.ops     = &msd_ops;
+#else
     _msd_device.parent.init    = rt_msd_init;
     _msd_device.parent.open    = rt_msd_open;
     _msd_device.parent.close   = rt_msd_close;
     _msd_device.parent.read    = RT_NULL;
     _msd_device.parent.write   = RT_NULL;
     _msd_device.parent.control = rt_msd_control;
+#endif
 
     /* no private, no callback */
     _msd_device.parent.user_data = RT_NULL;

components/drivers/spi/spi_wifi_rw009.c

@@ -629,6 +629,18 @@ static void spi_wifi_data_thread_entry(void *parameter)
     }
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops rw009_ops =
+{
+    rw009_wifi_init,
+    rw009_wifi_open,
+    rw009_wifi_close,
+    rw009_wifi_read,
+    rw009_wifi_write,
+    rw009_wifi_control
+};
+#endif
+
 rt_err_t rt_hw_wifi_init(const char *spi_device_name, wifi_mode_t mode)
 {
     /* align and struct size check. */
@@ -654,12 +666,16 @@ rt_err_t rt_hw_wifi_init(const char *spi_device_name, wifi_mode_t mode)
         rt_spi_configure(rw009_wifi_device.rt_spi_device, &cfg);
     }
 
+#ifdef RT_USING_DEVICE_OPS
+    rw009_wifi_device.parent.parent.ops        = &rw009_ops;
+#else
     rw009_wifi_device.parent.parent.init       = rw009_wifi_init;
     rw009_wifi_device.parent.parent.open       = rw009_wifi_open;
     rw009_wifi_device.parent.parent.close      = rw009_wifi_close;
     rw009_wifi_device.parent.parent.read       = rw009_wifi_read;
     rw009_wifi_device.parent.parent.write      = rw009_wifi_write;
     rw009_wifi_device.parent.parent.control    = rw009_wifi_control;
+#endif
     rw009_wifi_device.parent.parent.user_data  = RT_NULL;
 
     rw009_wifi_device.parent.eth_rx     = rw009_wifi_rx;

components/drivers/src/pipe.c

@@ -416,6 +416,18 @@ rt_err_t  rt_pipe_control(rt_device_t dev, int cmd, void *args)
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops pipe_ops = 
+{
+    RT_NULL,
+    rt_pipe_open,
+    rt_pipe_close,
+    rt_pipe_read,
+    rt_pipe_write,
+    rt_pipe_control,
+};
+#endif
+
 rt_pipe_t *rt_pipe_create(const char *name, int bufsz)
 {
     rt_pipe_t *pipe;
@@ -434,12 +446,16 @@ rt_pipe_t *rt_pipe_create(const char *name, int bufsz)
 
     dev = &(pipe->parent);
     dev->type = RT_Device_Class_Pipe;
+#ifdef RT_USING_DEVICE_OPS
+    dev->ops         = &pipe_ops;
+#else
     dev->init        = RT_NULL;
     dev->open        = rt_pipe_open;
     dev->read        = rt_pipe_read;
     dev->write       = rt_pipe_write;
     dev->close       = rt_pipe_close;
     dev->control     = rt_pipe_control;
+#endif
 
     dev->rx_indicate = RT_NULL;
     dev->tx_complete = RT_NULL;

components/drivers/usb/usbdevice/class/ecm.c

@@ -327,6 +327,19 @@ static rt_err_t rt_ecm_eth_control(rt_device_t dev, int cmd, void *args)
 
     return RT_EOK;
 }
+
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops ecm_device_ops =
+{
+    rt_ecm_eth_init,
+    rt_ecm_eth_open,
+    rt_ecm_eth_close,
+    rt_ecm_eth_read,
+    rt_ecm_eth_write,
+    rt_ecm_eth_control
+};
+#endif
+
 struct pbuf *rt_ecm_eth_rx(rt_device_t dev)
 {
     struct pbuf* p = RT_NULL;

components/drivers/usb/usbdevice/class/hid.c

@@ -592,14 +592,33 @@ static void hid_thread_entry(void* parameter)
 		HID_Report_Received(&report);
 	}
 }
+
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops hid_device_ops =
+{
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    _hid_write,
+    RT_NULL,
+};
+#endif
+
 static rt_uint8_t hid_mq_pool[(sizeof(struct hid_report)+sizeof(void*))*8];
 static void rt_usb_hid_init(struct ufunction *func)
 {
     struct hid_s *hiddev;
     hiddev = (struct hid_s *)func->user_data;
     rt_memset(&hiddev->parent, 0, sizeof(hiddev->parent));
+
+#ifdef RT_USING_DEVICE_OPS
+    hiddev->parent.ops   = &hid_device_ops;
+#else
     hiddev->parent.write = _hid_write;
+#endif
     hiddev->func = func;
+
     rt_device_register(&hiddev->parent, "hidd", RT_DEVICE_FLAG_RDWR);
     rt_mq_init(&hiddev->hid_mq, "hiddmq", hid_mq_pool, sizeof(struct hid_report),
                             sizeof(hid_mq_pool), RT_IPC_FLAG_FIFO);

components/drivers/usb/usbdevice/class/rndis.c

@@ -1180,6 +1180,19 @@ rt_err_t rt_rndis_eth_tx(rt_device_t dev, struct pbuf* p)
 
     return result;
 }
+
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops rndis_device_ops =
+{
+    rt_rndis_eth_init,
+    rt_rndis_eth_open,
+    rt_rndis_eth_close,
+    rt_rndis_eth_read,
+    rt_rndis_eth_write,
+    rt_rndis_eth_control
+};
+#endif
+
 #endif /* RT_USING_LWIP */
 
 #ifdef  RNDIS_DELAY_LINK_UP
@@ -1307,12 +1320,16 @@ ufunction_t rt_usbd_function_rndis_create(udevice_t device)
     _rndis->host_addr[4]                = 0xEA;//*(const rt_uint8_t *)(0x0FE081F1);
     _rndis->host_addr[5]                = 0x13;//*(const rt_uint8_t *)(0x0FE081F2);
 
+#ifdef RT_USING_DEVICE_OPS
+    _rndis->parent.parent.ops           = &rndis_device_ops;
+#else
     _rndis->parent.parent.init          = rt_rndis_eth_init;
     _rndis->parent.parent.open          = rt_rndis_eth_open;
     _rndis->parent.parent.close         = rt_rndis_eth_close;
     _rndis->parent.parent.read          = rt_rndis_eth_read;
     _rndis->parent.parent.write         = rt_rndis_eth_write;
     _rndis->parent.parent.control       = rt_rndis_eth_control;
+#endif
     _rndis->parent.parent.user_data     = device;
 
     _rndis->parent.eth_rx               = rt_rndis_eth_rx;

components/drivers/usb/usbdevice/class/winusb.c

@@ -246,16 +246,34 @@ static rt_err_t  win_usb_control(rt_device_t dev, int cmd, void *args)
     }
     return RT_EOK;
 }
+
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops winusb_device_ops =
+{
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    win_usb_read,
+    win_usb_write,
+    win_usb_control,
+};
+#endif
+
 static rt_err_t rt_usb_winusb_init(ufunction_t func)
 {
     winusb_device_t winusb_device   = (winusb_device_t)func->user_data;
     winusb_device->parent.type      = RT_Device_Class_Miscellaneous;
+
+#ifdef RT_USING_DEVICE_OPS
+    winusb_device->parent.ops       = &winusb_device_ops;
+#else
     winusb_device->parent.init      = RT_NULL;
     winusb_device->parent.open      = RT_NULL;
     winusb_device->parent.close     = RT_NULL;
     winusb_device->parent.read      = win_usb_read;
     winusb_device->parent.write     = win_usb_write;
     winusb_device->parent.control   = win_usb_control;
+#endif
 
     winusb_device->parent.user_data = func;
 

components/drivers/usb/usbhost/class/adk.c

@@ -209,6 +209,18 @@ static rt_size_t rt_usbh_adk_write (rt_device_t device, rt_off_t pos, const void
     return length;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops adk_device_ops =
+{
+    RT_NULL;
+    RT_NULL;
+    RT_NULL;
+    rt_usbh_adk_read;
+    rt_usbh_adk_write;
+    RT_NULL;
+};
+#endif
+
 /**
  * This function will run adk class driver when usb device is detected and identified
  *  as a adk class device, it will continue the enumulate process.
@@ -342,12 +354,16 @@ static rt_err_t rt_usbh_adk_enable(void* arg)
 
     /* register adk device */
     adk->device.type    = RT_Device_Class_Char;
+#ifdef RT_USING_DEVICE_OPS
+    adk->device.ops     = &adk_device_ops;
+#else
     adk->device.init    = RT_NULL;
     adk->device.open    = RT_NULL;
     adk->device.close   = RT_NULL;
     adk->device.read    = rt_usbh_adk_read;
     adk->device.write   = rt_usbh_adk_write;
     adk->device.control = RT_NULL;
+#endif
     adk->device.user_data = (void*)intf;
 
     rt_device_register(&adk->device, "adkdev", RT_DEVICE_FLAG_RDWR);

components/drivers/usb/usbhost/class/udisk.c

@@ -167,6 +167,18 @@ static rt_err_t rt_udisk_control(rt_device_t dev, int cmd, void *args)
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops udisk_device_ops =
+{
+    rt_udisk_init,
+    RT_NULL,
+    RT_NULL,
+    rt_udisk_read,
+    rt_udisk_write,
+    rt_udisk_control
+};
+#endif
+
 /**
  * This function will run udisk driver when usb disk is detected.
  *
@@ -312,10 +324,14 @@ rt_err_t rt_udisk_run(struct uhintf* intf)
 
             /* register sdcard device */
             stor->dev[i].type    = RT_Device_Class_Block;
+#ifdef RT_USING_DEVICE_OPS
+            stor->dev[i].ops     = &udisk_device_ops;
+#else
             stor->dev[i].init    = rt_udisk_init;
             stor->dev[i].read    = rt_udisk_read;
             stor->dev[i].write   = rt_udisk_write;
             stor->dev[i].control = rt_udisk_control;
+#endif
             stor->dev[i].user_data = (void*)data;
 
             rt_device_register(&stor->dev[i], dname, RT_DEVICE_FLAG_RDWR |
@@ -350,10 +366,14 @@ rt_err_t rt_udisk_run(struct uhintf* intf)
 
                 /* register sdcard device */
                 stor->dev[0].type    = RT_Device_Class_Block;
+#ifdef RT_USING_DEVICE_OPS
+                stor->dev[i].ops     = &udisk_device_ops;
+#else
                 stor->dev[0].init    = rt_udisk_init;
                 stor->dev[0].read    = rt_udisk_read;
                 stor->dev[0].write   = rt_udisk_write;
                 stor->dev[0].control = rt_udisk_control;
+#endif
                 stor->dev[0].user_data = (void*)data;
 
                 rt_device_register(&stor->dev[0], dname,

components/drivers/watchdog/watchdog.c

@@ -78,6 +78,18 @@ static rt_err_t rt_watchdog_control(struct rt_device *dev,
     return (wtd->ops->control(wtd, cmd, args));
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops wdt_ops = 
+{
+    rt_watchdog_init,
+    rt_watchdog_open,
+    rt_watchdog_close,
+    RT_NULL,
+    RT_NULL,
+    rt_watchdog_control,
+};
+#endif
+
 /**
  * This function register a watchdog device
  */
@@ -95,12 +107,16 @@ rt_err_t rt_hw_watchdog_register(struct rt_watchdog_device *wtd,
     device->rx_indicate = RT_NULL;
     device->tx_complete = RT_NULL;
 
+#ifdef RT_USING_DEVICE_OPS
+    device->ops         = &wdt_ops;
+#else
     device->init        = rt_watchdog_init;
     device->open        = rt_watchdog_open;
     device->close       = rt_watchdog_close;
     device->read        = RT_NULL;
     device->write       = RT_NULL;
     device->control     = rt_watchdog_control;
+#endif
     device->user_data   = data;
 
     /* register a character device */

components/libc/compilers/newlib/libc.c

@@ -35,6 +35,8 @@
 #include <pthread.h>
 #endif
 
+int	_EXFUN(putenv,(char *__string));
+
 int libc_system_init(void)
 {
 #if defined(RT_USING_DFS) & defined(RT_USING_DFS_DEVFS)

components/libc/compilers/newlib/stdio.c

@@ -31,6 +31,8 @@
 
 #define STDIO_DEVICE_NAME_MAX   32
 
+int	_EXFUN(fileno, (FILE *));
+
 static FILE* std_console = NULL;
 
 int libc_stdio_set_console(const char* device_name, int mode)

components/utilities/logtrace/log_file.c

@@ -112,6 +112,18 @@ static rt_err_t fdevice_control(rt_device_t dev, int cmd, void *arg)
     return RT_EOK;
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops log_trace_ops = 
+{
+    RT_NULL,
+    fdevice_open,
+    fdevice_close,
+    RT_NULL,
+    fdevice_write,
+    fdevice_control
+};
+#endif
+
 void log_trace_file_init(const char *filename)
 {
     rt_device_t device;
@@ -123,11 +135,15 @@ void log_trace_file_init(const char *filename)
 
         _file_device.parent.type  = RT_Device_Class_Char;
 
+#ifdef RT_USING_DEVICE_OPS
+        _file_device.parent.ops     = &log_trace_ops;
+#else
         _file_device.parent.init    = RT_NULL;
         _file_device.parent.open    = fdevice_open;
         _file_device.parent.close   = fdevice_close;
         _file_device.parent.write   = fdevice_write;
         _file_device.parent.control = fdevice_control;
+#endif
 
         rt_device_register(&_file_device.parent, "logfile", O_RDWR);
     }

components/utilities/logtrace/log_trace.c

@@ -383,17 +383,33 @@ static rt_err_t _log_control(rt_device_t dev, int cmd, void *arg)
     return rt_device_control(_traceout_device, cmd, arg);
 }
 
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops log_device_ops = 
+{
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    RT_NULL,
+    _log_write,
+    _log_control
+};
+#endif
+
 int log_trace_init(void)
 {
     rt_memset(&_log_device, 0x00, sizeof(_log_device));
 
     _log_device.type = RT_Device_Class_Char;
+#ifdef RT_USING_DEVICE_OPS
+    _log_device.ops     = &log_device_ops;
+#else
     _log_device.init    = RT_NULL;
     _log_device.open    = RT_NULL;
     _log_device.close   = RT_NULL;
     _log_device.read    = RT_NULL;
     _log_device.write   = _log_write;
     _log_device.control = _log_control;
+#endif
 
     /* no indication and complete callback */
     _log_device.rx_indicate = RT_NULL;

include/rtdef.h

@@ -848,6 +848,17 @@ enum rt_device_class_type
 #define RT_DEVICE_CTRL_RTC_SET_ALARM    0x13            /**< set alarm */
 
 typedef struct rt_device *rt_device_t;
+struct rt_device_ops
+{
+    /* common device interface */
+    rt_err_t  (*init)   (rt_device_t dev);
+    rt_err_t  (*open)   (rt_device_t dev, rt_uint16_t oflag);
+    rt_err_t  (*close)  (rt_device_t dev);
+    rt_size_t (*read)   (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
+    rt_size_t (*write)  (rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
+    rt_err_t  (*control)(rt_device_t dev, int cmd, void *args);
+};
+
 /**
  * Device structure
  */
@@ -866,6 +877,9 @@ struct rt_device
     rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
     rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);
 
+#ifdef RT_USING_DEVICE_OPS
+    const struct rt_device_ops *ops;
+#else
     /* common device interface */
     rt_err_t  (*init)   (rt_device_t dev);
     rt_err_t  (*open)   (rt_device_t dev, rt_uint16_t oflag);
@@ -873,6 +887,7 @@ struct rt_device
     rt_size_t (*read)   (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
     rt_size_t (*write)  (rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
     rt_err_t  (*control)(rt_device_t dev, int cmd, void *args);
+#endif
 
 #if defined(RT_USING_POSIX)
     const struct dfs_file_ops *fops;
@@ -1030,8 +1045,8 @@ struct rt_module
 
     rt_uint32_t                  user_data;             /**< arch data in the module */
 
-    /* object in this module, module object is the last basic object type */
-    struct rt_object_information module_object[RT_Object_Class_Unknown];
+    void (*module_init)(void);
+    void (*module_cleanup)(void);
 };
 typedef struct rt_module *rt_module_t;
 

src/Kconfig

@@ -192,6 +192,10 @@ menu "Kernel Device Object"
         bool "Using device object"
         default y
 
+    config RT_USING_DEVICE_OPS
+        bool "Using ops for each device object"
+        default n
+
     config RT_USING_INTERRUPT_INFO
         bool "Enable additional interrupt trace information"
         default n

src/device.c

@@ -32,12 +32,28 @@
 
 #ifdef RT_USING_DEVICE
 
+#ifdef RT_USING_DEVICE_OPS
+#define device_init     (dev->ops->init)
+#define device_open     (dev->ops->open)
+#define device_close    (dev->ops->close)
+#define device_read     (dev->ops->read)
+#define device_write    (dev->ops->write)
+#define device_control  (dev->ops->control)
+#else
+#define device_init     (dev->init)
+#define device_open     (dev->open)
+#define device_close    (dev->close)
+#define device_read     (dev->read)
+#define device_write    (dev->write)
+#define device_control  (dev->control)
+#endif
+
 /**
  * This function registers a device driver with specified name.
  *
  * @param dev the pointer of device driver structure
  * @param name the device driver's name
- * @param flags the flag of device
+ * @param flags the capabilities flag of device
  *
  * @return the error code, RT_EOK on initialization successfully.
  */
@@ -154,6 +170,8 @@ rt_device_t rt_device_create(int type, int attach_size)
     rt_device_t device;
 
     size = RT_ALIGN(sizeof(struct rt_device), RT_ALIGN_SIZE);
+    attach_size = RT_ALIGN(attach_size, RT_ALIGN_SIZE);
+    /* use the totoal size */
     size += attach_size;
 
     device = (rt_device_t)rt_malloc(size);
@@ -197,11 +215,11 @@ rt_err_t rt_device_init(rt_device_t dev)
     RT_ASSERT(dev != RT_NULL);
 
     /* get device init handler */
-    if (dev->init != RT_NULL)
+    if (device_init != RT_NULL)
     {
         if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
         {
-            result = dev->init(dev);
+            result = device_init(dev);
             if (result != RT_EOK)
             {
                 rt_kprintf("To initialize device:%s failed. The error code is %d\n",
@@ -234,9 +252,9 @@ rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag)
     /* if device is not initialized, initialize it. */
     if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
     {
-        if (dev->init != RT_NULL)
+        if (device_init != RT_NULL)
         {
-            result = dev->init(dev);
+            result = device_init(dev);
             if (result != RT_EOK)
             {
                 rt_kprintf("To initialize device:%s failed. The error code is %d\n",
@@ -257,9 +275,9 @@ rt_err_t rt_device_open(rt_device_t dev, rt_uint16_t oflag)
     }
 
     /* call device open interface */
-    if (dev->open != RT_NULL)
+    if (device_open != RT_NULL)
     {
-        result = dev->open(dev, oflag);
+        result = device_open(dev, oflag);
     }
     else
     {
@@ -304,9 +322,9 @@ rt_err_t rt_device_close(rt_device_t dev)
         return RT_EOK;
 
     /* call device close interface */
-    if (dev->close != RT_NULL)
+    if (device_close != RT_NULL)
     {
-        result = dev->close(dev);
+        result = device_close(dev);
     }
 
     /* set open flag */
@@ -343,9 +361,9 @@ rt_size_t rt_device_read(rt_device_t dev,
     }
 
     /* call device read interface */
-    if (dev->read != RT_NULL)
+    if (device_read != RT_NULL)
     {
-        return dev->read(dev, pos, buffer, size);
+        return device_read(dev, pos, buffer, size);
     }
 
     /* set error code */
@@ -381,9 +399,9 @@ rt_size_t rt_device_write(rt_device_t dev,
     }
 
     /* call device write interface */
-    if (dev->write != RT_NULL)
+    if (device_write != RT_NULL)
     {
-        return dev->write(dev, pos, buffer, size);
+        return device_write(dev, pos, buffer, size);
     }
 
     /* set error code */
@@ -407,9 +425,9 @@ rt_err_t rt_device_control(rt_device_t dev, int cmd, void *arg)
     RT_ASSERT(dev != RT_NULL);
 
     /* call device write interface */
-    if (dev->control != RT_NULL)
+    if (device_control != RT_NULL)
     {
-        return dev->control(dev, cmd, arg);
+        return device_control(dev, cmd, arg);
     }
 
     return -RT_ENOSYS;