diff --git a/bsp/qemu-vexpress-a9/drivers/drv_clcd.c b/bsp/qemu-vexpress-a9/drivers/drv_clcd.c index 543924e7181d97afe7a1391351b31cc6363fd807..4444d338c33b514c8fcc207930b06d88364d3231 100644 --- a/bsp/qemu-vexpress-a9/drivers/drv_clcd.c +++ b/bsp/qemu-vexpress-a9/drivers/drv_clcd.c @@ -5,8 +5,8 @@ #include #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; diff --git a/bsp/qemu-vexpress-a9/drivers/drv_smc911x.c b/bsp/qemu-vexpress-a9/drivers/drv_smc911x.c index a5a7df3b0690e32d7e25da0bfee29819758ddb7e..4b33cc42157692abc4dc4e1daeda7abb619665f2 100644 --- a/bsp/qemu-vexpress-a9/drivers/drv_smc911x.c +++ b/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 -int emac(int argc, char** argv) -{ - rt_hw_interrupt_umask(_emac.irqno); - - return 0; -} -MSH_CMD_EXPORT(emac, emac dump); diff --git a/components/drivers/audio/audio.c b/components/drivers/audio/audio.c index 87bb7260580fef7227192c99ac1d34eee0e9aeeb..220a000df1a9acf0b838884c0cc74fa96c7b78f1 100644 --- a/components/drivers/audio/audio.c +++ b/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; - 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; +#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 diff --git a/components/drivers/audio/audio_pipe.c b/components/drivers/audio/audio_pipe.c index abef1557a4754c7dd26430cdd93cb695238033fe..9dc296831ee18d47dc80a6fbeaed9475209ce9ec 100644 --- a/components/drivers/audio/audio_pipe.c +++ b/components/drivers/audio/audio_pipe.c @@ -193,14 +193,26 @@ static rt_size_t rt_pipe_write(rt_device_t dev, static rt_err_t rt_pipe_control(rt_device_t dev, int cmd, void *args) { struct rt_audio_pipe *pipe; - + pipe = (struct rt_audio_pipe *)dev; - + if (cmd == PIPE_CTRL_GET_SPACE && args) *(rt_size_t*)args = rt_ringbuffer_space_len(&pipe->ringbuffer); 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); } diff --git a/components/drivers/can/can.c b/components/drivers/can/can.c index 000745514c3e110b887b00f5b50ffc87a23c472a..98d76cd5b306f8ae308d580c4feaf0c8ddc92551 100644 --- a/components/drivers/can/can.c +++ b/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; diff --git a/components/drivers/hwtimer/hwtimer.c b/components/drivers/hwtimer/hwtimer.c index 066c5f6f6c6c0fbf21a26d449507e7b55e946577..c3e50763432fd28675ec72b49e694cb36ecdf416 100644 --- a/components/drivers/hwtimer/hwtimer.c +++ b/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); diff --git a/components/drivers/i2c/fm24clxx.c b/components/drivers/i2c/fm24clxx.c index c37a62973a5e7284d18bcc4017e491dad59b2a12..bb77d707bf318727d822a1e4877248a414548caa 100644 --- a/components/drivers/i2c/fm24clxx.c +++ b/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); diff --git a/components/drivers/i2c/i2c_dev.c b/components/drivers/i2c/i2c_dev.c index 5713a289365ab188b303b1c8da1e3d9ba72b6cd6..042b7b743a5dcbf0d940674deddbff4a1680c9be 100644 --- a/components/drivers/i2c/i2c_dev.c +++ b/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); diff --git a/components/drivers/misc/pin.c b/components/drivers/misc/pin.c index 9ed827f0b59e8f57930565b00f81ca713e16212b..dc2137eb17d65c40720d0fb91bdf084092deccd7 100644 --- a/components/drivers/misc/pin.c +++ b/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) { diff --git a/components/drivers/mtd/mtd_nand.c b/components/drivers/mtd/mtd_nand.c index 8cd0a03d5d382a838eeded46f0bbcbd55d305ca9..bf22d889ce56a19b021f0388983b05d18e3e6820 100644 --- a/components/drivers/mtd/mtd_nand.c +++ b/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; diff --git a/components/drivers/mtd/mtd_nor.c b/components/drivers/mtd/mtd_nor.c index 72bbc5a87321576cbbfe710131bc369393189ee7..8f37e95f0944a339fd178c603c665970defb4ded 100644 --- a/components/drivers/mtd/mtd_nor.c +++ b/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; diff --git a/components/drivers/rtc/soft_rtc.c b/components/drivers/rtc/soft_rtc.c index 6db2136ad4b11567f9da32b41da307b438abd116..c828e43ebcf16c4a524d0f1c83e14e3c36413c17 100644 --- a/components/drivers/rtc/soft_rtc.c +++ b/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; diff --git a/components/drivers/sdio/block_dev.c b/components/drivers/sdio/block_dev.c index 4143272b80cc2d026f597265048c26fbd709e4a2..14a01acd90051b816343a57254f8623cfed1b479 100644 --- a/components/drivers/sdio/block_dev.c +++ b/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; @@ -366,13 +378,17 @@ rt_int32_t rt_mmcsd_blk_probe(struct rt_mmcsd_card *card) blk_dev->part.lock = rt_sem_create(sname, 1, RT_IPC_FLAG_FIFO); /* register mmcsd device */ - blk_dev->dev.type = RT_Device_Class_Block; + 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); - diff --git a/components/drivers/serial/serial.c b/components/drivers/serial/serial.c index 645d083283ccb1edd91a3a16bbbdacf5c18ae578..1de13313446d20d204d080fcd77c451d92806516 100644 --- a/components/drivers/serial/serial.c +++ b/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 */ diff --git a/components/drivers/spi/enc28j60.c b/components/drivers/spi/enc28j60.c index 1daaea367a954de40fd3613aada8bbc4eff7d5f4..b37b2244e599e90279daf120b968a49f0e4414bf 100644 --- a/components/drivers/spi/enc28j60.c +++ b/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; diff --git a/components/drivers/spi/spi_dev.c b/components/drivers/spi/spi_dev.c index eca971a6e75b7223c740724ccd86ea61d437ba0c..1e69ebe59106d53f02137b285e25ffa36b27f2b5 100644 --- a/components/drivers/spi/spi_dev.c +++ b/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,13 +171,17 @@ 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); } diff --git a/components/drivers/spi/spi_flash_gd.c b/components/drivers/spi/spi_flash_gd.c index df41150a5d9115327334999228642fd368e02478..a8e8f9a4b831a41a4382cb0acca8304fe7f58650 100644 --- a/components/drivers/spi/spi_flash_gd.c +++ b/components/drivers/spi/spi_flash_gd.c @@ -1,7 +1,7 @@ /* * File : spi_flash_gd.c * This file is part of RT-Thread RTOS - * Copyright (c) 2016 Shanghai Fullhan Microelectronics Co., Ltd. + * Copyright (c) 2016 Shanghai Fullhan Microelectronics Co., Ltd. * All rights reserved * * This program is free software; you can redistribute it and/or modify @@ -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; diff --git a/components/drivers/spi/spi_flash_sfud.c b/components/drivers/spi/spi_flash_sfud.c index 2e97644fa4764d79b97724e89a87fd3bf6f37c8e..c4fd1e0208e0175125814a6c018426b37d35057d 100644 --- a/components/drivers/spi/spi_flash_sfud.c +++ b/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. * @@ -255,7 +267,7 @@ rt_spi_flash_device_t rt_sfud_flash_probe(const char *spi_flash_dev_name, const /* initialize lock */ rt_mutex_init(&(rtt_dev->lock), spi_flash_dev_name, RT_IPC_FLAG_FIFO); } - + if (rtt_dev && sfud_dev && spi_flash_dev_name_bak && spi_dev_name_bak) { rt_memset(sfud_dev, 0, sizeof(sfud_flash)); rt_strncpy(spi_flash_dev_name_bak, spi_flash_dev_name, rt_strlen(spi_flash_dev_name)); @@ -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); diff --git a/components/drivers/spi/spi_flash_sst25vfxx.c b/components/drivers/spi/spi_flash_sst25vfxx.c index 3843d20ff27a9b214affa0cb116ac4c77090b03a..35dcf3fff702d6fee6ee780741404850ec16c6d5 100644 --- a/components/drivers/spi/spi_flash_sst25vfxx.c +++ b/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; diff --git a/components/drivers/spi/spi_flash_w25qxx.c b/components/drivers/spi/spi_flash_w25qxx.c index a413aec673b417f4ddc7949d075c17381f5c783b..5a16ffbae20076a52f2f563bfffa777cffee30a8 100644 --- a/components/drivers/spi/spi_flash_w25qxx.c +++ b/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; diff --git a/components/drivers/spi/spi_msd.c b/components/drivers/spi/spi_msd.c index 5e9ae6289e0df41553f0ef350ce29e354eef9e26..a3046e14ba5281d163c249b9f4d38b1d8af17283 100644 --- a/components/drivers/spi/spi_msd.c +++ b/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; diff --git a/components/drivers/spi/spi_wifi_rw009.c b/components/drivers/spi/spi_wifi_rw009.c index 5fb36f33cf5f006fb2b0e9523557c3e1ddd8f3ae..0b92802383494657a138027a254525643a6262e8 100644 --- a/components/drivers/spi/spi_wifi_rw009.c +++ b/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; diff --git a/components/drivers/src/pipe.c b/components/drivers/src/pipe.c index ee9c8ba02a331792229ab276a8eb15ee4b290f36..09264ffbe3661ffe681594512e2180d22c587ecd 100644 --- a/components/drivers/src/pipe.c +++ b/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; diff --git a/components/drivers/usb/usbdevice/class/ecm.c b/components/drivers/usb/usbdevice/class/ecm.c index 0711de3f516c81ee49841ca118b6536cf7460cb5..6f19a0099ebbb7624b4a5ff8b1dc73c0e487b02b 100644 --- a/components/drivers/usb/usbdevice/class/ecm.c +++ b/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; diff --git a/components/drivers/usb/usbdevice/class/hid.c b/components/drivers/usb/usbdevice/class/hid.c index 29e581d62b6c7cc45185f8f80955a64cb1446c71..fe1050e3efb4617d9b1c3f77d86df741cb1d6f2c 100644 --- a/components/drivers/usb/usbdevice/class/hid.c +++ b/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; - hiddev->func = func; +#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); diff --git a/components/drivers/usb/usbdevice/class/rndis.c b/components/drivers/usb/usbdevice/class/rndis.c index 7e67b28bef9b1e6c2ccd45255a7edfca312bf0eb..0f680e9066d347c15404cf61773e19862fe23661 100644 --- a/components/drivers/usb/usbdevice/class/rndis.c +++ b/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,20 +1320,24 @@ 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; _rndis->parent.eth_tx = rt_rndis_eth_tx; - /* register eth device */ + /* register eth device */ eth_device_init(&((rt_rndis_eth_t)cdc->user_data)->parent, "u0"); - + #endif /* RT_USING_LWIP */ return cdc; diff --git a/components/drivers/usb/usbdevice/class/winusb.c b/components/drivers/usb/usbdevice/class/winusb.c index 71d946fcd962c8c9ca977227bbc565014e09fe72..9e7c957e7c2851f15741865d2e808ef4c6f7a7a4 100644 --- a/components/drivers/usb/usbdevice/class/winusb.c +++ b/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; diff --git a/components/drivers/usb/usbhost/class/adk.c b/components/drivers/usb/usbhost/class/adk.c index 1481d27ea6df1357fa1126b94e989225f26ce84d..e7eed45127f5c49ff97479ecdd35343c21c4d2a9 100644 --- a/components/drivers/usb/usbhost/class/adk.c +++ b/components/drivers/usb/usbhost/class/adk.c @@ -37,7 +37,7 @@ static const char* _adk_uri = RT_NULL; static const char* _adk_serial = RT_NULL; rt_err_t rt_usbh_adk_set_string(const char* manufacturer, const char* model, - const char* description, const char* _version, const char* uri, + const char* description, const char* _version, const char* uri, const char* serial) { _adk_manufacturer = manufacturer; @@ -62,31 +62,31 @@ RTM_EXPORT(rt_usbh_adk_set_string); * @param intf the interface instance. * @duration the idle period of requesting data. * @report_id the report id - * + * * @return the error code, RT_EOK on successfully. */ static rt_err_t rt_usbh_adk_get_protocol(struct uintf* intf, rt_uint16_t *protocol) { struct urequest setup; - uinst_t device; + uinst_t device; int timeout = 100; - + /* parameter check */ RT_ASSERT(intf != RT_NULL); RT_ASSERT(intf->device != RT_NULL); device = intf->device; - setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_VENDOR | + setup.request_type = USB_REQ_TYPE_DIR_IN | USB_REQ_TYPE_VENDOR | USB_REQ_TYPE_DEVICE; setup.request = USB_REQ_GET_PROTOCOL; setup.index = 0; setup.length = 2; setup.value = 0; - if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, (void*)protocol, 2, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, (void*)protocol, 2, timeout) == 0) return RT_EOK; - else return -RT_FALSE; + else return -RT_FALSE; } /** @@ -95,32 +95,32 @@ static rt_err_t rt_usbh_adk_get_protocol(struct uintf* intf, rt_uint16_t *protoc * @param intf the interface instance. * @duration the idle period of requesting data. * @report_id the report id - * + * * @return the error code, RT_EOK on successfully. */ -static rt_err_t rt_usbh_adk_send_string(struct uintf* intf, rt_uint16_t index, +static rt_err_t rt_usbh_adk_send_string(struct uintf* intf, rt_uint16_t index, const char* str) { struct urequest setup; - uinst_t device; + uinst_t device; int timeout = 100; - + /* parameter check */ RT_ASSERT(intf != RT_NULL); RT_ASSERT(intf->device != RT_NULL); device = intf->device; - setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_VENDOR | + setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_VENDOR | USB_REQ_TYPE_DEVICE; setup.request = USB_REQ_SEND_STRING; setup.index = index; setup.length = rt_strlen(str) + 1; setup.value = 0; - if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, (void*)str, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, (void*)str, rt_strlen(str) + 1, timeout) == 0) return RT_EOK; - else return -RT_FALSE; + else return -RT_FALSE; } /** @@ -129,41 +129,41 @@ static rt_err_t rt_usbh_adk_send_string(struct uintf* intf, rt_uint16_t index, * @param intf the interface instance. * @duration the idle period of requesting data. * @report_id the report id - * + * * @return the error code, RT_EOK on successfully. */ static rt_err_t rt_usbh_adk_start(struct uintf* intf) { struct urequest setup; - uinst_t device; + uinst_t device; int timeout = 100; - + /* parameter check */ RT_ASSERT(intf != RT_NULL); RT_ASSERT(intf->device != RT_NULL); device = intf->device; - setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_VENDOR | + setup.request_type = USB_REQ_TYPE_DIR_OUT | USB_REQ_TYPE_VENDOR | USB_REQ_TYPE_DEVICE; setup.request = USB_REQ_START; setup.index = 0; setup.length = 0; setup.value = 0; - if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, + if(rt_usb_hcd_control_xfer(device->hcd, device, &setup, RT_NULL, 0, timeout) == 0) return RT_EOK; - else return -RT_FALSE; + else return -RT_FALSE; } /** * This function will read data from usb adk device * * @param intf the interface instance. - * + * * @return the error code, RT_EOK on successfully. */ -static rt_size_t rt_usbh_adk_read(rt_device_t device, rt_off_t pos, void* buffer, +static rt_size_t rt_usbh_adk_read(rt_device_t device, rt_off_t pos, void* buffer, rt_size_t size) { uadk_t adk; @@ -177,9 +177,9 @@ static rt_size_t rt_usbh_adk_read(rt_device_t device, rt_off_t pos, void* buffer intf = (struct uintf*)device->user_data; adk = (uadk_t)intf->user_data; - length = rt_usb_hcd_bulk_xfer(intf->device->hcd, adk->pipe_in, + length = rt_usb_hcd_bulk_xfer(intf->device->hcd, adk->pipe_in, buffer, size, 300); - + return length; } @@ -188,33 +188,45 @@ static rt_size_t rt_usbh_adk_read(rt_device_t device, rt_off_t pos, void* buffer * This function will write data to usb adk device * * @param intf the interface instance. - * + * * @return the error code, RT_EOK on successfully. */ -static rt_size_t rt_usbh_adk_write (rt_device_t device, rt_off_t pos, const void* buffer, +static rt_size_t rt_usbh_adk_write (rt_device_t device, rt_off_t pos, const void* buffer, rt_size_t size) { uadk_t adk; rt_size_t length; struct uintf* intf; - RT_ASSERT(buffer != RT_NULL); + RT_ASSERT(buffer != RT_NULL); intf = (struct uintf*)device->user_data; adk = (uadk_t)intf->user_data; - length = rt_usb_hcd_bulk_xfer(intf->device->hcd, adk->pipe_out, + length = rt_usb_hcd_bulk_xfer(intf->device->hcd, adk->pipe_out, (void*)buffer, size, 300); - + 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. * * @param arg the argument. - * + * * @return the error code, RT_EOK on successfully. */ static rt_err_t rt_usbh_adk_enable(void* arg) @@ -224,8 +236,8 @@ static rt_err_t rt_usbh_adk_enable(void* arg) struct uintf* intf = (struct uintf*)arg; udev_desc_t dev_desc; rt_uint16_t protocol; - rt_err_t ret; - + rt_err_t ret; + /* parameter check */ if(intf == RT_NULL) { @@ -234,72 +246,72 @@ static rt_err_t rt_usbh_adk_enable(void* arg) } RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_adk_run\n")); - + dev_desc = &intf->device->dev_desc; - if(dev_desc->idVendor == USB_ACCESSORY_VENDOR_ID && - (dev_desc->idProduct == USB_ACCESSORY_PRODUCT_ID || + if(dev_desc->idVendor == USB_ACCESSORY_VENDOR_ID && + (dev_desc->idProduct == USB_ACCESSORY_PRODUCT_ID || dev_desc->idProduct == USB_ACCESSORY_ADB_PRODUCT_ID)) { if(intf->intf_desc->bInterfaceSubClass != 0xFF) return -RT_ERROR; - - RT_DEBUG_LOG(RT_DEBUG_USB, ("found android accessory device\n")); + + RT_DEBUG_LOG(RT_DEBUG_USB, ("found android accessory device\n")); } else { - RT_DEBUG_LOG(RT_DEBUG_USB, ("switch device\n")); - + RT_DEBUG_LOG(RT_DEBUG_USB, ("switch device\n")); + if((ret = rt_usbh_adk_get_protocol(intf, &protocol)) != RT_EOK) { rt_kprintf("rt_usbh_adk_get_protocol failed\n"); return ret; } - if(protocol != 1) + if(protocol != 1) { rt_kprintf("read protocol failed\n"); return -RT_ERROR; - } + } - rt_usbh_adk_send_string(intf, + rt_usbh_adk_send_string(intf, ACCESSORY_STRING_MANUFACTURER, _adk_manufacturer); - rt_usbh_adk_send_string(intf, + rt_usbh_adk_send_string(intf, ACCESSORY_STRING_MODEL, _adk_model); - rt_usbh_adk_send_string(intf, + rt_usbh_adk_send_string(intf, ACCESSORY_STRING_DESCRIPTION, _adk_description); - rt_usbh_adk_send_string(intf, + rt_usbh_adk_send_string(intf, ACCESSORY_STRING_VERSION, _adk_version); - rt_usbh_adk_send_string(intf, - ACCESSORY_STRING_URI, _adk_uri); - rt_usbh_adk_send_string(intf, - ACCESSORY_STRING_SERIAL, _adk_serial); + rt_usbh_adk_send_string(intf, + ACCESSORY_STRING_URI, _adk_uri); + rt_usbh_adk_send_string(intf, + ACCESSORY_STRING_SERIAL, _adk_serial); RT_DEBUG_LOG(RT_DEBUG_USB, ("manufacturer %s\n", _adk_manufacturer)); RT_DEBUG_LOG(RT_DEBUG_USB, ("model %s\n", _adk_model)); RT_DEBUG_LOG(RT_DEBUG_USB, ("description %s\n", _adk_description)); RT_DEBUG_LOG(RT_DEBUG_USB, ("version %s\n", _adk_version)); - RT_DEBUG_LOG(RT_DEBUG_USB, ("uri %s\n", _adk_uri)); - RT_DEBUG_LOG(RT_DEBUG_USB, ("serial %s\n", _adk_serial)); - + RT_DEBUG_LOG(RT_DEBUG_USB, ("uri %s\n", _adk_uri)); + RT_DEBUG_LOG(RT_DEBUG_USB, ("serial %s\n", _adk_serial)); + if((ret = rt_usbh_adk_start(intf)) != RT_EOK) { rt_kprintf("rt_usbh_adk_start failed\n"); return ret; - } + } return RT_EOK; } - + adk = rt_malloc(sizeof(struct uadkinst)); RT_ASSERT(adk != RT_NULL); /* initilize the data structure */ - rt_memset(adk, 0, sizeof(struct uadkinst)); + rt_memset(adk, 0, sizeof(struct uadkinst)); intf->user_data = (void*)adk; for(i=0; iintf_desc->bNumEndpoints; i++) - { + { uep_desc_t ep_desc; - + /* get endpoint descriptor from interface descriptor */ rt_usbh_get_endpoint_descriptor(intf->intf_desc, i, &ep_desc); if(ep_desc == RT_NULL) @@ -307,24 +319,24 @@ static rt_err_t rt_usbh_adk_enable(void* arg) rt_kprintf("rt_usb_get_endpoint_descriptor error\n"); return -RT_ERROR; } - - /* the endpoint type of adk class should be BULK */ + + /* the endpoint type of adk class should be BULK */ if((ep_desc->bmAttributes & USB_EP_ATTR_TYPE_MASK) != USB_EP_ATTR_BULK) continue; - + /* allocate pipes according to the endpoint type */ if(ep_desc->bEndpointAddress & USB_DIR_IN) { /* allocate an in pipe for the adk instance */ - ret = rt_usb_hcd_alloc_pipe(intf->device->hcd, &adk->pipe_in, + ret = rt_usb_hcd_alloc_pipe(intf->device->hcd, &adk->pipe_in, intf, ep_desc, RT_NULL); if(ret != RT_EOK) return ret; } else - { + { /* allocate an output pipe for the adk instance */ - ret = rt_usb_hcd_alloc_pipe(intf->device->hcd, &adk->pipe_out, - intf, ep_desc, RT_NULL); + ret = rt_usb_hcd_alloc_pipe(intf->device->hcd, &adk->pipe_out, + intf, ep_desc, RT_NULL); if(ret != RT_EOK) return ret; } } @@ -334,33 +346,37 @@ static rt_err_t rt_usbh_adk_enable(void* arg) { rt_kprintf("pipe error, unsupported device\n"); return -RT_ERROR; - } + } /* set configuration */ ret = rt_usbh_set_configure(intf->device, 1); if(ret != RT_EOK) return ret; /* register adk device */ - adk->device.type = RT_Device_Class_Char; - 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.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); - + return RT_EOK; } /** - * This function will be invoked when usb device plug out is detected and it would clean + * This function will be invoked when usb device plug out is detected and it would clean * and release all hub class related resources. * * @param arg the argument. - * + * * @return the error code, RT_EOK on successfully. */ static rt_err_t rt_usbh_adk_disable(void* arg) @@ -373,12 +389,12 @@ static rt_err_t rt_usbh_adk_disable(void* arg) RT_DEBUG_LOG(RT_DEBUG_USB, ("rt_usbh_adk_stop\n")); adk = (uadk_t)intf->user_data; - if(adk == RT_NULL) + if(adk == RT_NULL) { - rt_free(intf); + rt_free(intf); return RT_EOK; } - + if(adk->pipe_in != RT_NULL) rt_usb_hcd_free_pipe(intf->device->hcd, adk->pipe_in); @@ -389,11 +405,11 @@ static rt_err_t rt_usbh_adk_disable(void* arg) rt_device_unregister(&adk->device); /* free adk instance */ - if(adk != RT_NULL) + if(adk != RT_NULL) { rt_free(adk); } - + /* free interface instance */ rt_free(intf); @@ -403,13 +419,13 @@ static rt_err_t rt_usbh_adk_disable(void* arg) /** * This function will register adk class driver to the usb class driver manager. * and it should be invoked in the usb system initialization. - * + * * @return the error code, RT_EOK on successfully. */ ucd_t rt_usbh_class_driver_adk(void) { adk_driver.class_code = USB_CLASS_ADK; - + adk_driver.enable = rt_usbh_adk_enable; adk_driver.disable = rt_usbh_adk_disable; diff --git a/components/drivers/usb/usbhost/class/udisk.c b/components/drivers/usb/usbhost/class/udisk.c index f8f47890f45bd4a8b0143365cc7ea6d8d44b13c9..cdd2551c96f9f5482ec70798d127373eaca23b43 100644 --- a/components/drivers/usb/usbhost/class/udisk.c +++ b/components/drivers/usb/usbhost/class/udisk.c @@ -31,7 +31,7 @@ static int udisk_get_id(void) if((_udisk_idset & (1 << i)) != 0) continue; else break; } - + /* it should not happen */ if(i == UDISK_MAX_COUNT) RT_ASSERT(0); @@ -43,14 +43,14 @@ static void udisk_free_id(int id) { RT_ASSERT(id < UDISK_MAX_COUNT) - _udisk_idset &= ~(1 << id); + _udisk_idset &= ~(1 << id); } /** * This function will initialize the udisk device * * @param dev the pointer of device driver structure - * + * * @return RT_EOK */ static rt_err_t rt_udisk_init(rt_device_t dev) @@ -68,7 +68,7 @@ static rt_err_t rt_udisk_init(rt_device_t dev) * * @return the actually read size on successful, otherwise negative returned. */ -static rt_size_t rt_udisk_read(rt_device_t dev, rt_off_t pos, void* buffer, +static rt_size_t rt_udisk_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size) { rt_err_t ret; @@ -81,18 +81,18 @@ static rt_size_t rt_udisk_read(rt_device_t dev, rt_off_t pos, void* buffer, RT_ASSERT(buffer != RT_NULL); if(size > 4096) timeout = 800; - + data = (struct ustor_data*)dev->user_data; intf = data->intf; ret = rt_usbh_storage_read10(intf, (rt_uint8_t*)buffer, pos, size, timeout); - + if (ret != RT_EOK) { rt_kprintf("usb mass_storage read failed\n"); return 0; } - + return size; } @@ -106,7 +106,7 @@ static rt_size_t rt_udisk_read(rt_device_t dev, rt_off_t pos, void* buffer, * * @return the actually written size on successful, otherwise negative returned. */ -static rt_size_t rt_udisk_write (rt_device_t dev, rt_off_t pos, const void* buffer, +static rt_size_t rt_udisk_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size) { rt_err_t ret; @@ -129,7 +129,7 @@ static rt_size_t rt_udisk_write (rt_device_t dev, rt_off_t pos, const void* buff rt_kprintf("usb mass_storage write %d sector failed\n", size); return 0; } - + return size; } @@ -138,9 +138,9 @@ static rt_size_t rt_udisk_write (rt_device_t dev, rt_off_t pos, const void* buff * * @param intf the interface instance. * @param buffer the data buffer to save inquiry data - * + * * @return the error code, RT_EOK on successfully. - */ + */ static rt_err_t rt_udisk_control(rt_device_t dev, int cmd, void *args) { ustor_t stor; @@ -164,14 +164,26 @@ static rt_err_t rt_udisk_control(rt_device_t dev, int cmd, void *args) geometry->sector_count = stor->capicity[0]; } - return RT_EOK; + 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. * * @param intf the usb interface instance. - * + * * @return the error code, RT_EOK on successfully. */ rt_err_t rt_udisk_run(struct uhintf* intf) @@ -179,10 +191,10 @@ rt_err_t rt_udisk_run(struct uhintf* intf) int i = 0; rt_err_t ret; char dname[4]; - char sname[8]; + char sname[8]; rt_uint8_t max_lun, *sector, sense[18], inquiry[36]; - struct dfs_partition part[MAX_PARTITION_COUNT]; - ustor_t stor; + struct dfs_partition part[MAX_PARTITION_COUNT]; + ustor_t stor; /* check parameter */ RT_ASSERT(intf != RT_NULL); @@ -193,40 +205,40 @@ rt_err_t rt_udisk_run(struct uhintf* intf) // rt_usbh_clear_feature(intf->device, 0, USB_FEATURE_ENDPOINT_HALT); /* reset mass storage class device */ ret = rt_usbh_storage_reset(intf); - if(ret != RT_EOK) return ret; + if(ret != RT_EOK) return ret; stor = (ustor_t)intf->user_data; - /* get max logic unit number */ + /* get max logic unit number */ ret = rt_usbh_storage_get_max_lun(intf, &max_lun); - if(ret != RT_EOK) + if(ret != RT_EOK) rt_usbh_clear_feature(intf->device, 0, USB_FEATURE_ENDPOINT_HALT); /* reset pipe in endpoint */ if(stor->pipe_in->status == UPIPE_STATUS_STALL) { - ret = rt_usbh_clear_feature(intf->device, + ret = rt_usbh_clear_feature(intf->device, stor->pipe_in->ep.bEndpointAddress, USB_FEATURE_ENDPOINT_HALT); - if(ret != RT_EOK) return ret; + if(ret != RT_EOK) return ret; } - + /* reset pipe out endpoint */ if(stor->pipe_out->status == UPIPE_STATUS_STALL) { - ret = rt_usbh_clear_feature(intf->device, + ret = rt_usbh_clear_feature(intf->device, stor->pipe_out->ep.bEndpointAddress, USB_FEATURE_ENDPOINT_HALT); - if(ret != RT_EOK) return ret; + if(ret != RT_EOK) return ret; } while((ret = rt_usbh_storage_inquiry(intf, inquiry)) != RT_EOK) - { + { if(ret == -RT_EIO) return ret; - rt_thread_delay(5); + rt_thread_delay(5); if(i++ < 10) continue; rt_kprintf("rt_usbh_storage_inquiry error\n"); - return -RT_ERROR; + return -RT_ERROR; } i = 0; @@ -235,26 +247,26 @@ rt_err_t rt_udisk_run(struct uhintf* intf) while((ret = rt_usbh_storage_test_unit_ready(intf)) != RT_EOK) { if(ret == -RT_EIO) return ret; - + ret = rt_usbh_storage_request_sense(intf, sense); if(ret == -RT_EIO) return ret; - - rt_thread_delay(10); + + rt_thread_delay(10); if(i++ < 10) continue; rt_kprintf("rt_usbh_storage_test_unit_ready error\n"); - return -RT_ERROR; + return -RT_ERROR; } i = 0; rt_memset(stor->capicity, 0, sizeof(stor->capicity)); /* get storage capacity */ - while((ret = rt_usbh_storage_get_capacity(intf, + while((ret = rt_usbh_storage_get_capacity(intf, (rt_uint8_t*)stor->capicity)) != RT_EOK) - { - if(ret == -RT_EIO) return ret; - + { + if(ret == -RT_EIO) return ret; + rt_thread_delay(50); if(i++ < 10) continue; @@ -262,16 +274,16 @@ rt_err_t rt_udisk_run(struct uhintf* intf) stor->capicity[1] = 0x200; rt_kprintf("rt_usbh_storage_get_capacity error\n"); - break; + break; } stor->capicity[0] = uswap_32(stor->capicity[0]); stor->capicity[1] = uswap_32(stor->capicity[1]); stor->capicity[0] += 1; - - RT_DEBUG_LOG(RT_DEBUG_USB, ("capicity %d, block size %d\n", + + RT_DEBUG_LOG(RT_DEBUG_USB, ("capicity %d, block size %d\n", stor->capicity[0], stor->capicity[1])); - + /* get the first sector to read partition table */ sector = (rt_uint8_t*) rt_malloc (SECTOR_SIZE); if (sector == RT_NULL) @@ -283,42 +295,46 @@ rt_err_t rt_udisk_run(struct uhintf* intf) rt_memset(sector, 0, SECTOR_SIZE); RT_DEBUG_LOG(RT_DEBUG_USB, ("read partition table\n")); - + /* get the partition table */ ret = rt_usbh_storage_read10(intf, sector, 0, 1, 500); if(ret != RT_EOK) { rt_kprintf("read parition table error\n"); - rt_free(sector); - return -RT_ERROR; + rt_free(sector); + return -RT_ERROR; } RT_DEBUG_LOG(RT_DEBUG_USB, ("finished reading partition\n")); - + for(i=0; iintf = intf; + data->intf = intf; data->udisk_id = udisk_get_id(); rt_snprintf(dname, 6, "ud%d-%d", data->udisk_id, i); rt_snprintf(sname, 8, "sem_ud%d", i); data->part.lock = rt_sem_create(sname, 1, RT_IPC_FLAG_FIFO); /* register sdcard device */ - stor->dev[i].type = RT_Device_Class_Block; - stor->dev[i].init = rt_udisk_init; - stor->dev[i].read = rt_udisk_read; - stor->dev[i].write = rt_udisk_write; + 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 | + rt_device_register(&stor->dev[i], dname, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE); stor->dev_cnt++; @@ -330,16 +346,16 @@ rt_err_t rt_udisk_run(struct uhintf* intf) else { RT_DEBUG_LOG(RT_DEBUG_USB, ("udisk part %d mount failed\n", i)); - } + } } else { if(i == 0) - { - struct ustor_data* data = rt_malloc(sizeof(struct ustor_data)); - rt_memset(data, 0, sizeof(struct ustor_data)); + { + struct ustor_data* data = rt_malloc(sizeof(struct ustor_data)); + rt_memset(data, 0, sizeof(struct ustor_data)); data->udisk_id = udisk_get_id(); - + /* there is no partition table */ data->part.offset = 0; data->part.size = 0; @@ -349,23 +365,27 @@ rt_err_t rt_udisk_run(struct uhintf* intf) rt_snprintf(dname, 7, "udisk%d", data->udisk_id); /* register sdcard device */ - stor->dev[0].type = RT_Device_Class_Block; - stor->dev[0].init = rt_udisk_init; - stor->dev[0].read = rt_udisk_read; - stor->dev[0].write = rt_udisk_write; + 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, - RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE + RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE); stor->dev_cnt++; - if (dfs_mount(stor->dev[0].parent.name, UDISK_MOUNTPOINT, + if (dfs_mount(stor->dev[0].parent.name, UDISK_MOUNTPOINT, "elm", 0, 0) == 0) - { + { rt_kprintf("Mount FAT on Udisk successful.\n"); - } + } else { rt_kprintf("Mount FAT on Udisk failed.\n"); @@ -382,31 +402,31 @@ rt_err_t rt_udisk_run(struct uhintf* intf) } /** - * This function will be invoked when usb disk plug out is detected and it would clean + * This function will be invoked when usb disk plug out is detected and it would clean * and release all udisk related resources. * * @param intf the usb interface instance. - * + * * @return the error code, RT_EOK on successfully. */ rt_err_t rt_udisk_stop(struct uhintf* intf) { int i; - ustor_t stor; + ustor_t stor; struct ustor_data* data; /* check parameter */ RT_ASSERT(intf != RT_NULL); RT_ASSERT(intf->device != RT_NULL); - stor = (ustor_t)intf->user_data; + stor = (ustor_t)intf->user_data; RT_ASSERT(stor != RT_NULL); for(i=0; idev_cnt; i++) { rt_device_t dev = &stor->dev[i]; data = (struct ustor_data*)dev->user_data; - + /* unmount filesystem */ dfs_unmount(UDISK_MOUNTPOINT); diff --git a/components/drivers/watchdog/watchdog.c b/components/drivers/watchdog/watchdog.c index af2dcace78a2020a3aa7d4e767fb1abec6d2ad64..e5453f8e435938f058c48453402334edd9a2e262 100644 --- a/components/drivers/watchdog/watchdog.c +++ b/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 */ diff --git a/components/libc/compilers/newlib/libc.c b/components/libc/compilers/newlib/libc.c index 6d6a7d734ec3e293646dd822d24e073197e4108d..0b7350c30edc67f9063312f0497bb930ed3bb888 100644 --- a/components/libc/compilers/newlib/libc.c +++ b/components/libc/compilers/newlib/libc.c @@ -35,6 +35,8 @@ #include #endif +int _EXFUN(putenv,(char *__string)); + int libc_system_init(void) { #if defined(RT_USING_DFS) & defined(RT_USING_DFS_DEVFS) diff --git a/components/libc/compilers/newlib/stdio.c b/components/libc/compilers/newlib/stdio.c index 394705bf15fb4ad26c107cd7e6accdeb9c206019..9f30106b729c5f59a95a3a602d1a77c8ef67da62 100644 --- a/components/libc/compilers/newlib/stdio.c +++ b/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) diff --git a/components/utilities/logtrace/log_file.c b/components/utilities/logtrace/log_file.c index 4e4e15896989b26205c81d7646387af67bcb68f7..42d1f6e7a98580d051754ed8e8858af486e7c10d 100644 --- a/components/utilities/logtrace/log_file.c +++ b/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); } diff --git a/components/utilities/logtrace/log_trace.c b/components/utilities/logtrace/log_trace.c index 79bcde207593e2c413c0b35b6312ed7143cf3da4..4ea0ff13fd6cfeb8fa8d40e087fca392d3284131 100644 --- a/components/utilities/logtrace/log_trace.c +++ b/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; diff --git a/include/rtdef.h b/include/rtdef.h index de243b7d5cf87c7b686efe242c7b10657d72b754..5f6f7289675545e4f21cd82f759bcf7c4c6fdb39 100644 --- a/include/rtdef.h +++ b/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; diff --git a/src/Kconfig b/src/Kconfig index d8ddbfc838d4bb5abc3c02e510a9399e23486496..89f709478b981713e57b20f9e3a0c44483ae40b9 100644 --- a/src/Kconfig +++ b/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 diff --git a/src/device.c b/src/device.c index 231a052b86803071ebf97216face134b0702995c..2a919cace6543434a6bce7e284136783b38be4e3 100644 --- a/src/device.c +++ b/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;