static int g2d_probe(struct platform_device *pdev)
{
struct class_device;
struct class_device *class_dev = NULL;
G2D_INF("\n\n\n===================== G2D probe ======================\n\n\n");
if (alloc_chrdev_region(&g2d_devno, 0, 1, G2D_DEVNAME))
{
G2D_ERR("can't get device major number...\n");
return -EFAULT;
}
G2D_INF("get device major number (%d)\n", g2d_devno);
g2d_cdev = cdev_alloc();
g2d_cdev->owner = THIS_MODULE;
g2d_cdev->ops = &g2d_fops;
cdev_add(g2d_cdev, g2d_devno, 1);
g2d_class = class_create(THIS_MODULE, G2D_DEVNAME);
class_dev = (struct class_device *)device_create(g2d_class, NULL, g2d_devno, NULL, G2D_DEVNAME);
#ifdef G2D_QUEUE
if (_g2d_create_workqueue())
{
G2D_ERR("failed to create workqueue\n");
return -EFAULT;
}
if (_g2d_create_queuebuffer())
{
G2D_ERR("failed to create queue buffer\n");
return -EFAULT;
}
#else
init_waitqueue_head(&isr_wait_queue);
if (!g2d_cmd_buffer)
{
g2d_cmd_buffer = (g2d_command_t *)kzalloc(sizeof(g2d_command_t), GFP_KERNEL);
if (!g2d_cmd_buffer) return -EFAULT;
}
#endif
mt6575_irq_set_sens(MT6575_G2D_IRQ_ID, MT65xx_EDGE_SENSITIVE);
mt6575_irq_set_polarity(MT6575_G2D_IRQ_ID, MT65xx_POLARITY_LOW);
if (request_irq(MT6575_G2D_IRQ_ID, g2d_drv_isr, 0, "G2D ISR" , NULL))
{
G2D_ERR("request irq failed\n");
}
G2D_INF("probe is done\n");
NOT_REFERENCED(class_dev);
return 0;
}
int gpt_irq_init(void)
{
//1. Disable all gpt irq bits
DRV_WriteReg32(GPT_IRQ_EN, 0);
//2. Ack all gpt irq if needed
DRV_WriteReg32(GPT_IRQ_ACK, 0x3F);
//3. Register gpt irq for GIC
mt6575_irq_set_sens(MT6575_GPT_IRQ_ID, MT65xx_LEVEL_SENSITIVE);
mt6575_irq_set_polarity(MT6575_GPT_IRQ_ID, MT65xx_POLARITY_LOW);
return 0;
}
int __init musb_platform_init(struct musb *musb)
{
int err;
if (is_host_enabled(musb)) {
#ifdef CONFIG_USB_MTK_HDRC_HCD
musb->board_set_vbus = mtk_set_vbus;
mt_set_gpio_mode(GPIO_OTG_DRVVBUS_PIN, GPIO_OTG_DRVVBUS_PIN_M_GPIO); //should set GPIO2 as gpio mode.
mt_set_gpio_dir(GPIO_OTG_DRVVBUS_PIN, GPIO_DIR_OUT);
mt_get_gpio_pull_enable(GPIO_OTG_DRVVBUS_PIN);
mt_set_gpio_pull_select(GPIO_OTG_DRVVBUS_PIN, GPIO_PULL_UP);
#endif
}
musb->nIrq = MT6575_USB0_IRQ_ID;
musb->dma_irq= (int)SHARE_IRQ;
musb->fifo_cfg = fifo_cfg;
musb->fifo_cfg_size = ARRAY_SIZE(fifo_cfg);
musb->fifo_cfg_host = fifo_cfg_host;
musb->fifo_cfg_host_size = ARRAY_SIZE(fifo_cfg_host);
mtk_musb->power = FALSE;
mtk_musb->is_host = FALSE;
mtk_musb->fifo_size = 8*1024;
mt6575_irq_set_sens(MT6575_USB0_IRQ_ID, MT65xx_LEVEL_SENSITIVE);
mt65xx_irq_set_polarity(MT6575_USB0_IRQ_ID, MT65xx_POLARITY_LOW);
musb_platform_enable(musb);
musb->isr = mt6575_usb_interrupt;
musb_writel(musb->mregs, MUSB_HSDMA_INTR, 0xff | (0xff << DMA_INTR_UNMASK_SET_OFFSET));
DBG(2, "musb platform init %x\n", musb_readl(musb->mregs,MUSB_HSDMA_INTR));
musb_writel(musb->mregs, USB_L1INTM, TX_INT_STATUS | RX_INT_STATUS | USBCOM_INT_STATUS | DMA_INT_STATUS);
err = device_create_file(musb->controller, &dev_attr_cmode);
return 0;
}
void sc_mod_init(void)
{
mt6575_init_irq();
gpt_irq_init();
mt6575_irq_set_sens(MT6575_SLEEP_IRQ_ID, MT65xx_LEVEL_SENSITIVE);
mt6575_irq_set_polarity(MT6575_SLEEP_IRQ_ID, MT65xx_POLARITY_LOW);
power_saving_init();
slp_pmic_init();
DRV_WriteReg32(CA9_SCU_CONTROL, (DRV_Reg32(CA9_SCU_CONTROL) | (1 << 5))); // enable_scu_standby
DRV_WriteReg32(CA9_SCU_CONTROL, (DRV_Reg32(CA9_SCU_CONTROL) | (1 << 6))); // enable_scu_ic_standby
/* make AP control whole-chip sleep mode */
DRV_WriteReg32(SC_MD_INTF_CON, 0x363f);
if (get_chip_eco_ver() == CHIP_E1) {
/* to workaround AP+MD sleep/wakeup issue */
DRV_WriteReg32(SC_CLK_SETTLE, (3 << 24) | (3 << 16) | 100);
DRV_WriteReg32(SC_MD_INTF_CON, DRV_Reg32(SC_MD_INTF_CON) | (1U << 2));
DRV_WriteReg32(SC_MD_INTF_CON, DRV_Reg32(SC_MD_INTF_CON) & ~(1U << 10));
} else {
/* typical values can cover MD's RM_SYSCLK_SETTLE = 3 ~ 5 ms */
DRV_WriteReg32(SC_CLK_SETTLE, SC_CLK_SETTLE_TYPICAL);
}
/* MTCMOS power-on sequence: CPUSYS(2) -> CPU(0) -> NEON(3) -> DBG(1) */
DRV_WriteReg32(SC_PWR_CON8, (1 << 20) | (3 << 16) | (0 << 12) | (2 << 8));
DRV_WriteReg32(SC_PWR_CON9, 0x000f);
/* bit 17: DVFS_SEL[0] = 1 depends on AP_SRCLKEN (from E2) */
/* bit 7: STANDBYWFI = STANDBYWFI_CPU & L2CC_IDLE & SCU_IDLE (from E2) */
/* bit 4: enable SRCLKENAI pin */
DRV_WriteReg32(SC_CLK_CON, (1U << 17) | (1U << 7) | (1U << 4));
/* if bus clock source is from 3GPLL, make AP be able to control 3GPLL */
if ((DRV_Reg32(TOP_CKMUXSEL) & 0x3) == 0x2)
DRV_WriteReg32(SC_CLK_CON, DRV_Reg32(SC_CLK_CON) | SC_CLK_CON_3GPLLON);
/* set peripheral control to handshake mode */
DRV_WriteReg32(SC_PERI_CON, 0x0081);
DRV_WriteReg32(SC_PAUSE, 0);
/* mask all wakeup sources */
DRV_WriteReg32(SC_WAKEUP_EVENT_MASK, 0xffffffff);
/* for cleaning wakeup source status */
DRV_WriteReg32(SC_DBG_WAKEUP, 0);
DRV_WriteReg32(SC_TIMER_CON, SC_TIMER_CON_DBG | SC_TIMER_CON_EN);
DRV_WriteReg32(SC_TIMER_CMD, SC_TIMER_CMD_KEY | SC_TIMER_CMD_CONWR |
SC_TIMER_CMD_CNTWR | SC_TIMER_CMD_WR);
while (!(DRV_Reg32(SC_TIMER_STA) & SC_TIMER_STA_CMDCPL));
DRV_WriteReg32(SC_ISR_MASK, 0x0007);
DRV_WriteReg32(SC_ISR_STATUS, 0x0007); /* write 1 clear */
printf("[BATTERY] sc_hw_init : Done\r\n");
}
static int accfix_probe(struct platform_device *xxx)
{
int ret = 0;
#ifdef SW_WORK_AROUND_ACCDET_REMOTE_BUTTON_ISSUE
struct task_struct *keyEvent_thread = NULL;
int error=0;
#endif
ACCFIX_DEBUG("[accfix]accfix_probe begin!\n");
//------------------------------------------------------------------
// below register accdet as switch class
//------------------------------------------------------------------
//------------------------------------------------------------------
// Create normal device for auido use
//------------------------------------------------------------------
ret = alloc_chrdev_region(&accfix_devno, 0, 1, ACCFIX_DEVNAME);
if (ret)
{
ACCFIX_DEBUG("[accfix]alloc_chrdev_region: Get Major number error!\n");
return -1;
}
accfix_cdev = cdev_alloc();
accfix_cdev->owner = THIS_MODULE;
accfix_cdev->ops = &accfix_fops;
ret = cdev_add(accfix_cdev, accfix_devno, 1);
if(ret)
{
ACCFIX_DEBUG("[accfix]accfix error: cdev_add\n");
return -1;
}
ACCFIX_DEBUG("[accfix]try create classd\n");
accfix_class = class_create(THIS_MODULE, ACCFIX_DEVNAME);
if (accfix_class == NULL){
ACCFIX_DEBUG("[accfix]class_create failed\n");
return -1;
} else {
ACCFIX_DEBUG("[accfix]class_create success\n");
}
//ACCFIX_DEBUG("[accfix]try destroy device\n");
//device_destroy(accfix_class, accfix_devno);
//ACCFIX_DEBUG("[accfix]destroy device success\n");
// if we want auto creat device node, we must call this
accfix_nor_device = device_create(accfix_class, NULL, accfix_devno, NULL, ACCFIX_DEVNAME);
if (accfix_nor_device == NULL){
ACCFIX_DEBUG("[accfix]device_create failed\n");
return -1;
} else {
ACCFIX_DEBUG("[accfix]device_create success\n");
}
//sys_chmod("/dev/accfix", 777);
/*ACCFIX_DEBUG("[accfix]try device_rename \n");
ret= device_rename(accfix_nor_device, "accdet");
if(ret)
{
ACCFIX_DEBUG("[accfix]device_rename returned:%d!\n", ret);
return -1;
} else {
ACCFIX_DEBUG("[accfix]device_rename success\n");
}
//zzzzz
ACCFIX_DEBUG("[accfix] DEBUG EXIT\n");
return -1;
*/
//switch dev
accfix_data.name = "h2w_test"; //zzz
accfix_data.index = 0;
accfix_data.state = NO_DEVICE;
//zzz
//ACCFIX_DEBUG("[accfix]try switch_dev_unregister returned:%d!\n", ret);
//switch_dev_unregister(&accfix_data);
ret = switch_dev_register(&accfix_data);
if(ret)
{
ACCFIX_DEBUG("[accfix]switch_dev_register returned:%d!\n", ret);
return -1; //switch doesnt matter - just an icon in taskbar
}
//------------------------------------------------------------------make: *** [_module_../med
// Create input device
//------------------------------------------------------------------
kpd_accfix_dev = input_allocate_device();
if (!kpd_accfix_dev)
{
ACCFIX_DEBUG("[accfix]kpd_accfix_dev : fail!\n");
return -ENOMEM;
}
__set_bit(EV_KEY, kpd_accfix_dev->evbit);
__set_bit(KEY_CALL, kpd_accfix_dev->keybit);
__set_bit(KEY_ENDCALL, kpd_accfix_dev->keybit);
//longxuewei add
__set_bit(KEY_F24, kpd_accfix_dev->keybit);
__set_bit(114, kpd_accfix_dev->keybit);
__set_bit(115, kpd_accfix_dev->keybit);
__set_bit(163, kpd_accfix_dev->keybit);
__set_bit(165, kpd_accfix_dev->keybit);
__set_bit(226, kpd_accfix_dev->keybit);
//longxuewei add end
kpd_accfix_dev->id.bustype = BUS_HOST;
kpd_accfix_dev->name = "ACCFIX";
if(input_register_device(kpd_accfix_dev))
{
ACCFIX_DEBUG("[accfix]kpd_accfix_dev register : fail!\n");
}else
{
ACCFIX_DEBUG("[accfix]kpd_accfix_dev register : success!!\n");
}
//------------------------------------------------------------------
// Create workqueue
//------------------------------------------------------------------
accfix_workqueue = create_singlethread_workqueue("accfix");
INIT_WORK(&accfix_work, accfix_work_callback);
#ifdef ACCFIX_EINT
accfix_eint_workqueue = create_singlethread_workqueue("accfix_eint");
INIT_WORK(&accfix_eint_work, accfix_eint_work_callback);
accfix_setup_eint();
#endif
/* #if defined(SUPPORT_CALLINGLIGHT)
hrtimer_init(&accfix_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
accfix_timer.function = calling_light_decate;
#endif */
//------------------------------------------------------------------
// wake lock
//------------------------------------------------------------------
wake_lock_init(&accfix_suspend_lock, WAKE_LOCK_SUSPEND, "accfix wakelock");
#ifdef SW_WORK_AROUND_ACCDET_REMOTE_BUTTON_ISSUE
init_waitqueue_head(&send_event_wq);
//start send key event thread
keyEvent_thread = kthread_run(sendKeyEvent, 0, "keyEvent_send");
if (IS_ERR(keyEvent_thread))
{
error = PTR_ERR(keyEvent_thread);
ACCFIX_DEBUG( " failed to create kernel thread: %d\n", error);
}
#endif
#if DEBUG_THREAD
if((ret = accfix_create_attr(&accfix_driver.driver)))
{
ACCFIX_DEBUG("create attribute err = %d\n", ret);
}
#endif
/* For early porting before audio driver add */
//temp_func();
ACCFIX_DEBUG("[accfix]accfix_probe : ACCFIX_INIT\n");
if (g_accfix_first == 1)
{
long_press_time_ns = (s64)long_press_time * NSEC_PER_MSEC;
//Accdet Hardware Init
accfix_init();
//mt6575_irq_set_sens(MT6575_ACCDET_IRQ_ID, MT65xx_EDGE_SENSITIVE);
mt6575_irq_set_sens(MT6575_ACCDET_IRQ_ID, MT65xx_LEVEL_SENSITIVE);
mt6575_irq_set_polarity(MT6575_ACCDET_IRQ_ID, MT65xx_POLARITY_LOW);
//register accdet interrupt
ret = request_irq(MT6575_ACCDET_IRQ_ID, accfix_irq_handler, 0, "ACCFIX", NULL);
if(ret)
{
ACCFIX_DEBUG("[accfix]accfix register interrupt error\n");
ACCFIX_DEBUG("[accfix]try free IRQ\n");
free_irq(MT6575_ACCDET_IRQ_ID,NULL);
ACCFIX_DEBUG("[accfix]IRQ freed success\n");
ret = request_irq(MT6575_ACCDET_IRQ_ID, accfix_irq_handler, 0, "ACCFIX", NULL);
if(ret){
ACCFIX_DEBUG("[accfix]accfix register interrupt error twice\n");
}
}
queue_work(accfix_workqueue, &accfix_work); //schedule a work for the first detection
g_accfix_first = 0;
}
ACCFIX_DEBUG("[accfix]accfix_probe done!\n");
return 0;
}
