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; }