INT32 f_null_attach(struct COFDM_TUNER_CONFIG_API *ptrCOFDM_Tuner)
{
struct nim_device *dev;
void *priv_mem;
ALI_PRINTF("Enter f_null_attach()...\n");
dev = (struct nim_device *)dev_alloc(nim_null_name, HLD_DEV_TYPE_NIM, sizeof(struct nim_device));
if (dev == NULL)
{
NIM_PRINTF("f_null_attach(): Error, Alloc nim device error!\n");
return ERR_NO_MEM;
}
/* Alloc structure space of private */
priv_mem = (void *)MALLOC(sizeof(struct nim_null_private));
if (priv_mem == NULL)
{
dev_free(dev);
NIM_PRINTF("f_null_attach(): Alloc nim device prive memory error!\n");
return ERR_NO_MEM;
}
MEMCPY(priv_mem, ptrCOFDM_Tuner, sizeof(struct nim_null_private));
dev->priv = priv_mem;
/* Function point init */
//dev->base_addr = 0x80;
dev->init = f_null_attach;
dev->open = f_null_open;
dev->stop = f_null_close;
dev->disable = f_null_disable;
dev->do_ioctl = f_null_ioctl;
dev->channel_change = f_null_channel_change;
dev->channel_search = f_null_channel_search;
dev->get_lock = f_null_get_lock_status;
dev->get_freq = f_null_get_freq;
dev->get_FEC = f_null_get_code_rate;
dev->get_AGC = f_null_get_AGC;
dev->get_SNR = f_null_get_SNR;
dev->get_BER = f_null_get_BER;
//added for DVB-T additional elements
dev->get_guard_interval = f_null_get_GI;
dev->get_fftmode = f_null_get_fftmode;
dev->get_modulation = f_null_get_modulation;
dev->get_spectrum_inv = f_null_get_specinv;
/* Add this device to queue */
if (dev_register(dev) != SUCCESS)
{
NIM_PRINTF("f_null_attach(): Error, Register nim device error!\n");
FREE(priv_mem);
dev_free(dev);
return ERR_NO_DEV;
}
NIM_PRINTF("Exit f_null_attach() normally.\n");
return SUCCESS;
}
int fs_init(dev_t dev)
{
fs_dev->f_op = dev_operations(dev);
read_super();
cache_init();
/* register sys calls */
SCALL_REGISTER(3, sys_read);
SCALL_REGISTER(4, sys_write);
SCALL_REGISTER(5, fs_open);
SCALL_REGISTER(6, fs_close);
SCALL_REGISTER(10, fs_unlink);
SCALL_REGISTER(12, fs_chdir);
SCALL_REGISTER(19, sys_lseek);
SCALL_REGISTER(38, fs_rename);
SCALL_REGISTER(39, fs_mkdir);
SCALL_REGISTER(40, fs_rmdir);
SCALL_REGISTER(141, fs_getdents);
SCALL_REGISTER(200, sys_flush);
/* register fs device */
dev_register(DEV_FS, &ops);
return OK;
}
void
ramdisk_init(void)
{
int i;
char dev_name[] = "rd0";
dev_register(DEV_RAMDISK, &ramdisk_dev);
for (i = 1; i < RAM_DISKS; i++)
{
int len, vlen;
const char *parameter;
const char *value;
/* Considering RAM_DISKS < 10 for now. */
dev_name[2] = (i - 1) + 0x30;
parameter = bootparam_get_parameter(dev_name, &len);
if (!parameter)
continue;
value = bootparam_get_value("addr", &vlen,
parameter, len);
if (value)
ramdisk[i].phy_addr = strtoptr(value, NULL, 0);
value = bootparam_get_value("size", &vlen,
parameter, len);
if (value)
ramdisk[i].len = strtol(value, NULL, 0);
}
}
bool
MolExt::start( IOService *provider )
{
bool res = super::start( provider );
IOLog("MolExt::start\n");
dev_register();
return res;
}
INT32 venc_m3327_init()
{
struct venc_device *dev;
struct venc_m3327_private *tp;
void *priv_mem;
dev = dev_alloc(venc_m3327_name,HLD_DEV_TYPE_VENC,sizeof(struct venc_device));
if (dev == NULL)
{
VENC_PRINTF("Error: Alloc video vencplay device error!\n");
return RET_FAILURE;
}
/* Alloc structure space of private */
priv_mem = (void *)MALLOC(sizeof(struct venc_m3327_private));
if (priv_mem == NULL)
{
dev_free(dev);
VENC_PRINTF("Alloc vencplay device prive memory error!/n");
return RET_FAILURE;
}
MEMSET(priv_mem, 0, sizeof(struct venc_m3327_private));
dev->priv = tp = priv_mem;
dev->next = NULL;
dev->flags = 0;
/* Function point init */
dev->init = venc_m3327_init;
dev->open = venc_m3327_open;
dev->close = venc_m3327_close;
//dev->ioctl = venc_m3327_ioctl;
//dev->i_frame = venc_m3327_i_frame;
//dev->start = venc_m3327_start;
//dev->stop = venc_m3327_stop;
dev->mp2enc = venc_m3327_mp2enc;
/* Add this device to queue */
if (dev_register(dev) != RET_SUCCESS)
{
VENC_PRINTF("Error: Register vencplay device error!\n");
FREE(priv_mem);
dev_free(dev);
return RET_FAILURE;
}
VENC_PRINTF("VENC Attached!\n");
return RET_SUCCESS;
}
void
omap_mmc_init(void)
{
omap_mmchs = vm_map_physical(vm_get_kernel_map(VM_REG_DEVICE), VM_DEVICE | VM_SUPER_RW,
(uintptr_t)0x4809c000, 4096);
omap_padconf = vm_map_physical(vm_get_kernel_map(VM_REG_DEVICE), VM_DEVICE | VM_SUPER_RW,
(uintptr_t)0x48002000, 4096);
omap_mmc_init_controller();
if (omap_mmc_init_card())
{
mbr_t mbr_data;
/* We cannot use mbr_read() yet here, because it uses
* dev_seek(), dev_read().
*
* FIXME: this code really needs to be generalized behind
* a generic partition table interface?
*/
omap_mmc_data.minors[0].start_offset = 0;
omap_mmc_data.minors[0].cur_block = 0;
omap_mmc_data.minors[0].cur_byte = 0;
omap_mmc_seek(NULL, 0, 0, SEEK_SET);
omap_mmc_read(NULL, 0, &mbr_data, 512);
omap_mmc_data.n_partitions = mbr_count_partitions(&mbr_data);
printf("omap-mmc: %d partitions present.\r\n", omap_mmc_data.n_partitions);
omap_mmc_dev.minor_count = 1 + omap_mmc_data.n_partitions;
for (int i = 0; i < MAX_PARTITIONS; i++)
omap_mmc_data.minors[i+1].start_offset = mbr_data.partitions[i].lba_begin;
omap_mmc_init_minors();
}
dev_register(DEV_SDCARD, &omap_mmc_dev);
}
*****************************************************************************/
INT32 f_TC90512_attach(struct COFDM_TUNER_CONFIG_API *ptrCOFDM_Tuner) //51117-01Angus
{
struct nim_device *dev;
struct nim_TC90512_private * priv_mem;
UINT32 tuner_id=0;
if ((ptrCOFDM_Tuner == NULL))
{
NIM_PRINTF("Tuner Configuration API structure is NULL!/n");
return ERR_NO_DEV;
}
dev = (struct nim_device *)dev_alloc(nim_TC90512_name, HLD_DEV_TYPE_NIM, sizeof(struct nim_device));
if (dev == NULL)
{
NIM_PRINTF("Error: Alloc nim device error!\n");
return ERR_NO_MEM;
}
/* Alloc structure space of private */
priv_mem = (struct nim_TC90512_private *)MALLOC(sizeof(struct nim_TC90512_private));
if ((void*)priv_mem == NULL)
{
dev_free(dev);
NIM_TC90512_PRINTF("Alloc nim device prive memory error!/n");
return ERR_NO_MEM;
}
MEMCPY((void*)&(priv_mem->Tuner_Control), (void*)ptrCOFDM_Tuner, sizeof(struct COFDM_TUNER_CONFIG_API));
dev->priv = (void*)priv_mem;
/* Function point init */
dev->base_addr = SYS_COFDM_TC90512_CHIP_ADRRESS; //please check here
dev->init = f_TC90512_attach;
dev->open = f_TC90512_open;
dev->stop = f_TC90512_close;
dev->do_ioctl = NULL;
dev->channel_change = f_TC90512_channel_change;
dev->channel_search = f_TC90512_channel_search;
dev->get_lock = f_TC90512_get_lock;
dev->get_freq = f_TC90512_get_freq;
dev->get_FEC = f_TC90512_get_code_rate;
dev->get_AGC = f_TC90512_get_AGC;
dev->get_SNR = f_TC90512_get_SNR;
//dev->get_BER = f_TC90512_get_BER;
dev->get_guard_interval = f_TC90512_get_GI;
dev->get_fftmode = f_TC90512_get_fftmode;
dev->get_modulation = f_TC90512_get_modulation;
dev->get_spectrum_inv = NULL;
//dev->get_HIER= f_TC90512_get_hier_mode;
//dev->get_priority=f_TC90512_priority;
dev->get_freq_offset = NULL;
f_IIC_Sema_ID=osal_semaphore_create(1);
/*if((((struct nim_TC90512_private*)dev->priv)->Tuner_Control.tuner_config.cChip)!=Tuner_Chip_QUANTEK )
{
ptrCOFDM_Tuner->tuner_config.Tuner_Write=NULL;
ptrCOFDM_Tuner->tuner_config.Tuner_Read=NULL;
}*/
/* Add this device to queue */
if (dev_register(dev) != SUCCESS)
{
NIM_PRINTF("Error: Register nim device error!\n");
FREE(priv_mem);
dev_free(dev);
return ERR_NO_DEV;
}
if (((struct nim_TC90512_private*)dev->priv)->Tuner_Control.nim_Tuner_Init != NULL)
{
if((((struct nim_TC90512_private*)dev->priv)->Tuner_Control.tuner_config.cChip)==Tuner_Chip_QUANTEK || (((struct nim_TC90512_private*)dev->priv)->Tuner_Control.tuner_config.cChip)==Tuner_Chip_MAXLINEAR)
{
f_TC90512_PassThrough(dev,TRUE);
//if (((struct nim_TC90512_private*)dev->priv)->Tuner_Control.nim_Tuner_Init(&((struct nim_TC90512_private*)dev->priv)->tuner_id, &(ptrCOFDM_Tuner->tuner_config)) != SUCCESS)
if (((struct nim_TC90512_private*)dev->priv)->Tuner_Control.nim_Tuner_Init(&tuner_id, &(ptrCOFDM_Tuner->tuner_config)) != SUCCESS)
{
NIM_PRINTF("Error: Init Tuner Failure!\n");
f_TC90512_PassThrough(dev,FALSE);
return ERR_NO_DEV;
}
f_TC90512_PassThrough(dev,FALSE);
}
else
{
if (((struct nim_TC90512_private*)dev->priv)->Tuner_Control.nim_Tuner_Init(&tuner_id, &(ptrCOFDM_Tuner->tuner_config)) != SUCCESS)
{
NIM_PRINTF("Error: Init Tuner Failure!\n");
return ERR_NO_DEV;
}
}
}
return SUCCESS;
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 ybs_drv_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
ADC_InitTypeDef ADC_InitStructure;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
NVIC_InitTypeDef NVIC_InitStructure;
//mos ctrl, PB0, high off, low on
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
//adc, PA1, ADC12_IN1
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_ADCCLKConfig(RCC_PCLK2_Div8); /*72Mhz/8 = 9Mhz*/
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
GPIO_Init(GPIOA, &GPIO_InitStructure);
ADC_DeInit(ADC1);
ADC_StructInit(&ADC_InitStructure);
ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_InitStructure.ADC_ScanConvMode = DISABLE;
ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_Init(ADC1, &ADC_InitStructure);
ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_71Cycles5); //9Mhz/(71.5 + 12.5) = 107.1Khz
ADC_Cmd(ADC1, ENABLE);
/* Enable ADC1 reset calibaration register */
ADC_ResetCalibration(ADC1);
while(ADC_GetResetCalibrationStatus(ADC1));
ADC_StartCalibration(ADC1);
while (ADC_GetCalibrationStatus(ADC1));
ADC_Cmd(ADC1, ENABLE);
ADC_SoftwareStartConvCmd(ADC1, ENABLE);
//TIM4 TIMEBASE
RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
TIM_TimeBaseStructure.TIM_Period = YBS_US - 1;
TIM_TimeBaseStructure.TIM_Prescaler = 72 - 1; //Fapb1 = TIM_clk = 72Mhz, Tick = 1us
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseStructure.TIM_RepetitionCounter = 0;
TIM_TimeBaseInit(TIM4, &TIM_TimeBaseStructure);
//TIM_ARRPreloadConfig(TIM4, ENABLE);
TIM_Cmd(TIM4, DISABLE);
TIM_ClearFlag(TIM4, TIM_FLAG_Update);
TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
//IRQ OF TIM4
NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
//DAC
static const struct ad5663_cfg_s ad5663_cfg = {
.spi = &spi1,
.gpio_cs = SPI_1_NSS,
.gpio_ldac = SPI_CS_PA2,
.gpio_clr = SPI_CS_PA3,
};
dev_register("ad5663", &ad5663_cfg);
ybs_fd_dac = dev_open("dac0", 0);
dev_ioctl(ybs_fd_dac, DAC_SET_CH, 1); //for fast ch1 write purpose
return 0;
}
/********************************************
* NAME: vbi_cc_init
* init cc parameters and set callback fucn of vpo_isr to excute push user data for cc using
*
* Returns : BOOL
* 1 : RET_FAILURE
* 0 : RET_SUCCESS
* Parameter Flow Description
* ------------------------------------------------------------------------------
* None
* ------------------------------------------------------------------------------
* Additional information:
******************************************/
__ATTRIBUTE_REUSE_
INT32 vbi_cc_init()
{
struct vbi_device *dev;
struct vbi_m3327_private *tp;
void *priv_mem;
g_vbi_m3327_name = (char *)ccvbi_m3327_name;
dev = dev_alloc(g_vbi_m3327_name,HLD_DEV_TYPE_VBI,sizeof(struct vbi_device));
if (dev == NULL)
{
VBI_PRINTF("Error: Alloc video vbiplay device error!\n");
return RET_FAILURE;
}
/* Alloc structure space of private */
priv_mem = (void *)MALLOC(sizeof(struct vbi_m3327_private));
if (priv_mem == NULL)
{
dev_free(dev);
VBI_PRINTF("Alloc vbiplay device prive memory error!/n");
return RET_FAILURE;
}
MEMSET(priv_mem, 0, sizeof(struct vbi_m3327_private));
g_vbi_priv = dev->priv = tp = (struct vbi_m3327_private *)priv_mem;
ccg_vbi27_pconfig_par = &(g_vbi_priv->config_par);
ccg_vbi27_ttx_by_osd = &(g_vbi_priv->ttx_by_osd);
ccg_vbi27_cc_by_osd = &(g_vbi_priv->cc_by_osd);
//======================================
#ifdef CC_BY_OSD
ccg_vbi27_dtvcc_by_osd=&(g_vbi_priv->dtvcc_by_osd);//hbchen
#endif
//======================================
/*according the macro , config the VBI driver*/
//vbi_data_array = (struct vbi_data_array_t *)MALLOC((VBI_QUEUE_DEPTH)*sizeof(struct vbi_data_array_t));
//MEMSET(vbi_data_array, 0, (VBI_QUEUE_DEPTH)*sizeof(struct vbi_m3327_private));
*ccg_vbi27_ttx_by_osd = FALSE;
g_vbi_priv->init_ttx_decoder = NULL;
#ifdef CC_BY_OSD
*ccg_vbi27_cc_by_osd = TRUE;
g_vbi_priv->init_cc_decoder = vbi_m3327_init_cc_decoder;
g_vbi_priv->vbi_line21_push_by_cc = vbi_line21_push;
g_vbi_priv->vbi_line21_push_by_dtvcc = vbi_line21_push_dtvcc;//xing for DTVCC
#else
*ccg_vbi27_cc_by_osd = FALSE;
#endif
#ifdef CC_BY_VBI
ccg_vbi27_pconfig_par->cc_by_vbi = TRUE;
#else
ccg_vbi27_pconfig_par->cc_by_vbi = FALSE;
#endif
//dev->setoutput = vbi_m3327_setoutput;
dev->next = NULL;
dev->flags = 0;
/* Function point init */
dev->init = vbi_cc_init;
dev->open = vbi_cc_open;
dev->close = NULL;
dev->request_write = NULL;
dev->update_write = NULL;
dev->setoutput = ccvbi_m3327_setoutput;
dev->start = NULL;
dev->stop = NULL;
/* Add this device to queue */
if(dev_register(dev) != RET_SUCCESS)
{
VBI_PRINTF("Error: Register vbiplay device error!\n");
FREE(priv_mem);
dev_free(dev);
return RET_FAILURE;
}
return RET_SUCCESS;
}
/**********************************************************
* Name : hcdi_s3602_attach
* Description : usb host controller s3602 device attach
* Parameter : notify: HC event notify callback to USBD
* Return : RET_SUCCESS: success
* RET_FAILURE: error
***********************************************************/
RET_CODE hcdi_s3602_attach_ex(HC_NOTIFY_CB notify)
{
struct usb_hc_device* dev;
struct hc_s3602_private* priv ;
void* priv_mem_ctrl;
void* priv_mem_bulk;
void* priv_mem_bulk_out;
void* priv_mem_opt_bulk;
void* priv_mem_int_c;
void* priv_mem_int_d;
UINT32 base_address;
UINT16 i = 0;
dev = (struct usb_hc_device *) dev_alloc(hc_s3602_name_ex,
HLD_DEV_TYPE_USB_HOST,
sizeof(struct usb_hc_device));
if (dev == NULL)
{
HCDI_CMD_PRINTF("Error: Alloc usb host controller device error!\n");
HCDI_CMD_ASSERT(0);
return RET_FAILURE;
}
/* Alloc structure space of private ctrl*/
priv_mem_ctrl = (void *) MALLOC(sizeof(struct hc_s3602_private) + 0x0f);
if (priv_mem_ctrl == NULL)
{
dev_free(dev);
HCDI_CMD_PRINTF("Alloc usb host controller device prive memory error!\n");
HCDI_CMD_ASSERT(0);
return RET_FAILURE;
}
/* Private date struct 16 bytes aligen */
dev->priv_ctrl= priv = (void *) (((UINT32) priv_mem_ctrl+ 0x0f) & (~0x0f));
/* Init priv element */
MEMSET((UINT8 *) priv, 0, sizeof(struct hc_s3602_private));
priv->priv_addr = priv_mem_ctrl; /* Unaligned address of struct real located */
priv->priv_type = USB_CONTROL_TRANSFER_MODE ;
/* Alloc structure space of private bulk */
priv_mem_bulk = (void *) MALLOC(sizeof(struct hc_s3602_private) + 0x0f);
if (priv_mem_bulk== NULL)
{
FREE(priv_mem_ctrl);
dev_free(dev);
HCDI_CMD_PRINTF("Alloc usb host controller device prive memory error!\n");
HCDI_CMD_ASSERT(0);
return RET_FAILURE;
}
/* Private date struct 16 bytes aligen */
dev->priv_bulk= priv = (void *) (((UINT32) priv_mem_bulk+ 0x0f) & (~0x0f));
/* Init priv element */
MEMSET((UINT8 *) priv, 0, sizeof(struct hc_s3602_private));
priv->priv_addr = priv_mem_bulk; /* Unaligned address of struct real located */
priv->priv_type = USB_BULK_IN_TRANSFER_MODE ;
/* Alloc structure space of private bulk_out */
priv_mem_bulk_out = (void *) MALLOC(sizeof(struct hc_s3602_private) + 0x0f);
if (priv_mem_bulk_out== NULL)
{
FREE(priv_mem_ctrl);
FREE(priv_mem_bulk);
dev_free(dev);
HCDI_CMD_PRINTF("Alloc usb host controller device prive memory error!\n");
HCDI_CMD_ASSERT(0);
return RET_FAILURE;
}
/* Private date struct 16 bytes aligen */
dev->priv_bulk_out= priv = (void *) (((UINT32) priv_mem_bulk_out+ 0x0f) & (~0x0f));
/* Init priv element */
MEMSET((UINT8 *) priv, 0, sizeof(struct hc_s3602_private));
priv->priv_addr = priv_mem_bulk_out; /* Unaligned address of struct real located */
priv->priv_type = USB_BULK_OUT_TRANSFER_MODE ;
/* Alloc structure space of private opt_bulk */
priv_mem_opt_bulk = (void *) MALLOC(sizeof(struct hc_s3602_private) + 0x0f);
if (priv_mem_opt_bulk== NULL)
{
FREE(priv_mem_ctrl);
FREE(priv_mem_bulk);
FREE(priv_mem_bulk_out);
dev_free(dev);
HCDI_CMD_PRINTF("Alloc usb host controller device prive memory error!\n");
HCDI_CMD_ASSERT(0);
return RET_FAILURE;
}
/* Private date struct 16 bytes aligen */
dev->priv_opt_bulk = priv = (void *) (((UINT32) priv_mem_opt_bulk+ 0x0f) & (~0x0f));
/* Init priv element */
MEMSET((UINT8 *) priv, 0, sizeof(struct hc_s3602_private));
priv->priv_addr = priv_mem_opt_bulk; /* Unaligned address of struct real located */
priv->priv_type = USB_OPT_BULK_TRANSFER_MODE ;
/* Alloc structure space of private int_c*/
priv_mem_int_c= (void *) MALLOC(sizeof(struct hc_s3602_private) + 0x0f);
if (priv_mem_int_c == NULL)
{
FREE(priv_mem_bulk);
FREE(priv_mem_ctrl);
dev_free(dev);
HCDI_CMD_PRINTF("Alloc usb host controller device prive memory error!\n");
HCDI_CMD_ASSERT(0);
return RET_FAILURE;
}
/* Private date struct 16 bytes aligen */
dev->priv_int_c= priv = (void *) (((UINT32) priv_mem_int_c+ 0x0f) & (~0x0f));
/* Init priv element */
MEMSET((UINT8 *) priv, 0, sizeof(struct hc_s3602_private));
priv->priv_addr = priv_mem_int_c; /* Unaligned address of struct real located */
priv->priv_type = USB_INTERRUPT_TRANSFER_MODE ;
/* Alloc structure space of private int d*/
priv_mem_int_d= (void *) MALLOC(sizeof(struct hc_s3602_private) + 0x0f);
if (priv_mem_int_d == NULL)
{
FREE(priv_mem_int_c);
FREE(priv_mem_bulk);
FREE(priv_mem_ctrl);
dev_free(dev);
HCDI_CMD_PRINTF("Alloc usb host controller device prive memory error!\n");
HCDI_CMD_ASSERT(0);
return RET_FAILURE;
}
/* Private date struct 16 bytes aligen */
dev->priv_int_d= priv = (void *) (((UINT32) priv_mem_int_d+ 0x0f) & (~0x0f));
/* Init priv element */
MEMSET((UINT8 *) priv, 0, sizeof(struct hc_s3602_private));
priv->priv_addr = priv_mem_int_d; /* Unaligned address of struct real located */
priv->priv_type = USB_HUB_TRANSFER_MODE ;
/* Function point init */
if( (sys_ic_get_chip_id() == ALI_M3329E)&&(sys_ic_get_rev_id() >=IC_REV_5))
dev->base_addr = HC_S3329E5_BASE_ADDR;
else if (sys_ic_get_chip_id() == ALI_S3602)
dev->base_addr = HC_S3602_BASE_ADDR;
else
return !RET_SUCCESS; // usb invalid chip id
//dev->base_addr = base_address;
dev->init = hcdi_s3602_attach_ex;
dev->open = hcdi_s3602_open_ex;
dev->close = hcdi_s3602_close_ex;
dev->submit_upt = hcdi_s3602_submit_upt_ex;
dev->cancel_upt = hcdi_s3602_cancel_upt_ex;
dev->suspend = hcdi_s3602_suspend_ex;
dev->resume = hcdi_s3602_resume_ex;
dev->reset = hcdi_s3602_reset_ex;
dev->io_control = hcdi_s3602_ioctl_ex;
dev->hc_notify_uplayer = notify;
dev->rh_port_num = 1;
//dev->curr_upt = NULL;
dev->curr_upt_bulk= NULL;
dev->curr_upt_ctl= NULL;
dev->curr_upt_int_c= NULL;
dev->curr_upt_int_d= NULL;
for (i = 0; i < USB_MAX_DEVICES; i++)
dev->adrsVec[i] = 0;
dev->pRoot = NULL ;
dev->nanSeconds = 0;
/* Add this device to queue */
if (dev_register(dev) != SUCCESS)
{
HCDI_CMD_PRINTF("Error: Register usb host controller device error!\n");
FREE(priv_mem_int_d);
FREE(priv_mem_int_c);
FREE(priv_mem_bulk);
FREE(priv_mem_ctrl);
dev_free(dev);
HCDI_CMD_ASSERT(0);
return RET_FAILURE;
}
return RET_SUCCESS;
}
int floppy_init(void)
{
int rc = 0;
int res, i;
struct vfs_node *n = NULL;
//struct dev *d = NULL;
//dev_t devno;
u_long cmos_drive0, cmos_drive1;
rc = dev_register(FLPY_MAJOR, "flpy");
if (rc != 0) {
DEBUG(DL_DBG, ("register FLPY device class failed.\n"));
goto out;
}
/* Open the root of devfs */
n = vfs_lookup("/dev", VFS_DIRECTORY);
if (!n) {
rc = EGENERIC;
DEBUG(DL_DBG, ("devfs not mounted.\n"));
goto out;
}
/* Setup the interrupt handler */
register_irq_handler(IRQ6, &_flpy_hook, flpy_callback);
/* Reset primary controller */
_primary_fdc.base_port = FDC_PRI;
fdc_reset(&_primary_fdc);
/* Get the FDC version */
fdc_out(_primary_fdc.base_port, FDC_VERSION);
res = fdc_in(_primary_fdc.base_port);
DEBUG(DL_DBG, ("FDC version(0x%x)\n", res));
switch (res) {
case 0x80: DEBUG(DL_DBG, ("NEC765 FDC found on base port 0x%x\n",
_primary_fdc.base_port));
break;
case 0x90: DEBUG(DL_DBG, ("Enhanced FDC found on base port 0x%x\n",
_primary_fdc.base_port));
break;
default: DEBUG(DL_DBG, ("FDC not found on base port 0x%x\n",
_primary_fdc.base_port));
}
/* Read floppy drive type from CMOS memory (up to two drives). */
fdc_out(0x70, 0x10);
res = fdc_in(0x71);
cmos_drive0 = res >> 4;
cmos_drive1 = res & 0x0F;
/* Setup the two floppy drives */
setup_drive(&_primary_fdc, 0, cmos_drive0);
setup_drive(&_primary_fdc, 0, cmos_drive1);
for (res = 0, i = 0; i < NR_MAXDRIVES; i++) {
if (_primary_fdc.drive[i].param->cmos_type)
; // Setup callback
}
DEBUG(DL_DBG, ("module flpy initialize successfully.\n"));
out:
if (n) {
vfs_node_deref(n);
}
return 0;
}
static int cmd_reg(struct cmd *cmd)
{
int a=0;
char *p;
struct device *d;
struct db_device *dd;
char sum[64];
unsigned int n;
int type;
char *pass;
int port;
char *bcast;
int did = cmd->device_id;
char buf[CMD_MAX];
NEXT_ARG(p);
type = atoi(p);
NEXT_ARG(p);
pass = p;
NEXT_ARG(p);
port = atoi(p);
NEXT_ARG(p);
bcast = p;
/* authenticate the passwd based on id and type */
n = (unsigned int)cmd->device_id ^ (unsigned int)type;
cksum(&n, sizeof n, sum);
if (strcmp(pass, sum) != 0)
{
trace_warn("authenticate fail\n");
return 1;
}
if (port <= 0)
return 1;
dd = md_find_device(did);
if( dd )
{
/* mark it online even if it's disabled.
* needed for the manager to identify online devs. */
dd->online = 1;
if( !dd->enabled )
{
return ERR_DEV_DISABLED;
}
}
d = get_device(did);
if( !d )
{
d = dev_create(did);
}
d->type = type;
d->addr = *cmd->saddr;
d->addr.sin_port = htons(port);
d->fileaddr = d->addr;
d->fileaddr.sin_port = htons(port+1);
if (strcmp("none", bcast) == 0)
d->bcast.sin_addr.s_addr = 0;
else
{
d->bcast.sin_addr.s_addr = inet_addr(bcast);
d->bcast.sin_port = htons(BRCAST_PORT);
}
dev_update_data(d);
if (dev_register(d) != 0)
{
/* existing dev ok */
}
dev_activate(d);
if( is_ptc(d) )
{
/* re-set ptc if it's restarted. */
ptc_go_current();
}
if( d->type == DEVTYPE_CHAIR )
{
manage_notify_chair(d);
}
get_client_info(buf, d);
REP_ADD(cmd, "OK");
REP_ADD(cmd, buf);
REP_END(cmd);
return 0;
}
__ATTRIBUTE_REUSE_
INT32 pan_direct_gpio_attach(struct pan_configuration *config)
{
struct pan_device *dev;
struct pan_hw_info *tp;
if (config == NULL || config->hw_info == NULL)
{
return ERR_FAILUE;
}
dev = dev_alloc(pan_direct_gpio_name, HLD_DEV_TYPE_PAN, sizeof(struct pan_device));
if (dev == NULL)
{
PRINTF("Error: Alloc front panel device error!\n");
return ERR_NO_MEM;
}
dev->priv = config->hw_info;
tp = (struct pan_hw_info*)dev->priv;
#ifdef SUPPORT_FIRMWARE_CONFIG
POS_GPIO_POWER_LED = tp->lbd[0].position;
POS_GPIO_POWER_LED_POLAR = tp->lbd[0].polar;
POS_GPIO_STANDBY_LED = tp->lbd[2].position;
POS_GPIO_STANDBY_LED_POLAR = tp->lbd[2].polar;
POS_GPIO_LOCK_LED = tp->lbd[1].position;
POS_GPIO_STANDBY_KEY = tp->flatch.position;
//POS_GPIO_STANDBY_KEY_POLAR = tp->flatch.polar;
POS_GPIO_CHANNEL_UP_KEY = tp->fclock.position;
//POS_GPIO_CHANNEL_UP_KEY_POLAR = tp->fclock.polar;
POS_GPIO_CHANNEL_DOWN_KEY = tp->fdata.position;
//POS_GPIO_CHANNEL_DOWN_KEY_POLAR = tp->fdata.polar;
//keypress_repeat = tp->intv_repeat;
#endif
/* Function point init */
dev->init = pan_direct_gpio_attach;
dev->open = pan_direct_gpio_open;
dev->stop = pan_direct_gpio_close;
dev->do_ioctl = pan_direct_gpio_ioctl;
dev->display = pan_direct_gpio_display;
/* Add this device to queue */
if (dev_register(dev) != SUCCESS)
{
PRINTF("Error: Register panel device error!\n");
dev_free(dev);
return ERR_NO_DEV;
}
return SUCCESS;
}
