INT32 i2c_gpio_attach(int dev_num)
{
int i;
if (dev_num > 0)
{
dev_num = (dev_num > I2C_GPIO_NUM) ? I2C_GPIO_NUM : dev_num;
i2c_gpio = (struct i2c_gpio_st *)MALLOC(sizeof(struct i2c_gpio_st) * dev_num);
if (i2c_gpio == NULL)
return ERR_FAILUE;
MEMSET(i2c_gpio, 0, sizeof(struct i2c_gpio_st) * dev_num);
for (i = 0; i < dev_num; i++)
{
i2c_gpio[i].mutex_id = osal_mutex_create();
i2c_gpio[i].clock_period = 0;
}
i2c_dev[I2C_TYPE_GPIO>>16].mode_set = i2c_gpio_mode_set;
i2c_dev[I2C_TYPE_GPIO>>16].read = i2c_gpio_read;
i2c_dev[I2C_TYPE_GPIO>>16].write = i2c_gpio_write;
i2c_dev[I2C_TYPE_GPIO>>16].write_read = i2c_gpio_write_read;
i2c_dev[I2C_TYPE_GPIO>>16].write_read_std = i2c_gpio_write_read_std;
i2c_dev[I2C_TYPE_GPIO>>16].write_write_read = i2c_gpio_write_write_read;
i2c_dev_ext[I2C_TYPE_GPIO>>16].write_plus_read = i2c_gpio_write_plus_read;
}
UINT8 gyca_mail_init(void)
{
UINT32 chunk_id = CAS_MAIL_CHUNK_ID;
CHUNK_HEADER chuck_hdr;
/* get table info base addr by using chunk */
if(sto_get_chunk_header(chunk_id, &chuck_hdr) == 0)
{
GYCAS_PRINTF("Err: %s get chunk header fail!\n", __FUNCTION__);
return 1;
}
gyca_email_mutex = osal_mutex_create();
if(gyca_email_mutex == OSAL_INVALID_ID)
{
GYCAS_PRINTF("Err: %s create mutex failed!\n", __FUNCTION__);
}
gyca_email_start_addr = sto_chunk_goto(&chunk_id, 0xFFFFFFFF, 1) + CHUNK_HEADER_SIZE + SECTOR_SIZE;
if(!gyca_check_flash_mail_head(gyca_email_start_addr))
gyca_readmail_all_from_flash(gyca_email_start_addr, GYCA_MAIL_HEAD_SIZE);
else
{
MEMSET(flashbuf, 0, sizeof(flashbuf));
//gyca_mail_test();
//gyca_delmail_all_flash(gyca_email_start_addr);
//gyca_writemaill_all_to_flash(gyca_email_start_addr, GYCA_MAIL_HEAD_SIZE);
}
}
//--------------------------------------------------------------------+
// CLASS-USBD API (don't require to verify parameters)
//--------------------------------------------------------------------+
bool usbh_init(void)
{
tu_memclr(_usbh_devices, sizeof(usbh_device_t)*(CFG_TUSB_HOST_DEVICE_MAX+1));
//------------- Enumeration & Reporter Task init -------------//
_usbh_q = osal_queue_create( &_usbh_qdef );
TU_ASSERT(_usbh_q != NULL);
//------------- Semaphore, Mutex for Control Pipe -------------//
for(uint8_t i=0; i<CFG_TUSB_HOST_DEVICE_MAX+1; i++) // including address zero
{
usbh_device_t * const dev = &_usbh_devices[i];
dev->control.sem_hdl = osal_semaphore_create(&dev->control.sem_def);
TU_ASSERT(dev->control.sem_hdl != NULL);
dev->control.mutex_hdl = osal_mutex_create(&dev->control.mutex_def);
TU_ASSERT(dev->control.mutex_hdl != NULL);
memset(dev->itf2drv, 0xff, sizeof(dev->itf2drv)); // invalid mapping
memset(dev->ep2drv , 0xff, sizeof(dev->ep2drv )); // invalid mapping
}
// Class drivers init
for (uint8_t drv_id = 0; drv_id < USBH_CLASS_DRIVER_COUNT; drv_id++) usbh_class_drivers[drv_id].init();
TU_ASSERT(hcd_init());
hcd_int_enable(TUH_OPT_RHPORT);
return true;
}
int dm_init(void)
{
MEMSET(&g_dm, 0, sizeof(DiskMgr));
if ((g_dm.MutexId = osal_mutex_create()) == OSAL_INVALID_ID)
{
DM_ERROR("Create mutex failed!\n");
return -1;
}
return 0;
}
static int jpeg_init(struct pe_image_cfg *pe_image_cfg)
{
struct vpo_device * pvpo_sd;
MEMSET(&jpeg_file, 0, sizeof(jpeg_file));
jpeg_file.init_conf.frm_y_size = pe_image_cfg->frm_y_size;
jpeg_file.init_conf.frm_y_addr = pe_image_cfg->frm_y_addr;
jpeg_file.init_conf.frm_c_size = pe_image_cfg->frm_c_size;
jpeg_file.init_conf.frm_c_addr = pe_image_cfg->frm_c_addr;
jpeg_file.init_conf.frm2_y_size = pe_image_cfg->frm2_y_size;
jpeg_file.init_conf.frm2_y_addr = pe_image_cfg->frm2_y_addr;
jpeg_file.init_conf.frm2_c_size = pe_image_cfg->frm2_c_size;
jpeg_file.init_conf.frm2_c_addr = pe_image_cfg->frm2_c_addr;
jpeg_file.init_conf.decoder_buf = pe_image_cfg->decoder_buf;
jpeg_file.init_conf.frm3_y_size = pe_image_cfg->frm3_y_size;
jpeg_file.init_conf.frm3_y_addr = pe_image_cfg->frm3_y_addr;
jpeg_file.init_conf.frm3_c_size = pe_image_cfg->frm3_c_size;
jpeg_file.init_conf.frm3_c_addr = pe_image_cfg->frm3_c_addr;
pvpo_sd = (struct vpo_device *)dev_get_by_id(HLD_DEV_TYPE_DIS, 1);
if(NULL != pvpo_sd)
{
jpeg_file.init_conf.frm4_y_size = pe_image_cfg->frm4_y_size;
jpeg_file.init_conf.frm4_y_addr = pe_image_cfg->frm4_y_addr;
jpeg_file.init_conf.frm4_c_size = pe_image_cfg->frm4_c_size;
jpeg_file.init_conf.frm4_c_addr = pe_image_cfg->frm4_c_addr;
}
jpeg_file.init_conf.decoder_buf_len = pe_image_cfg->decoder_buf_len;
jpeg_file.init_conf.fread_callback = NULL,//jpg_read_data;
jpeg_file.init_conf.fseek_callback = NULL,//jpg_seek_data;
jpeg_file.init_conf.imagedec_status = jpeg_process;
if(sys_ic_get_chip_id()==ALI_S3602 || sys_ic_get_chip_id()==ALI_S3602F ||sys_ic_get_chip_id()==ALI_S3811)
jpeg_file.init_conf.frm_mb_type = 1;
else
jpeg_file.init_conf.frm_mb_type = 0;
#ifdef ENABLE_PE_CACHE
jpeg_file.init_conf.decoder_buf_len -= GIF_CACHE_SIZE;
gif_cache_buffer = (unsigned char *)(((unsigned long)jpeg_file.init_conf.decoder_buf) & 0xfffffff0);
gif_cache_buffer = (unsigned char *)(((unsigned long)gif_cache_buffer & 0x0fffffff) | 0x80000000);
jpeg_file.init_conf.decoder_buf = jpeg_file.init_conf.decoder_buf + GIF_CACHE_SIZE;
#endif
jpeg_file.id = imagedec_init(&jpeg_file.init_conf);
jpeg_file.lock = osal_mutex_create();
//pic_gif_init();
}
/*
* __sinit() is called whenever stdio's internal variables must be set up.
*/
void __sinit()
{
int i;
__isthreaded = 1;
if (__sdidinit == 0)
{
thread_lock = osal_mutex_create();
/* Set _extra for the usual suspects. */
for (i = 0; i < FOPEN_MAX; i++)
usual[i]._extra = &usual_extra[i];
/* Make sure we clean up on exit. */
//__cleanup = _cleanup; /* conservative */
__sdidinit = 1;
}
}
/*
* Find a free FILE for fopen et al.
*/
FILE *__sfp()
{
FILE *fp;
int n;
struct glue *g;
if (!__sdidinit)
__sinit();
/*
* The list must be locked because a FILE may be updated.
*/
THREAD_LOCK();
for (g = &__sglue; g != NULL; g = g->next)
{
for (fp = g->iobs, n = g->niobs; --n >= 0; fp++)
if (fp->_flags == 0)
goto found;
}
return (NULL);
found:
fp->_flags = 1; /* reserve this slot; caller sets real flags */
THREAD_UNLOCK();
fp->_p = NULL; /* no current pointer */
fp->_w = 0; /* nothing to read or write */
fp->_r = 0;
fp->_bf._base = NULL; /* no buffer */
fp->_bf._size = 0;
fp->_lbfsize = 0; /* not line buffered */
fp->_file = -1; /* no file */
/* fp->_cookie = <any>; */ /* caller sets cookie, _read/_write etc */
fp->_ub._base = NULL; /* no ungetc buffer */
fp->_ub._size = 0;
fp->_lb._base = NULL; /* no line buffer */
fp->_lb._size = 0;
/* fp->_lock = NULL; */ /* once set always set (reused) */
fp->_extra->orientation = 0;
fp->_extra->fl_mutex = osal_mutex_create();
//MEMSET(&fp->_extra->mbstate, 0, sizeof(mbstate_t));
return (fp);
}
void osd_dev_api_attach(struct ge_device *ge_dev, UINT32 osd_layer_id)
{
struct osd_device *dev;
const char *name;
if (ge_dev)
m_osddrv_ge_dev = ge_dev;
if (osd_layer_id >= 3)
return;
if (osd_layer_id == 0)
name = "OSD_DEV_0";
else if (osd_layer_id == 1)
name = "OSD_DEV_1";
else
name = "OSD_DEV_2";
dev = (struct osd_device *)dev_alloc((INT8 *)name,HLD_DEV_TYPE_OSD,sizeof(struct osd_device));
if (dev == NULL)
{
return ;
}
dev->priv = (void *)osd_layer_id;
dev->next = NULL;
dev->flags = 0;
dev->sema_opert_osd = osal_mutex_create();
if(OSAL_INVALID_ID == dev->sema_opert_osd)
{
PRINTF("OSD Can not create mutex!!!\n");
ASSERT(0);
}
/* Function point init */
#if 0
dev->open = OSDDrv_Open;
dev->close = OSDDrv_Close;
dev->ioctl = OSDDrv_IoCtl;
dev->get_para = OSDDrv_GetPara;
dev->show_onoff = OSDDrv_ShowOnOff;
dev->region_show = OSDDrv_RegionShow;
dev->set_pallette = OSDDrv_SetPallette;
dev->get_pallette = OSDDrv_GetPallette;
dev->modify_pallette = OSDDrv_ModifyPallette;
dev->create_region = OSDDrv_CreateRegion;
dev->delete_region = OSDDrv_DeleteRegion;
dev->set_region_pos = OSDDrv_SetRegionPos;
dev->get_region_pos = OSDDrv_GetRegionPos;
dev->region_write = OSDDrv_RegionWrite;
dev->region_read = OSDDrv_RegionRead;
dev->region_fill = OSDDrv_RegionFill;
dev->region_write2 = OSDDrv_RegionWrite2;
dev->draw_hor_line = OSDDrv_DrawHorLine;
dev->scale = OSDDrv_Scale;
dev->set_clip = OSDDrv_SetClip;
dev->clear_clip = OSDDrv_ClearClip;
dev->get_region_addr = OSDDrv_GetRegionAddr;
#endif
/* Add this device to queue */
if (dev_register(dev) != RET_SUCCESS)
{
dev_free(dev);
return ;
}
return ;
}
int ali_ftl_add_mtd(struct mtd_info *mtd)
{
struct ali_ftl_info *afi;
UINT32 i=0;
UINT32 totalBadBlkNum=0;
#ifdef ALI_FTL_WITH_THREAD //for TDS
T_CTSK t_FtlTsk;
#endif
afi = MALLOC(sizeof(struct ali_ftl_info));
if (!afi) {
ALI_FTL_ERR("[ERR] %s: out of memory\n", __FUNCTION__);
return -1;
}
aliFTLDevice=afi;
MEMSET(aliFTLDevice, 0x0, sizeof(struct ali_ftl_info));
afi->mtd = mtd;
/*MTD info*/
afi->bytePerBlock=mtd->erasesize;
afi->pagePerBlock=mtd->erasesize / mtd->writesize;
afi->oobPerPage=mtd->oobavail;
afi->bytePerPage= mtd->writesize;
/*Partition & Section info*/
afi->blockPerPartition=mtd->size/afi->bytePerBlock;
//afi->blockPerPartition=(uint32_t)mtd->size/afi->bytePerBlock;
// now sizeof(mtd->size)=64, it will cause compile error.
afi->sectionPerPartition=SECTION_PER_PARTITION; //WHH ???
afi->maxLoadSection=SECTION_PER_PARTITION;//WHH ???
afi->blkPerSection=afi->blockPerPartition/afi->sectionPerPartition;
afi->spareBlkPerSection=afi->blkPerSection/SPARE_DATA_RATIO;
afi->dataBlkPerSection=afi->blkPerSection-afi->spareBlkPerSection;
afi->blockPerPartition=afi->blockPerPartition-(afi->blockPerPartition-afi->blkPerSection*afi->sectionPerPartition);//subtract reduce block
afi->spareBlkPerPartition=afi->spareBlkPerSection*afi->sectionPerPartition;
afi->dataBlkPerPartition=afi->blockPerPartition-afi->spareBlkPerPartition;
/*LUT/WLC Info */
afi->pagePerSet=(afi->blkPerSection*sizeof(UINT32))/ mtd->writesize;
if((afi->blkPerSection*sizeof(UINT32))% mtd->writesize)
afi->pagePerSet++;
afi->pagePerSet=afi->pagePerSet<<1; // lut + wlc
afi->setPerBlk=afi->pagePerBlock/afi->pagePerSet;
afi->bytePerSet=afi->pagePerSet*afi->bytePerPage;
afi->wlcOffset=afi->blkPerSection;//*sizeof(uint32_t);
afi->lutSpareOffset=afi->dataBlkPerSection;//*sizeof(uint32_t) ;
afi->wlcSpareOffset=afi->wlcOffset+afi->dataBlkPerSection;//*sizeof(uint32_t) ;
for(i = 0; i < MAX_SECTION; i++) {
//afi->section2Cur[i] = INVALID_INDEX;
//afi->cur2Section[i] = INVALID_INDEX;
//afi->lut_cur[i] = kzalloc(LUT_SECTION_LEN+WLC_SECTION_LEN);
if(i < afi->sectionPerPartition)
afi->lrulist[i] = i;
else
afi->lrulist[i] = INVALID_INDEX; //??
}
section_info_init(afi);
/* Calculate geometry */
//afi->cylinders = ((afi->dataBlkPerPartition*afi->bytePerBlock)>>9)>>3;
afi->cylinders = (afi->dataBlkPerPartition*(afi->bytePerBlock>>9))>>3;
afi->heads = 1;
afi->sectors =8;
if(afi->spareBlkPerSection > afi->sectionPerPartition) { // LYH 110110
if(BuildLUT(afi)!=0) {
ALI_FTL_ERR("[ERR] %s: BuildLUT fail\n", __FUNCTION__);
return -1;
}
dump_afi_all(afi);
}else {
ALI_FTL_ERR("[ERR] %s: Not enough blocks to build FTL\n", __FUNCTION__);
return -1;
}
/* init mutex */
//mutex_init(&afi->ali_ftl_mutex);
afi->ali_ftl_mutex = osal_mutex_create(); //for TDS
#ifdef ALI_FTL_WITH_THREAD
#if 0 //for Linux
/* init timer */ //??
init_timer(&afi->ali_ftl_timer);
afi->ali_ftl_timer.expires= jiffies + ALI_FTL_THREAD_PERIOD;
afi->ali_ftl_timer.function = ali_ftl_timer_func;
afi->ali_ftl_timer.data = (unsigned long)afi; //check the case
add_timer(&afi->ali_ftl_timer);
/* init kernel thread */ //??
afi->ali_ftl_th = kthread_run(ali_ftl_thread, afi, "ali_ftl_thread");
if (IS_ERR(afi->ali_ftl_th)) {
printk("Unable to start ALi FTL thread\n");
del_timer(&afi->ali_ftl_timer);
}
#if 0
if ((afi->mbd.size) != afi->heads * afi->cylinders * afi->sectors) {
/* Oh no we don't have mbd.size == heads * cylinders * sectors */
printk(KERN_WARNING "ali_ftl_add_mtd: cannot calculate a geometry to match size of 0x%lx.\n", afi->mbd.size>>9);
printk(KERN_WARNING "ali_ftl_add_mtd: using C:%d H:%d S:%d (== 0x%lx sects)\n",
afi->cylinders, afi->heads , afi->sectors, (long)afi->cylinders * (long)afi->heads * (long)afi->sectors );
}
void tr_lockInit( tr_lock_t * l )
{
*l = osal_mutex_create();
}
