static struct ach_header *ach_create(const char *name, size_t frame_cnt, size_t frame_size, clockid_t clock)
{
struct ach_header *shm;
int len = ach_create_len(frame_cnt, frame_size);
len = sizeof(struct ach_header) +
frame_cnt * sizeof(ach_index_t) +
frame_cnt * frame_size + 3 * sizeof(uint64_t);
shm = (struct ach_header *)kzalloc(len, GFP_KERNEL);
if (unlikely(!shm)) {
printk(KERN_ERR "ach: Unable to allocate buffer memory\n");
return NULL;
}
shm->len = len;
/* initialize mutex */
rt_mutex_init(&shm->sync.mutex);
init_waitqueue_head(&shm->sync.readq);
/* set up refcounting */
kref_init(&shm->refcount);
rt_mutex_init(&shm->ref_mutex);
shm->clock = clock;
/* initialize counts */
ach_create_counts( shm, name, frame_cnt, frame_size );
return shm;
}
void
jffs2_start_garbage_collect_thread(struct jffs2_sb_info *c)
{
struct super_block *sb=OFNI_BS_2SFFJ(c);
cyg_mtab_entry *mte;
int result;
RT_ASSERT(c);
//RT_ASSERT(!sb->s_gc_thread_handle);
mte=(cyg_dir *) sb->s_root;
RT_ASSERT(mte);
rt_event_init(&sb->s_gc_thread_flags, "gc_event", RT_IPC_FLAG_FIFO);
rt_mutex_init(&sb->s_lock, "gc_mutex", RT_IPC_FLAG_FIFO);
// rt_mutex_init(&mte->fs->syncmode, "fs_lock", RT_IPC_FLAG_FIFO);
D1(printk("jffs2_start_garbage_collect_thread\n"));
/* Start the thread. Doesn't matter if it fails -- it's only an
* optimisation anyway */
result = rt_thread_init(&sb->s_gc_thread,
"jffs2_gc_thread",
jffs2_garbage_collect_thread,
(void *)c,
(void*)sb->s_gc_thread_stack,
sizeof(sb->s_gc_thread_stack),
CYGNUM_JFFS2_GC_THREAD_PRIORITY,
CYGNUM_JFFS2_GC_THREAD_TICKS
);
if (result != RT_EOK) {
rt_thread_startup(&sb->s_gc_thread);
/* how to deal with the following filed? */
/* sb->s_gc_thread_handle; */
}
}
void setup_main_loop(void)
{
signal(SIGPIPE, SIG_IGN);
state.epoll_fd = epoll_create(1);
if (state.epoll_fd < 0) fail(1, "epoll_create");
rt_mutex_init(&state.sched_lock);
#if ENABLE_AIO
int ret;
static event_t aio_dummy_event;
state.aio_dummy_event = &aio_dummy_event;
ret = io_setup(MAX_AIO_EVENTS, &state.aio_ctx);
if (ret < 0) fail2(1, -ret, "io_setup");
state.aio_eventfd = eventfd(0, EFD_NONBLOCK);
if (state.aio_eventfd < 0) fail(1, "eventfd");
ret = epoll_ctler(EPOLL_CTL_ADD, state.aio_eventfd,
EPOLLIN, state.aio_dummy_event);
if (ret < 0) fail(1, "epoll_ctl eventfd");
#endif
}
int rtgui_system_server_init(void)
{
rt_mutex_init(&_screen_lock, "screen", RT_IPC_FLAG_FIFO);
/* init image */
rtgui_system_image_init();
/* init font */
rtgui_font_system_init();
/* init rtgui server */
rtgui_topwin_init();
rtgui_server_init();
/* use driver rect for main window */
rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), &_mainwin_rect);
/* set the default font */
#if RTGUI_DEFAULT_FONT_SIZE == 16
rtgui_font_set_defaut(&rtgui_font_asc16);
#elif RTGUI_DEFAULT_FONT_SIZE == 12
rtgui_font_set_defaut(&rtgui_font_asc12);
#else
rtgui_font_set_defaut(&rtgui_font_asc12);
#endif
return 0;
}
static int init_rttest(void)
{
int ret, i;
spin_lock_init(&rttest_lock);
for (i = 0; i < MAX_RT_TEST_MUTEXES; i++)
rt_mutex_init(&mutexes[i]);
ret = sysdev_class_register(&rttest_sysclass);
if (ret)
return ret;
for (i = 0; i < MAX_RT_TEST_THREADS; i++) {
ret = init_test_thread(i);
if (ret)
break;
ret = sysdev_create_file(&thread_data[i].sysdev, &attr_status);
if (ret)
break;
ret = sysdev_create_file(&thread_data[i].sysdev, &attr_command);
if (ret)
break;
}
printk("Initializing RT-Tester: %s\n", ret ? "Failed" : "OK" );
return ret;
}
int rt_hw_lcd_init(const char *name)
{
struct lcd_device *dev;
if(rt_device_find(name))
{
return -RT_EIO;
}
dev = rt_malloc(sizeof(struct lcd_device));
if(!dev)
{
return RT_ENOMEM;
}
dev->rtdev.type = RT_Device_Class_Graphic;
dev->rtdev.rx_indicate = RT_NULL;
dev->rtdev.init = rt_lcd_init;
dev->rtdev.open = RT_NULL;
dev->rtdev.close = RT_NULL;
dev->rtdev.read = RT_NULL;
dev->rtdev.write = RT_NULL;
dev->rtdev.control = rt_lcd_control;
dev->rtdev.user_data = RT_NULL;
/* initialize mutex */
rt_mutex_init(&dev->lock, name, RT_IPC_FLAG_FIFO);
rt_device_register(&dev->rtdev, name, RT_DEVICE_FLAG_RDWR);
return RT_EOK;
}
int rtgui_system_server_init(void)
{
rt_mutex_init(&_screen_lock, "screen", RT_IPC_FLAG_FIFO);
/* the graphic device driver must be set before initialization */
RT_ASSERT(rtgui_graphic_driver_get_default() != RT_NULL);
/* init image */
rtgui_system_image_init();
/* init font */
rtgui_font_system_init();
/* set the rect of main window to full screen */
rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), &_mainwin_rect);
/* init rtgui server */
rtgui_topwin_init();
rtgui_server_init();
/* use driver rect for main window */
rtgui_graphic_driver_get_rect(rtgui_graphic_driver_get_default(), &_mainwin_rect);
/* init theme */
rtgui_system_theme_init();
return 0;
}
rt_err_t at24cxx_init(const char * device_name, const char * i2c_bus_name)
{
int i;
struct rt_i2c_bus_device* i2c_bus_device;
/* initialize mutex */
if (rt_mutex_init(&at24cxx_device.lock, device_name, RT_IPC_FLAG_FIFO) != RT_EOK)
{
rt_kprintf("init lock mutex failed\n");
return -RT_ENOSYS;
}
/* we got i2c bus */
i2c_bus_device = rt_i2c_bus_device_find(i2c_bus_name);
if(i2c_bus_device == RT_NULL)
{
AT24CXX_TRACE("i2c device %s not found!\r\n", i2c_bus_device);
return -RT_ENOSYS;
}
at24cxx_device.bus = i2c_bus_device;
/* find match */
for(i=0;i<ARRAY_SIZE(at24cxx_attr_table);i++)
{
if(!rt_strcmp(at24cxx_attr_table[i].name, device_name))
{
AT24CXX_TRACE("%s supported hardware:%s\r\n", __func__, device_name);
at24cxx_device.attr = at24cxx_attr_table[i];
break;
}
}
/* devices not supported */
if( i == ARRAY_SIZE(at24cxx_attr_table))
{
return RT_ERROR;
}
at24cxx_device.geometry.bytes_per_sector = at24cxx_device.attr.page_size;
at24cxx_device.geometry.block_size = at24cxx_device.attr.page_size;
at24cxx_device.geometry.sector_count = at24cxx_device.attr.total_size/at24cxx_device.attr.page_size;
/* register device */
at24cxx_device.parent.type = RT_Device_Class_Block;
at24cxx_device.parent.init = init;
at24cxx_device.parent.open = open;
at24cxx_device.parent.close = close;
at24cxx_device.parent.read = read;
at24cxx_device.parent.write = write_page;
at24cxx_device.parent.control = control;
/* no private */
at24cxx_device.parent.user_data = RT_NULL;
rt_device_register(&at24cxx_device.parent, device_name,
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
return RT_EOK;
}
channel_t *new_channel(void) {
channel_t *ch = calloc(1, sizeof(channel_t));
if (!ch) fail(1, "allocating channel");
ch->rc = 1;
rt_mutex_init(&ch->lock);
ch->ev.type = EVENT_CHANNEL;
ch->ev.u.ch = ch;
return ch;
}
/**********************************************************************************
* MODULE INIT
**********************************************************************************/
static int __init ach_init(void)
{
int ret = 0;
if (!max_devices)
return -1;
/* Init ctrl data */
ctrl_data.in_use_cnt = 0;
ctrl_data.devices = ach_ch_devices_alloc();
ctrl_data.free = ctrl_data.devices;
ctrl_data.in_use = NULL;
rt_mutex_init(&ctrl_data.lock);
/* Create ctrl device */
misc_register(&ach_misc_device);
printk(KERN_INFO
"ach: device registered with a max of %u devices\n",
max_devices);
/* Common channel device stuff */
/* We'll use own major number as we want to control the minor numbers ourself */
{
dev_t dev_num;
ctrl_data.ach_ch_class = class_create(THIS_MODULE, ACH_CH_SUBSYSTEM);
if (IS_ERR(ctrl_data.ach_ch_class)) {
ret = PTR_ERR(ctrl_data.ach_ch_class);
printk(KERN_ERR "ach: Failed to create class\n");
goto out_deregister;
}
/* Allocate major */
dev_num = 0;
ret = alloc_chrdev_region(&dev_num, 0, max_devices, ACH_CH_SUBSYSTEM);
if (ret < 0) {
printk(KERN_ERR
"ach: Failed to allocate major number with %u minor numbers\n",
max_devices);
goto out_classdestroy;
}
ctrl_data.major = MAJOR(dev_num);
}
return 0;
out_classdestroy:
class_destroy(ctrl_data.ach_ch_class);
out_deregister:
misc_deregister(&ach_misc_device);
ach_ch_devices_free_all();
return ret;
}
////////////////////////////////////////////////////////////////////////
// Init all ipc objects.
static void ipcs_init(void)
{
unsigned short dummy,max_interval;
getFrameSplit(&max_interval,&dummy);
rt_mutex_init(&setup_data_buf_mutex,"musb",RT_IPC_FLAG_FIFO);
rt_sem_init(&rx_sem,"semrx",0,RT_IPC_FLAG_FIFO);
rt_sem_init(&tx1_sem,"semtx0",1,RT_IPC_FLAG_FIFO);
rt_sem_init(&tx2_sem,"semtx1",1,RT_IPC_FLAG_FIFO);
rt_timer_init(&max_interval_timer,"rx_tmr",rx_interval_timeout,
RT_NULL,max_interval/1000*RT_TICK_PER_SECOND,RT_TIMER_FLAG_ONE_SHOT);
}
void socket_conn_init(void)
{
int i;
char mutex_name[] = {'m','c','_','A',0};
memset(socket_list,0,sizeof(socket_list));
for( i = 0 ; i < SOCKET_LIST_SIZE ; i++ )
{
rt_mutex_init(&socket_list[i].mu_sock,mutex_name,RT_IPC_FLAG_FIFO);
mutex_name[3]++;
}
}
int cme_m7_eth_init(void)
{
// /* PHY RESET: PA4 */
// {
// GPIO_ResetBits(GPIOA, GPIO_Pin_4);
// rt_thread_delay(2);
// GPIO_SetBits(GPIOA, GPIO_Pin_4);
// rt_thread_delay(2);
// }
// GPIO_Configuration();
NVIC_Configuration();
// cme_eth_device.ETH_Speed = ETH_Speed_100M;
// cme_eth_device.ETH_Mode = ETH_Mode_FullDuplex;
/* OUI 00-80-E1 STMICROELECTRONICS. */
cme_eth_device.dev_addr[0] = 0x00;
cme_eth_device.dev_addr[1] = 0x80;
cme_eth_device.dev_addr[2] = 0xE1;
/* generate MAC addr from 96bit unique ID (only for test). */
// cme_eth_device.dev_addr[3] = *(rt_uint8_t*)(0x1FFF7A10+4);
// cme_eth_device.dev_addr[4] = *(rt_uint8_t*)(0x1FFF7A10+2);
// cme_eth_device.dev_addr[5] = *(rt_uint8_t*)(0x1FFF7A10+0);
cme_eth_device.dev_addr[3] = 12;
cme_eth_device.dev_addr[4] = 34;
cme_eth_device.dev_addr[5] = 56;
cme_eth_device.parent.parent.init = rt_cme_eth_init;
cme_eth_device.parent.parent.open = rt_cme_eth_open;
cme_eth_device.parent.parent.close = rt_cme_eth_close;
cme_eth_device.parent.parent.read = rt_cme_eth_read;
cme_eth_device.parent.parent.write = rt_cme_eth_write;
cme_eth_device.parent.parent.control = rt_cme_eth_control;
cme_eth_device.parent.parent.user_data = RT_NULL;
cme_eth_device.parent.eth_rx = rt_cme_eth_rx;
cme_eth_device.parent.eth_tx = rt_cme_eth_tx;
/* init EMAC lock */
rt_mutex_init(&cme_eth_device.lock, "emac0", RT_IPC_FLAG_PRIO);
/* init tx buffer free semaphore */
rt_sem_init(&cme_eth_device.tx_buf_free,
"tx_buf",
ETH_TXBUFNB,
RT_IPC_FLAG_FIFO);
/* register eth device */
eth_device_init(&(cme_eth_device.parent), "e0");
return RT_EOK;
}
int dfs_jffs2_init(void)
{
/* register fatfs file system */
dfs_register(&dfs_jffs2_ops);
/* initialize mutex */
if (rt_mutex_init(&jffs2_lock, "jffs2lock", RT_IPC_FLAG_FIFO) != RT_EOK)
{
rt_kprintf("init jffs2 lock mutex failed\n");
}
rt_kprintf("init jffs2 lock mutex okay\n");
return 0;
}
int rt_application_init()
{
rt_thread_t init_thread;
rt_err_t result;
/* 初始化静态互斥量 */
result = rt_mutex_init(&static_mutex, "smutex", RT_IPC_FLAG_FIFO);
if (result != RT_EOK)
{
rt_kprintf("init static mutex failed.\n");
return -1;
}
/* 创建一个动态互斥量 */
dynamic_mutex = rt_mutex_create("dmutex", RT_IPC_FLAG_FIFO);
if (dynamic_mutex == RT_NULL)
{
rt_kprintf("create dynamic mutex failed.\n");
return -1;
}
#if (RT_THREAD_PRIORITY_MAX == 32)
init_thread = rt_thread_create("init",
rt_init_thread_entry, RT_NULL,
2048, 8, 20);
#else
init_thread = rt_thread_create("init",
rt_init_thread_entry, RT_NULL,
2048, 80, 20);
#endif
if (init_thread != RT_NULL)
rt_thread_startup(init_thread);
rt_thread_init(&thread1,
"thread1",
rt_thread_entry1,
RT_NULL,
&thread1_stack[0],
sizeof(thread1_stack),11,5);
rt_thread_startup(&thread1);
rt_thread_init(&thread2,
"thread2",
rt_thread_entry2,
RT_NULL,
&thread2_stack[0],
sizeof(thread2_stack),10,5);
rt_thread_startup(&thread2);
return 0;
}
rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
const char *bus_name)
{
rt_err_t res = RT_EOK;
rt_mutex_init(&bus->lock, "i2c_bus_lock", RT_IPC_FLAG_FIFO);
if (bus->timeout == 0) bus->timeout = RT_TICK_PER_SECOND;
res = rt_i2c_bus_device_device_init(bus, bus_name);
i2c_dbg("I2C bus [%s] registered\n", bus_name);
return res;
}
rt_err_t rt_spi_bus_register(struct rt_spi_bus* bus, const char* name, const struct rt_spi_ops* ops)
{
rt_err_t result;
result = rt_spi_bus_device_init(bus, name);
if (result != RT_EOK) return result;
/* initialize mutex lock */
rt_mutex_init(&(bus->lock), name, RT_IPC_FLAG_FIFO);
/* set ops */
bus->ops = ops;
/* initialize owner */
bus->owner = RT_NULL;
return RT_EOK;
}
/**
* this function will initialize device file system.
*/
void dfs_init(void)
{
/* clear filesystem operations table */
rt_memset(filesystem_operation_table, 0, sizeof(filesystem_operation_table));
/* clear filesystem table */
rt_memset(filesystem_table, 0, sizeof(filesystem_table));
/* clean fd table */
rt_memset(fd_table, 0, sizeof(fd_table));
/* create device filesystem lock */
rt_mutex_init(&fslock, "fslock", RT_IPC_FLAG_FIFO);
#ifdef DFS_USING_WORKDIR
/* set current working directory */
rt_memset(working_directory, 0, sizeof(working_directory));
working_directory[0] = '/';
#endif
}
int init_module(void)
{
printk("Conditional semaphore test program.\n");
printk("Wait for all tasks to end, then type: ./rem.\n\n");
start_rt_timer(nano2count(TICK));
rt_cond_init(&cond);
rt_mutex_init(&mtx);
rt_task_init(&task1, task_func1, 0, RT_STACK, 0, 0, 0);
rt_task_init(&task2, task_func2, 0, RT_STACK, 1, 0, 0);
rt_task_init(&task3, task_func3, 0, RT_STACK, 2, 0, 0);
rt_task_init(&task4, task_func4, 0, RT_STACK, 3, 0, 0);
rt_task_resume(&task1);
rt_task_resume(&task2);
rt_task_resume(&task3);
rt_task_resume(&task4);
printk("Do not panic, wait 2 s, till task3 times out.\n\n");
return 0;
}
void rt_hw_i2c1_init(void)
{
struct rt_i2c_bus_device *bus;
RCC_Configuration();
NVIC_Configuration();
GPIO_Configuration();
bus=&i2c_bus1;
rt_memset(bus, 0, sizeof(struct rt_i2c_bus_device));
bus->ops = &i2c1_ops;
rt_sem_init(&DMA_TX_Sem,"i2c_tx",0,RT_IPC_FLAG_FIFO);
rt_sem_init(&DMA_RX_Sem,"i2c_rx",0,RT_IPC_FLAG_FIFO);
#ifdef NO_RT_DEVICE
rt_mutex_init(&I2C1_mutex,"i2c1_m",RT_IPC_FLAG_FIFO);
#endif
rt_i2c_bus_device_register(bus,"i2c1");
}
void nand_mtd_init()
{
/* initialize mutex */
if (rt_mutex_init(&nand, "nand", RT_IPC_FLAG_FIFO) != RT_EOK)
{
rt_kprintf("init nand lock mutex failed\n");
}
nand_part[0].page_size = PAGE_DATA_SIZE;
nand_part[0].pages_per_block = 32;//don't caculate oob size
nand_part[0].block_start = 0;
nand_part[0].block_end = 123;
nand_part[0].oob_size = 16;
nand_part[0].ops = &nand_mtd_ops;
rt_mtd_nand_register_device("psram0", &nand_part[0]);
nand_read_id(RT_NULL);
}
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
{
rt_err_t result;
char name[RT_NAME_MAX];
static rt_uint16_t pthread_mutex_number = 0;
if (!mutex) return EINVAL;
/* build mutex name */
rt_snprintf(name, sizeof(name), "pmtx%02d", pthread_mutex_number ++);
if (attr == RT_NULL) mutex->attr = pthread_default_mutexattr;
else mutex->attr = *attr;
/* init mutex lock */
result = rt_mutex_init(&(mutex->lock), name, RT_IPC_FLAG_FIFO);
if (result != RT_EOK) return EINVAL;
/* detach the object from system object container */
rt_object_detach(&(mutex->lock.parent.parent));
return 0;
}
int rt_hw_uart_init(const char *name, uint32_t instance)
{
struct uart_device *dev;
if(rt_device_find(name))
{
return -RT_EIO;
}
dev = rt_malloc(sizeof(struct uart_device));
if(!dev)
{
return RT_ENOMEM;
}
dev->rtdev.type = RT_Device_Class_Char;
dev->rtdev.rx_indicate = RT_NULL;
dev->rtdev.tx_complete = RT_NULL;
dev->rtdev.init = rt_uart_init;
dev->rtdev.open = rt_uart_open;
dev->rtdev.close = rt_uart_close;
dev->rtdev.read = rt_uart_read;
dev->rtdev.write = rt_uart_write;
dev->rtdev.control = rt_uart_control;
dev->rtdev.user_data = RT_NULL;
dev->hw_instance = instance;
dev->rx_len = 0;
/* initialize mutex */
if (rt_mutex_init(&dev->lock, name, RT_IPC_FLAG_FIFO) != RT_EOK)
{
return -RT_ENOSYS;
}
rt_device_register(&dev->rtdev, name, RT_DEVICE_FLAG_RDWR);
return RT_EOK;
}
