static int mdss_dsi_cmd_dma_tx(struct mdss_dsi_ctrl_pdata *ctrl, struct dsi_buf *tp) { int len, ret = 0; int domain = MDSS_IOMMU_DOMAIN_UNSECURE; char *bp; unsigned long size, addr; #ifdef DEBUG_CMD int i; bp = tp->data; pr_info("%s: ", __func__); for (i = 0; i < tp->len; i++) printk("%x ", *bp++); pr_info("\n"); #endif bp = tp->data; len = ALIGN(tp->len, 4); size = ALIGN(tp->len, SZ_4K); #if !defined(CONFIG_MACH_S3VE3G_EUR) tp->dmap = dma_map_single(&dsi_dev, tp->data, size, DMA_TO_DEVICE); if (dma_mapping_error(&dsi_dev, tp->dmap)) { pr_err("%s: dmap mapp failed\n", __func__); return -ENOMEM; } #endif if (is_mdss_iommu_attached()) { int ret = msm_iommu_map_contig_buffer(tp->dmap, mdss_get_iommu_domain(domain), 0, size, SZ_4K, 0, &(addr)); if (IS_ERR_VALUE(ret)) { pr_err("unable to map dma memory to iommu(%d)\n", ret); return -ENOMEM; } } else { addr = tp->dmap; } INIT_COMPLETION(ctrl->dma_comp); if (ctrl->shared_pdata.broadcast_enable) if ((ctrl->ndx == DSI_CTRL_1) && (left_ctrl_pdata != NULL)) { MIPI_OUTP(left_ctrl_pdata->ctrl_base + 0x048, addr); MIPI_OUTP(left_ctrl_pdata->ctrl_base + 0x04c, len); } MIPI_OUTP((ctrl->ctrl_base) + 0x048, addr); MIPI_OUTP((ctrl->ctrl_base) + 0x04c, len); wmb(); if (ctrl->shared_pdata.broadcast_enable) if ((ctrl->ndx == DSI_CTRL_1) && (left_ctrl_pdata != NULL)) { MIPI_OUTP(left_ctrl_pdata->ctrl_base + 0x090, 0x01); } MIPI_OUTP((ctrl->ctrl_base) + 0x090, 0x01); /* trigger */ wmb(); ret = wait_for_completion_timeout(&ctrl->dma_comp, msecs_to_jiffies(DMA_TX_TIMEOUT)); if (ret == 0) { #if defined (CONFIG_FB_MSM_MDSS_DSI_DBG) dumpreg(); mdp5_dump_regs(); mdss_dsi_dump_power_clk(&ctrl->panel_data, 0); mdss_mdp_dump_power_clk(); mdss_mdp_debug_bus(); xlog_dump(); #endif pr_err("dma tx timeout!!\n"); ret = -ETIMEDOUT; } else ret = tp->len; if (is_mdss_iommu_attached()) msm_iommu_unmap_contig_buffer(addr, mdss_get_iommu_domain(domain), 0, size); return ret; }
static ssize_t afe_debug_write(struct file *filp, const char __user *ubuf, size_t cnt, loff_t *ppos) { char *lb_str = filp->private_data; char lbuf[32]; int rc; unsigned long param[5]; if (cnt > sizeof(lbuf) - 1) return -EINVAL; rc = copy_from_user(lbuf, ubuf, cnt); if (rc) return -EFAULT; lbuf[cnt] = '\0'; if (!strcmp(lb_str, "afe_loopback")) { rc = afe_get_parameters(lbuf, param, 3); if (!rc) { pr_info("%s %lu %lu %lu\n", lb_str, param[0], param[1], param[2]); if ((param[0] != AFE_LOOPBACK_ON) && (param[0] != AFE_LOOPBACK_OFF)) { pr_err("%s: Error, parameter 0 incorrect\n", __func__); rc = -EINVAL; goto afe_error; } if ((afe_validate_port(param[1]) < 0) || (afe_validate_port(param[2])) < 0) { pr_err("%s: Error, invalid afe port\n", __func__); } if (this_afe.apr == NULL) { pr_err("%s: Error, AFE not opened\n", __func__); rc = -EINVAL; } else { rc = afe_loopback(param[0], param[1], param[2]); } } else { pr_err("%s: Error, invalid parameters\n", __func__); rc = -EINVAL; } } else if (!strcmp(lb_str, "afe_loopback_gain")) { rc = afe_get_parameters(lbuf, param, 2); if (!rc) { pr_info("%s %lu %lu\n", lb_str, param[0], param[1]); if (afe_validate_port(param[0]) < 0) { pr_err("%s: Error, invalid afe port\n", __func__); rc = -EINVAL; goto afe_error; } if (param[1] < 0 || param[1] > 100) { pr_err("%s: Error, volume shoud be 0 to 100" " percentage param = %lu\n", __func__, param[1]); rc = -EINVAL; goto afe_error; } param[1] = (Q6AFE_MAX_VOLUME * param[1]) / 100; if (this_afe.apr == NULL) { pr_err("%s: Error, AFE not opened\n", __func__); rc = -EINVAL; } else { rc = afe_loopback_gain(param[0], param[1]); } } else { pr_err("%s: Error, invalid parameters\n", __func__); rc = -EINVAL; } } afe_error: if (rc == 0) rc = cnt; else pr_err("%s: rc = %d\n", __func__, rc); return rc; }
static int audio_open(struct inode *inode, struct file *file) { struct q6audio_aio *audio = NULL; int rc = 0; struct msm_audio_aac_config *aac_config = NULL; #ifdef CONFIG_DEBUG_FS /* 4 bytes represents decoder number, 1 byte for terminate string */ char name[sizeof "msm_aac_" + 5]; #endif audio = kzalloc(sizeof(struct q6audio_aio), GFP_KERNEL); if (audio == NULL) { pr_err("Could not allocate memory for aac decode driver\n"); return -ENOMEM; } audio->codec_cfg = kzalloc(sizeof(struct msm_audio_aac_config), GFP_KERNEL); if (audio->codec_cfg == NULL) { pr_err("%s:Could not allocate memory for aac" "config\n", __func__); kfree(audio); return -ENOMEM; } aac_config = audio->codec_cfg; /* Settings will be re-config at AUDIO_SET_CONFIG, * but at least we need to have initial config */ audio->pcm_cfg.buffer_size = PCM_BUFSZ_MIN_AAC; aac_config->dual_mono_mode = AUDIO_AAC_DUAL_MONO_INVALID; audio->ac = q6asm_audio_client_alloc((app_cb) q6_audio_cb, (void *)audio); if (!audio->ac) { pr_err("Could not allocate memory for audio client\n"); kfree(audio->codec_cfg); kfree(audio); return -ENOMEM; } /* open in T/NT mode */ if ((file->f_mode & FMODE_WRITE) && (file->f_mode & FMODE_READ)) { rc = q6asm_open_read_write(audio->ac, FORMAT_LINEAR_PCM, FORMAT_MPEG4_AAC); if (rc < 0) { pr_err("NT mode Open failed rc=%d\n", rc); rc = -ENODEV; goto fail; } audio->feedback = NON_TUNNEL_MODE; /* open AAC decoder, expected frames is always 1 audio->buf_cfg.frames_per_buf = 0x01;*/ audio->buf_cfg.meta_info_enable = 0x01; } else if ((file->f_mode & FMODE_WRITE) && !(file->f_mode & FMODE_READ)) { rc = q6asm_open_write(audio->ac, FORMAT_MPEG4_AAC); if (rc < 0) { pr_err("T mode Open failed rc=%d\n", rc); rc = -ENODEV; goto fail; } audio->feedback = TUNNEL_MODE; audio->buf_cfg.meta_info_enable = 0x00; } else { pr_err("Not supported mode\n"); rc = -EACCES; goto fail; } rc = audio_aio_open(audio, file); #ifdef CONFIG_DEBUG_FS snprintf(name, sizeof name, "msm_aac_%04x", audio->ac->session); audio->dentry = debugfs_create_file(name, S_IFREG | S_IRUGO, NULL, (void *)audio, &audio_aac_debug_fops); if (IS_ERR(audio->dentry)) pr_debug("debugfs_create_file failed\n"); #endif pr_info("%s:aacdec success mode[%d]session[%d]\n", __func__, audio->feedback, audio->ac->session); return rc; fail: q6asm_audio_client_free(audio->ac); kfree(audio->codec_cfg); kfree(audio); return rc; }
static ssize_t pn547_dev_read(struct file *filp, char __user *buf, size_t count, loff_t *offset) { struct pn547_dev *pn547_dev = filp->private_data; char tmp[MAX_BUFFER_SIZE] = {0, }; int ret = 0; #ifdef CONFIG_NFC_PN544 int readingWatchdog = 0; #endif if (count > MAX_BUFFER_SIZE) count = MAX_BUFFER_SIZE; pr_debug("%s : reading %zu bytes. irq=%s\n", __func__, count, gpio_get_value(pn547_dev->irq_gpio) ? "1" : "0"); #if NFC_DEBUG pr_info("pn547 : + r\n"); #endif mutex_lock(&pn547_dev->read_mutex); #ifdef CONFIG_NFC_PN544 wait_irq: #endif if (!gpio_get_value(pn547_dev->irq_gpio)) { atomic_set(&pn547_dev->read_flag, 0); if (filp->f_flags & O_NONBLOCK) { pr_info("%s : O_NONBLOCK\n", __func__); ret = -EAGAIN; goto fail; } #if NFC_DEBUG pr_info("pn547: wait_event_interruptible : in\n"); #endif if (!gpio_get_value(pn547_dev->irq_gpio)) ret = wait_event_interruptible(pn547_dev->read_wq, atomic_read(&pn547_dev->read_flag)); #if NFC_DEBUG pr_info("pn547 : h\n"); #endif if (pn547_dev->cancel_read) { pn547_dev->cancel_read = false; ret = -1; goto fail; } if (ret) goto fail; } /* Read data */ ret = i2c_master_recv(pn547_dev->client, tmp, count); #ifdef CONFIG_NFC_PN544 /* If bad frame(from 0x51 to 0x57) is received from pn65n, * we need to read again after waiting that IRQ is down. * if data is not ready, pn65n will send from 0x51 to 0x57. */ if ((I2C_ADDR_READ_L <= tmp[0] && tmp[0] <= I2C_ADDR_READ_H) && readingWatchdog < MAX_TRY_I2C_READ) { pr_warn("%s: data is not ready yet.data = 0x%x, cnt=%d\n", __func__, tmp[0], readingWatchdog); usleep_range(2000, 2000); /* sleep 2ms to wait for IRQ */ readingWatchdog++; goto wait_irq; } #endif #if NFC_DEBUG pr_info("pn547: i2c_master_recv\n"); #endif mutex_unlock(&pn547_dev->read_mutex); if (ret < 0) { pr_err("%s: i2c_master_recv returned %d\n", __func__, ret); return ret; } if (ret > count) { pr_err("%s: received too many bytes from i2c (%d)\n", __func__, ret); return -EIO; } if (copy_to_user(buf, tmp, ret)) { pr_err("%s : failed to copy to user space\n", __func__); return -EFAULT; } return ret; fail: mutex_unlock(&pn547_dev->read_mutex); return ret; }
static int pn547_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; int err; int addr; char tmp[4] = {0x20, 0x00, 0x01, 0x01}; int addrcnt; struct pn547_i2c_platform_data *platform_data; struct pn547_dev *pn547_dev; #ifdef CONFIG_MACH_VICTORLTE_CTC pr_info("%s : start system_rev : %d\n", __func__,system_rev); if (system_rev < 3) { pr_info("%s : probe fail \n", __func__); return -ENODEV; } #endif if (client->dev.of_node) { platform_data = devm_kzalloc(&client->dev, sizeof(struct pn547_i2c_platform_data), GFP_KERNEL); if (!platform_data) { dev_err(&client->dev, "Failed to allocate memory\n"); return -ENOMEM; } err = pn547_parse_dt(&client->dev, platform_data); if (err) return err; } else { platform_data = client->dev.platform_data; } if (platform_data == NULL) { pr_err("%s : nfc probe fail\n", __func__); return -ENODEV; } if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { pr_err("%s : need I2C_FUNC_I2C\n", __func__); return -ENODEV; } ret = gpio_request(platform_data->irq_gpio, "nfc_int"); if (ret) return -ENODEV; ret = gpio_request(platform_data->ven_gpio, "nfc_ven"); if (ret) goto err_ven; ret = gpio_request(platform_data->firm_gpio, "nfc_firm"); if (ret) goto err_firm; #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST ret = gpio_request(platform_data->clk_req_gpio, "nfc_clk_req"); if (ret) goto err_clk_req; #endif #ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2 ret = gpio_request(platform_data->clk_req_gpio, "nfc_clk_req"); if (ret) goto err_clk_req; #endif pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL); if (pn547_dev == NULL) { dev_err(&client->dev, "failed to allocate memory for module data\n"); ret = -ENOMEM; goto err_exit; } #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->nfc_clock = msm_xo_get(MSM_XO_TCXO_A1, "nfc"); if (IS_ERR(pn547_dev->nfc_clock)) { ret = PTR_ERR(pn547_dev->nfc_clock); printk(KERN_ERR "%s: Couldn't get TCXO_A1 vote for NFC (%d)\n", __func__, ret); ret = -ENODEV; goto err_get_clock; } pn547_dev->clock_state = false; #endif #ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2 pn547_dev->nfc_clock = clk_get(NULL, "nfc_clock"); if (IS_ERR(pn547_dev->nfc_clock)) { ret = PTR_ERR(pn547_dev->nfc_clock); printk(KERN_ERR "%s: Couldn't get D1 (%d)\n", __func__, ret); } else { if (clk_prepare_enable(pn547_dev->nfc_clock)) printk(KERN_ERR "%s: Couldn't prepare D1\n", __func__); } #endif #ifdef CONFIG_NFC_PN547_PMC8974_CLK_REQ #ifdef CONFIG_NFC_I2C_OVERWRITE pn547_dev->nfc_clk = clk_get(NULL, "nfc_clk"); #else pn547_dev->nfc_clk = clk_get(&client->dev, "nfc_clk"); #endif if (IS_ERR(pn547_dev->nfc_clk)) { ret = PTR_ERR(pn547_dev->nfc_clk); printk(KERN_ERR "%s: Couldn't get D1 (%d)\n", __func__, ret); } else { if (clk_prepare_enable(pn547_dev->nfc_clk)) printk(KERN_ERR "%s: Couldn't prepare D1\n", __func__); } #endif pr_info("%s : IRQ num %d\n", __func__, client->irq); pn547_dev->irq_gpio = platform_data->irq_gpio; pn547_dev->ven_gpio = platform_data->ven_gpio; pn547_dev->firm_gpio = platform_data->firm_gpio; pn547_dev->conf_gpio = platform_data->conf_gpio; #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->clk_req_gpio = platform_data->clk_req_gpio; pn547_dev->clk_req_irq = platform_data->clk_req_irq; #endif #ifdef CONFIG_NFC_PN547_8226_USE_BBCLK2 pn547_dev->clk_req_gpio = platform_data->clk_req_gpio; #endif pn547_dev->client = client; /* init mutex and queues */ init_waitqueue_head(&pn547_dev->read_wq); mutex_init(&pn547_dev->read_mutex); pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR; #ifdef CONFIG_NFC_PN547 pn547_dev->pn547_device.name = "pn547"; #else pn547_dev->pn547_device.name = "pn544"; #endif pn547_dev->pn547_device.fops = &pn547_dev_fops; ret = misc_register(&pn547_dev->pn547_device); if (ret) { pr_err("%s : misc_register failed\n", __FILE__); goto err_misc_register; } /* request irq. the irq is set whenever the chip has data available * for reading. it is cleared when all data has been read. */ pr_info("%s : requesting IRQ %d\n", __func__, client->irq); gpio_direction_input(pn547_dev->irq_gpio); gpio_direction_output(pn547_dev->ven_gpio, 0); gpio_direction_output(pn547_dev->firm_gpio, 0); #if defined(CONFIG_NFC_PN547_CLOCK_REQUEST) || defined(CONFIG_NFC_PN547_8226_USE_BBCLK2) gpio_direction_input(pn547_dev->clk_req_gpio); #endif i2c_set_clientdata(client, pn547_dev); wake_lock_init(&pn547_dev->nfc_wake_lock, WAKE_LOCK_SUSPEND, "nfc_wake_lock"); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST pn547_dev->wq_clock = create_singlethread_workqueue("nfc_wq"); if (!pn547_dev->wq_clock) { ret = -ENOMEM; pr_err("%s: could not create workqueue\n", __func__); goto err_create_workqueue; } INIT_WORK(&pn547_dev->work_nfc_clock, nfc_work_func_clock); #endif if(client->irq <=0) { pr_info("%s : [Before] requesting IRQ %d\n", __func__, client->irq); client->irq = gpio_to_irq(pn547_dev->irq_gpio); pr_info("%s : [After] requesting IRQ %d\n", __func__, client->irq); } ret = request_irq(client->irq, pn547_dev_irq_handler, IRQF_TRIGGER_RISING, "pn547", pn547_dev); if (ret) { dev_err(&client->dev, "request_irq failed\n"); goto err_request_irq_failed; } disable_irq_nosync(pn547_dev->client->irq); atomic_set(&pn547_dev->irq_enabled, 0); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST ret = request_irq(pn547_dev->clk_req_irq, pn547_dev_clk_req_irq_handler, IRQF_SHARED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING , "pn547_clk_req", pn547_dev); if (ret) { dev_err(&client->dev, "request_irq(clk_req) failed\n"); goto err_request_irq_failed; } enable_irq_wake(pn547_dev->clk_req_irq); #endif gpio_set_value(pn547_dev->ven_gpio, 1); gpio_set_value(pn547_dev->firm_gpio, 1); /* add firmware pin */ usleep_range(4900, 5000); gpio_set_value(pn547_dev->ven_gpio, 0); usleep_range(4900, 5000); gpio_set_value(pn547_dev->ven_gpio, 1); usleep_range(4900, 5000); for (addr = 0x2B; addr > 0x27; addr--) { client->addr = addr; addrcnt = 2; do { ret = i2c_master_send(client, tmp, 4); if (ret > 0) { pr_info("%s : i2c addr=0x%X\n", __func__, client->addr); break; } } while (addrcnt--); if (ret > 0) break; } if(ret <= 0) client->addr = 0x2B; gpio_set_value(pn547_dev->ven_gpio, 0); gpio_set_value(pn547_dev->firm_gpio, 0); /* add */ if (ret < 0) pr_err("%s : fail to get i2c addr\n", __func__); /* goto err_request_irq_failed; */ else pr_info("%s : success\n", __func__); return 0; err_request_irq_failed: #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST err_create_workqueue: #endif misc_deregister(&pn547_dev->pn547_device); wake_lock_destroy(&pn547_dev->nfc_wake_lock); err_misc_register: mutex_destroy(&pn547_dev->read_mutex); #ifdef CONFIG_NFC_PN547_CLOCK_REQUEST msm_xo_put(pn547_dev->nfc_clock); err_get_clock: #endif kfree(pn547_dev); err_exit: #if defined(CONFIG_NFC_PN547_CLOCK_REQUEST) || defined(CONFIG_NFC_PN547_8226_USE_BBCLK2) gpio_free(platform_data->clk_req_gpio); err_clk_req: #endif gpio_free(platform_data->firm_gpio); err_firm: gpio_free(platform_data->ven_gpio); err_ven: gpio_free(platform_data->irq_gpio); pr_err("[pn547] pn547_probe fail!\n"); return ret; }
static int __init amd_iommu_v2_init(void) { pr_info("AMD IOMMUv2 driver by Joerg Roedel <*****@*****.**>"); return 0; }
static int __init DC_FBDEV_init(void) { static DC_DEVICE_FUNCTIONS sDCFunctions = { .pfnGetInfo = DC_FBDEV_GetInfo, .pfnPanelQueryCount = DC_FBDEV_PanelQueryCount, .pfnPanelQuery = DC_FBDEV_PanelQuery, .pfnFormatQuery = DC_FBDEV_FormatQuery, .pfnDimQuery = DC_FBDEV_DimQuery, .pfnSetBlank = IMG_NULL, .pfnSetVSyncReporting = IMG_NULL, .pfnLastVSyncQuery = IMG_NULL, .pfnContextCreate = DC_FBDEV_ContextCreate, .pfnContextDestroy = DC_FBDEV_ContextDestroy, .pfnContextConfigure = DC_FBDEV_ContextConfigure, .pfnContextConfigureCheck = DC_FBDEV_ContextConfigureCheck, .pfnBufferAlloc = DC_FBDEV_BufferAlloc, .pfnBufferAcquire = DC_FBDEV_BufferAcquire, .pfnBufferRelease = DC_FBDEV_BufferRelease, .pfnBufferFree = DC_FBDEV_BufferFree, }; struct fb_info *psLINFBInfo; IMG_PIXFMT ePixFormat; int err = -ENODEV; psLINFBInfo = registered_fb[0]; if(!psLINFBInfo) { pr_err("No Linux framebuffer (fbdev) device is registered!\n" "Check you have a framebuffer driver compiled into your " "kernel\nand that it is enabled on the cmdline.\n"); goto err_out; } if(!lock_fb_info(psLINFBInfo)) goto err_out; console_lock(); /* Filter out broken FB devices */ if(!psLINFBInfo->fix.smem_len || !psLINFBInfo->fix.line_length) { pr_err("The fbdev device detected had a zero smem_len or " "line_length,\nwhich suggests it is a broken driver.\n"); goto err_unlock; } if(psLINFBInfo->fix.type != FB_TYPE_PACKED_PIXELS || psLINFBInfo->fix.visual != FB_VISUAL_TRUECOLOR) { pr_err("The fbdev device detected is not truecolor with packed " "pixels.\n"); goto err_unlock; } if(psLINFBInfo->var.bits_per_pixel == 32) { if(psLINFBInfo->var.red.length != 8 || psLINFBInfo->var.green.length != 8 || psLINFBInfo->var.blue.length != 8 /*|| psLINFBInfo->var.red.offset != 16 || psLINFBInfo->var.green.offset != 8 || psLINFBInfo->var.blue.offset != 0 */) // MTK: supports RGBA { pr_err("The fbdev device detected uses an unrecognized " "32bit pixel format (%u/%u/%u, %u/%u/%u)\n", psLINFBInfo->var.red.length, psLINFBInfo->var.green.length, psLINFBInfo->var.blue.length, psLINFBInfo->var.red.offset, psLINFBInfo->var.green.offset, psLINFBInfo->var.blue.offset); goto err_unlock; } // MTK: supports RGBA if(psLINFBInfo->var.red.offset == 0 || psLINFBInfo->var.green.offset == 8 || psLINFBInfo->var.blue.offset == 16 ) { ePixFormat = IMG_PIXFMT_R8G8B8A8_UNORM; } else { #if defined(DC_FBDEV_FORCE_XRGB8888) ePixFormat = IMG_PIXFMT_B8G8R8X8_UNORM; #else ePixFormat = IMG_PIXFMT_B8G8R8A8_UNORM; #endif } } else if(psLINFBInfo->var.bits_per_pixel == 16) { if(psLINFBInfo->var.red.length != 5 || psLINFBInfo->var.green.length != 6 || psLINFBInfo->var.blue.length != 5 || psLINFBInfo->var.red.offset != 11 || psLINFBInfo->var.green.offset != 5 || psLINFBInfo->var.blue.offset != 0) { pr_err("The fbdev device detected uses an unrecognized " "16bit pixel format (%u/%u/%u, %u/%u/%u)\n", psLINFBInfo->var.red.length, psLINFBInfo->var.green.length, psLINFBInfo->var.blue.length, psLINFBInfo->var.red.offset, psLINFBInfo->var.green.offset, psLINFBInfo->var.blue.offset); goto err_unlock; } ePixFormat = IMG_PIXFMT_B5G6R5_UNORM; } else { pr_err("The fbdev device detected uses an unsupported " "bpp (%u).\n", psLINFBInfo->var.bits_per_pixel); goto err_unlock; } if(!try_module_get(psLINFBInfo->fbops->owner)) { pr_err("try_module_get() failed"); goto err_unlock; } if(psLINFBInfo->fbops->fb_open && psLINFBInfo->fbops->fb_open(psLINFBInfo, 0) != 0) { pr_err("fb_open() failed"); goto err_module_put; } gpsDeviceData = kmalloc(sizeof(DC_FBDEV_DEVICE), GFP_KERNEL); if(!gpsDeviceData) goto err_module_put; gpsDeviceData->psLINFBInfo = psLINFBInfo; gpsDeviceData->ePixFormat = ePixFormat; if(DCRegisterDevice(&sDCFunctions, MAX_COMMANDS_IN_FLIGHT, gpsDeviceData, &gpsDeviceData->hSrvHandle) != PVRSRV_OK) goto err_kfree; gpsDeviceData->bCanFlip = DC_FBDEV_FlipPossible(psLINFBInfo); pr_info("Found usable fbdev device (%s):\n" "range (physical) = 0x%lx-0x%lx\n" "size (bytes) = 0x%x\n" "xres x yres = %ux%u\n" "xres x yres (v) = %ux%u\n" "img pix fmt = %u\n" "flipping? = %d\n", psLINFBInfo->fix.id, psLINFBInfo->fix.smem_start, psLINFBInfo->fix.smem_start + psLINFBInfo->fix.smem_len, psLINFBInfo->fix.smem_len, psLINFBInfo->var.xres, psLINFBInfo->var.yres, psLINFBInfo->var.xres_virtual, psLINFBInfo->var.yres_virtual, ePixFormat, gpsDeviceData->bCanFlip); err = 0; err_unlock: console_unlock(); unlock_fb_info(psLINFBInfo); err_out: return err; err_kfree: kfree(gpsDeviceData); err_module_put: module_put(psLINFBInfo->fbops->owner); goto err_unlock; }
/* * netvsc_device_add - Callback when the device belonging to this * driver is added */ int netvsc_device_add(struct hv_device *device, void *additional_info) { int ret = 0; int ring_size = ((struct netvsc_device_info *)additional_info)->ring_size; struct netvsc_device *net_device; struct net_device *ndev; net_device = alloc_net_device(device); if (!net_device) return -ENOMEM; net_device->ring_size = ring_size; /* * Coming into this function, struct net_device * is * registered as the driver private data. * In alloc_net_device(), we register struct netvsc_device * * as the driver private data and stash away struct net_device * * in struct netvsc_device *. */ ndev = net_device->ndev; /* Add netvsc_device context to netvsc_device */ net_device->nd_ctx = netdev_priv(ndev); /* Initialize the NetVSC channel extension */ init_completion(&net_device->channel_init_wait); set_per_channel_state(device->channel, net_device->cb_buffer); /* Open the channel */ ret = vmbus_open(device->channel, ring_size * PAGE_SIZE, ring_size * PAGE_SIZE, NULL, 0, netvsc_channel_cb, device->channel); if (ret != 0) { netdev_err(ndev, "unable to open channel: %d\n", ret); goto cleanup; } /* Channel is opened */ pr_info("hv_netvsc channel opened successfully\n"); net_device->chn_table[0] = device->channel; /* Connect with the NetVsp */ ret = netvsc_connect_vsp(device); if (ret != 0) { netdev_err(ndev, "unable to connect to NetVSP - %d\n", ret); goto close; } return ret; close: /* Now, we can close the channel safely */ vmbus_close(device->channel); cleanup: free_netvsc_device(net_device); return ret; }
ssize_t k330_gyro_selftest(char *buf, struct ssp_data *data) { char chTempBuf[36] = { 0,}; u8 uFifoPass = 2; u8 uBypassPass = 2; u8 uCalPass = 0; u8 dummy[2] = {0,}; s16 iNOST[3] = {0,}, iST[3] = {0,}, iCalData[3] = {0,}; s16 iZeroRateData[3] = {0,}, fifo_data[4] = {0,}; int iRet = 0; struct ssp_msg *msg = kzalloc(sizeof(*msg), GFP_KERNEL); msg->cmd = GYROSCOPE_FACTORY; msg->length = 36; msg->options = AP2HUB_READ; msg->buffer = chTempBuf; msg->free_buffer = 0; iRet = ssp_spi_sync(data, msg, 5000); if (iRet != SUCCESS) { pr_err("[SSP]: %s - Gyro Selftest Timeout!!\n", __func__); goto exit; } data->uTimeOutCnt = 0; iNOST[0] = (s16)((chTempBuf[0] << 8) + chTempBuf[1]); iNOST[1] = (s16)((chTempBuf[2] << 8) + chTempBuf[3]); iNOST[2] = (s16)((chTempBuf[4] << 8) + chTempBuf[5]); iST[0] = (s16)((chTempBuf[6] << 8) + chTempBuf[7]); iST[1] = (s16)((chTempBuf[8] << 8) + chTempBuf[9]); iST[2] = (s16)((chTempBuf[10] << 8) + chTempBuf[11]); iCalData[0] = (s16)((chTempBuf[12] << 8) + chTempBuf[13]); iCalData[1] =( s16)((chTempBuf[14] << 8) + chTempBuf[15]); iCalData[2] = (s16)((chTempBuf[16] << 8) + chTempBuf[17]); iZeroRateData[0] = (s16)((chTempBuf[18] << 8) + chTempBuf[19]); iZeroRateData[1] = (s16)((chTempBuf[20] << 8) + chTempBuf[21]); iZeroRateData[2] = (s16)((chTempBuf[22] << 8) + chTempBuf[23]); fifo_data[0] = chTempBuf[24]; fifo_data[1] = (s16)((chTempBuf[25] << 8) + chTempBuf[26]); fifo_data[2] = (s16)((chTempBuf[27] << 8) + chTempBuf[28]); fifo_data[3] = (s16)((chTempBuf[29] << 8) + chTempBuf[30]); uCalPass = chTempBuf[31]; uFifoPass = chTempBuf[32]; uBypassPass = chTempBuf[33]; dummy[0] = chTempBuf[34]; dummy[1] = chTempBuf[35]; pr_info("[SSP] %s dummy = 0x%X, 0x%X\n", __func__, dummy[0], dummy[1]); if (uFifoPass && uBypassPass && uCalPass) save_gyro_caldata(data, iCalData); ssp_dbg("[SSP]: %s - %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n", __func__, iNOST[0], iNOST[1], iNOST[2], iST[0], iST[1], iST[2], iZeroRateData[0], iZeroRateData[1], iZeroRateData[2], fifo_data[0], fifo_data[1], fifo_data[2], fifo_data[3], uFifoPass & uBypassPass & uCalPass, uFifoPass, uCalPass); exit: return sprintf(buf, "%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n", iNOST[0], iNOST[1], iNOST[2], iST[0], iST[1], iST[2], iZeroRateData[0], iZeroRateData[1], iZeroRateData[2], fifo_data[0], fifo_data[1], fifo_data[2], fifo_data[3], uFifoPass & uBypassPass & uCalPass, uFifoPass, uCalPass); }
static int load_kernel_fw_bootmode(struct i2c_client *client, const char *pFn) { const struct firmware *fw = NULL; unsigned int uFrameSize; unsigned int uPos = 0; int iRet; int iCheckFrameCrcError = 0; int iCheckWatingFrameDataError = 0; int count = 0; struct ssp_data *data = i2c_get_clientdata(client); pr_info("[SSP] ssp_load_fw start!!!\n"); iRet = request_firmware(&fw, pFn, &client->dev); if (iRet) { pr_err("[SSP]: %s - Unable to open firmware %s\n", __func__, pFn); return iRet; } /* Unlock bootloader */ iRet = unlock_bootloader(client); if (iRet < 0) { pr_err("[SSP] %s - unlock_bootloader failed! %d\n", __func__, iRet); goto out; } while (uPos < fw->size) { if (data->ssp_changes == SSP_MCU_L5) { iRet = ssp_wait_for_chg(data); if (iRet < 0) { pr_err("[SSP] %s - ssp_wait_for_chg failed! %d\n", __func__, iRet); goto out; } } iRet = check_bootloader(client, BL_WAITING_FRAME_DATA); if (iRet) { iCheckWatingFrameDataError++; if (iCheckWatingFrameDataError > 10) { pr_err("[SSP]: %s - F/W update fail\n", __func__); goto out; } else { pr_err("[SSP]: %s - F/W data_error %d, retry\n", __func__, iCheckWatingFrameDataError); continue; } } uFrameSize = ((*(fw->data + uPos) << 8) | *(fw->data + uPos + 1)); /* We should add 2 at frame size as the the firmware data is not * included the CRC bytes. */ uFrameSize += 2; /* Write one frame to device */ fw_write(client, fw->data + uPos, uFrameSize); if (data->ssp_changes == SSP_MCU_L5) { iRet = ssp_wait_for_chg(data); if (iRet < 0) { pr_err("[SSP] %s - ssp_wait_for_chg failed! %d\n", __func__, iRet); goto out; } } iRet = check_bootloader(client, BL_FRAME_CRC_PASS); if (iRet) { iCheckFrameCrcError++; if (iCheckFrameCrcError > 10) { pr_err("[SSP]: %s - F/W Update Fail. crc err\n", __func__); goto out; } else { pr_err("[SSP]: %s - F/W crc_error %d, retry\n", __func__, iCheckFrameCrcError); continue; } } uPos += uFrameSize; if (count++ == 100) { pr_info("[SSP] Updated %d bytes / %zd bytes\n", uPos, fw->size); count = 0; } mdelay(1); } pr_info("[SSP] Firmware download is success.(%d bytes)\n", uPos); out: release_firmware(fw); return iRet; }
static int check_bootloader(struct i2c_client *client, unsigned int uState) { u8 uVal; u8 uTemp; struct ssp_data *data = i2c_get_clientdata(client); recheck: if (i2c_master_recv(client, &uVal, 1) != 1) return -EIO; pr_debug("%s, uVal = 0x%x\n", __func__, uVal); if (uVal & 0x20) { if (i2c_master_recv(client, &uTemp, 1) != 1) { pr_err("[SSP]: %s - i2c recv fail\n", __func__); return -EIO; } if (i2c_master_recv(client, &uTemp, 1) != 1) { pr_err("[SSP]: %s - i2c recv fail\n", __func__); return -EIO; } uVal &= ~0x20; } if ((uVal & 0xF0) == BL_APP_CRC_FAIL) { pr_info("[SSP] SSP_APP_CRC_FAIL - There is no bootloader.\n"); if (i2c_master_recv(client, &uVal, 1) != 1) { pr_err("[SSP]: %s - i2c recv fail\n", __func__); return -EIO; } if (uVal & 0x20) { if (i2c_master_recv(client, &uTemp, 1) != 1) { pr_err("[SSP]: %s - i2c recv fail\n", __func__); return -EIO; } if (i2c_master_recv(client, &uTemp, 1) != 1) { pr_err("[SSP]: %s - i2c recv fail\n", __func__); return -EIO; } uVal &= ~0x20; } } switch (uState) { case BL_WAITING_BOOTLOAD_CMD: case BL_WAITING_FRAME_DATA: uVal &= ~BL_BOOT_STATUS_MASK; break; case BL_FRAME_CRC_PASS: if (uVal == BL_FRAME_CRC_CHECK) { if (data->ssp_changes == SSP_MCU_L5) ssp_wait_for_chg(data); goto recheck; } break; default: return -EINVAL; } if (uVal != uState) { pr_err("[SSP]: %s - Invalid bootloader mode state\n", __func__); return -EINVAL; } return 0; }
static int load_ums_fw_bootmode(struct i2c_client *client, const char *pFn) { const u8 *buff = NULL; char fw_path[BL_UMS_FW_PATH+1]; unsigned int uFrameSize; unsigned int uFSize = 0, uNRead = 0; unsigned int uPos = 0; int iRet = SUCCESS; int iCheckFrameCrcError = 0; int iCheckWatingFrameDataError = 0; int count = 0; struct file *fp = NULL; mm_segment_t old_fs = get_fs(); struct ssp_data *data = i2c_get_clientdata(client); pr_info("[SSP] ssp_load_ums_fw start!!!\n"); old_fs = get_fs(); set_fs(get_ds()); snprintf(fw_path, BL_UMS_FW_PATH, "/sdcard/ssp/%s", pFn); fp = filp_open(fw_path, O_RDONLY, 0); if (IS_ERR(fp)) { iRet = ERROR; pr_err("file %s open error:%d\n", fw_path, (s32)fp); goto err_open; } uFSize = (unsigned int)fp->f_path.dentry->d_inode->i_size; pr_info("ssp_load_ums firmware size: %u\n", uFSize); buff = kzalloc((size_t)uFSize, GFP_KERNEL); if (!buff) { iRet = ERROR; pr_err("fail to alloc buffer for fw\n"); goto err_alloc; } uNRead = (unsigned int)vfs_read(fp, (char __user *)buff, (unsigned int)uFSize, &fp->f_pos); if (uNRead != uFSize) { iRet = ERROR; pr_err("fail to read file %s (nread = %u)\n", fw_path, uNRead); goto err_fw_size; } /* Unlock bootloader */ iRet = unlock_bootloader(client); if (iRet < 0) { pr_err("[SSP] %s - unlock_bootloader failed! %d\n", __func__, iRet); goto out; } while (uPos < uFSize) { if (data->ssp_changes == SSP_MCU_L5) { iRet = ssp_wait_for_chg(data); if (iRet < 0) { pr_err("[SSP] %s - ssp_wait_for_chg failed! %d\n", __func__, iRet); goto out; } } if (check_bootloader(client, BL_WAITING_FRAME_DATA)) { iCheckWatingFrameDataError++; if (iCheckWatingFrameDataError > 10) { iRet = ERROR; pr_err("[SSP]: %s - F/W update fail\n", __func__); goto out; } else { pr_err("[SSP]: %s - F/W data_error %d, retry\n", __func__, iCheckWatingFrameDataError); continue; } } uFrameSize = (unsigned int)((*(buff + uPos) << 8) | *(buff + uPos + 1)); /* We should add 2 at frame size as the the firmware data is not * included the CRC bytes. */ uFrameSize += 2; /* Write one frame to device */ fw_write(client, buff + uPos, uFrameSize); if (data->ssp_changes == SSP_MCU_L5) { iRet = ssp_wait_for_chg(data); if (iRet < 0) { pr_err("[SSP] %s - ssp_wait_for_chg failed! %d\n", __func__, iRet); goto out; } } if (check_bootloader(client, BL_FRAME_CRC_PASS)) { iCheckFrameCrcError++; if (iCheckFrameCrcError > 10) { iRet = ERROR; pr_err("[SSP]: %s - F/W Update Fail. crc err\n", __func__); goto out; } else { pr_err("[SSP]: %s - F/W crc_error %d, retry\n", __func__, iCheckFrameCrcError); continue; } } uPos += uFrameSize; if (count++ == 100) { pr_info("[SSP] Updated %u bytes / %u bytes\n", uPos, uFSize); count = 0; } mdelay(1); } out: err_fw_size: kfree(buff); err_alloc: filp_close(fp, NULL); err_open: set_fs(old_fs); return iRet; }
static int32_t aprv2_core_fn_q(struct apr_client_data *data, void *priv) { struct adsp_get_version *payload; uint32_t *payload1; struct adsp_service_info *svc_info; int i; pr_info("core msg: payload len = %u, apr resp opcode = 0x%X\n", data->payload_size, data->opcode); switch (data->opcode) { case APR_BASIC_RSP_RESULT:{ if (data->payload_size == 0) { pr_err("%s: APR_BASIC_RSP_RESULT No Payload ", __func__); return 0; } payload1 = data->payload; switch (payload1[0]) { case ADSP_CMD_SET_POWER_COLLAPSE_STATE: pr_info("Cmd = ADSP_CMD_SET_POWER_COLLAPSE_STATE" " status[0x%x]\n", payload1[1]); break; case ADSP_CMD_REMOTE_BUS_BW_REQUEST: pr_info("%s: cmd = ADSP_CMD_REMOTE_BUS_BW_REQUEST" " status = 0x%x\n", __func__, payload1[1]); bus_bw_resp_received = 1; wake_up(&bus_bw_req_wait); break; default: pr_err("Invalid cmd rsp[0x%x][0x%x]\n", payload1[0], payload1[1]); break; } break; } case ADSP_GET_VERSION_RSP:{ if (data->payload_size) { payload = data->payload; if (query_adsp_ver == 1) { query_adsp_ver = 0; adsp_version = payload->build_id; wake_up(&adsp_version_wait); } svc_info = (struct adsp_service_info *) ((char *)payload + sizeof(struct adsp_get_version)); pr_info("----------------------------------------\n"); pr_info("Build id = %x\n", payload->build_id); pr_info("Number of services= %x\n", payload->svc_cnt); pr_info("----------------------------------------\n"); for (i = 0; i < payload->svc_cnt; i++) { pr_info("svc-id[%d]\tver[%x.%x]\n", svc_info[i].svc_id, (svc_info[i].svc_ver & 0xFFFF0000) >> 16, (svc_info[i].svc_ver & 0xFFFF)); } pr_info("-----------------------------------------\n"); } else pr_info("zero payload for ADSP_GET_VERSION_RSP\n"); break; }
/* * mdss_dsi_cmds_rx() - dcs read from panel * @ctrl: dsi controller * @cmds: read command descriptor * @len: number of bytes to read back * * controller have 4 registers can hold 16 bytes of rxed data * dcs packet: 4 bytes header + payload + 2 bytes crc * 2 padding bytes add to payload to have payload length is mutipled by 4 * 1st read: 4 bytes header + 8 bytes payload + 2 padding + 2 crc * 2nd read: 12 bytes payload + 2 padding + 2 crc * 3rd read: 12 bytes payload + 2 padding + 2 crc * */ int mdss_dsi_cmds_rx(struct mdss_dsi_ctrl_pdata *ctrl, struct dsi_cmd_desc *cmds, int rlen) { int data_byte, rx_byte, dlen, end; int short_response, pkt_size, ret = 0; int diff = 0; int i; struct dsi_buf *tp, *rp; char cmd; u32 dsi_ctrl, data; int video_mode; u32 left_dsi_ctrl = 0; bool left_ctrl_restore = false; pr_debug("%s : ++ \n",__func__); if (ctrl->shared_pdata.broadcast_enable) { if (ctrl->ndx == DSI_CTRL_0) { pr_debug("%s: Broadcast mode. 1st ctrl\n", __func__); return 0; } } if (ctrl->shared_pdata.broadcast_enable) { if ((ctrl->ndx == DSI_CTRL_1) && (left_ctrl_pdata != NULL)) { left_dsi_ctrl = MIPI_INP(left_ctrl_pdata->ctrl_base + 0x0004); video_mode = left_dsi_ctrl & 0x02; /* VIDEO_MODE_EN */ if (video_mode) { data = left_dsi_ctrl | 0x04; /* CMD_MODE_EN */ MIPI_OUTP(left_ctrl_pdata->ctrl_base + 0x0004, data); left_ctrl_restore = true; } } } /* turn on cmd mode * for video mode, do not send cmds more than * one pixel line, since it only transmit it * during BLLP. */ dsi_ctrl = MIPI_INP((ctrl->ctrl_base) + 0x0004); video_mode = dsi_ctrl & 0x02; /* VIDEO_MODE_EN */ if (video_mode) { data = dsi_ctrl | 0x04; /* CMD_MODE_EN */ MIPI_OUTP((ctrl->ctrl_base) + 0x0004, data); } if (rlen == 0) { short_response = 1; rx_byte = 4; pkt_size = 0; } else { short_response = 0; data_byte = 8; /* first read */ /* * add extra 2 padding bytes to have overall * packet size is multipe by 4. This also make * sure 4 bytes dcs headerlocates within a * 32 bits register after shift in. */ pkt_size = data_byte + 2; rx_byte = data_byte + 8; /* 4 header + 2 crc + 2 padding*/ } tp = &ctrl->tx_buf; rp = &ctrl->rx_buf; end = 0; mdss_dsi_buf_init(rp); while (!end) { pr_debug("%s: rlen=%d pkt_size=%d rx_byte=%d\n", __func__, rlen, pkt_size, rx_byte); if (!short_response) { max_pktsize[0] = pkt_size; mdss_dsi_buf_init(tp); ret = mdss_dsi_cmd_dma_add(tp, &pkt_size_cmd); if (!ret) { pr_err("%s: failed to add max_pkt_size\n", __func__); rp->len = 0; goto end; } mdss_dsi_wait4video_eng_busy(ctrl); mdss_dsi_enable_irq(ctrl, DSI_CMD_TERM); ret = mdss_dsi_cmd_dma_tx(ctrl, tp); if (IS_ERR_VALUE(ret)) { mdss_dsi_disable_irq(ctrl, DSI_CMD_TERM); pr_err("%s: failed to tx max_pkt_size\n", __func__); rp->len = 0; goto end; } pr_debug("%s: max_pkt_size=%d sent\n", __func__, pkt_size); } mdss_dsi_buf_init(tp); ret = mdss_dsi_cmd_dma_add(tp, cmds); if (!ret) { pr_err("%s: failed to add cmd = 0x%x\n", __func__, cmds->payload[0]); rp->len = 0; goto end; } mdss_dsi_wait4video_eng_busy(ctrl); /* video mode only */ mdss_dsi_enable_irq(ctrl, DSI_CMD_TERM); /* transmit read comamnd to client */ ret = mdss_dsi_cmd_dma_tx(ctrl, tp); if (IS_ERR_VALUE(ret)) { mdss_dsi_disable_irq(ctrl, DSI_CMD_TERM); pr_err("%s: failed to tx cmd = 0x%x\n", __func__, cmds->payload[0]); rp->len = 0; goto end; } /* * once cmd_dma_done interrupt received, * return data from client is ready and stored * at RDBK_DATA register already * since rx fifo is 16 bytes, dcs header is kept at first loop, * after that dcs header lost during shift into registers */ #if defined(CONFIG_FB_MSM_MIPI_SAMSUNG_OCTA_CMD_WQXGA_S6TNMR7_PT_PANEL) dlen = mdss_dsi_cmd_dma_rx(left_ctrl_pdata, rp, rx_byte); #else dlen = mdss_dsi_cmd_dma_rx(ctrl, rp, rx_byte); #endif if (short_response) break; if (rlen <= data_byte) { diff = data_byte - rlen; end = 1; } else { diff = 0; rlen -= data_byte; } dlen -= 2; /* 2 padding bytes */ dlen -= 2; /* 2 crc */ dlen -= diff; rp->data += dlen; /* next start position */ rp->len += dlen; data_byte = 12; /* NOT first read */ pkt_size += data_byte; pr_debug("%s: rp data=%x len=%d dlen=%d diff=%d\n", __func__, (int)rp->data, rp->len, dlen, diff); } rp->data = rp->start; /* move back to start position */ cmd = rp->data[0]; switch (cmd) { case DTYPE_ACK_ERR_RESP: pr_debug("%s: rx ACK_ERR_PACLAGE\n", __func__); rp->len = 0; case DTYPE_GEN_READ1_RESP: case DTYPE_DCS_READ1_RESP: mdss_dsi_short_read1_resp(rp); break; case DTYPE_GEN_READ2_RESP: case DTYPE_DCS_READ2_RESP: mdss_dsi_short_read2_resp(rp); break; case DTYPE_GEN_LREAD_RESP: case DTYPE_DCS_LREAD_RESP: mdss_dsi_long_read_resp(rp); break; default: pr_warning("%s:Invalid response cmd :len=%d dlen=%d diff=%d\n", __func__, rp->len, dlen, diff); for (i = 0;i < (rp->len); i++) pr_info(" rp[%d]=%x \n",i,rp->data[i]); rp->len = 0; } end: if (left_ctrl_restore) MIPI_OUTP(left_ctrl_pdata->ctrl_base + 0x0004, left_dsi_ctrl); /*restore */ if (video_mode) MIPI_OUTP((ctrl->ctrl_base) + 0x0004, dsi_ctrl); /* restore */ pr_debug("%s : -- \n",__func__); return rp->len; }
static void __exit it660x_i2c_exit(void) { pr_info( "%s . \n", __FUNCTION__ ); i2c_del_driver(&it660x_i2c_driver); }
ssize_t mpu6500_gyro_selftest(char *buf, struct ssp_data *data) { char chTempBuf[36] = { 0,}; u8 initialized = 0; s8 hw_result = 0; int i = 0, j = 0, total_count = 0, ret_val = 0; long avg[3] = {0,}, rms[3] = {0,}; int gyro_bias[3] = {0,}, gyro_rms[3] = {0,}; s16 shift_ratio[3] = {0,}; s16 iCalData[3] = {0,}; char a_name[3][2] = { "X", "Y", "Z" }; int iRet = 0; int dps_rms[3] = { 0, }; u32 temp = 0; #if defined (CONFIG_SEC_PATEK_PROJECT) int bias_thresh = DEF_BIAS_LSB_THRESH_SELF_MAX21103_MAXIM; #else int bias_thresh = DEF_BIAS_LSB_THRESH_SELF_6500; #endif struct ssp_msg *msg = kzalloc(sizeof(*msg), GFP_KERNEL); msg->cmd = GYROSCOPE_FACTORY; msg->length = 36; msg->options = AP2HUB_READ; msg->buffer = chTempBuf; msg->free_buffer = 0; iRet = ssp_spi_sync(data, msg, 7000); if (iRet != SUCCESS) { pr_err("[SSP]: %s - Gyro Selftest Timeout!!\n", __func__); ret_val = 1; goto exit; } data->uTimeOutCnt = 0; pr_err("[SSP]%d %d %d %d %d %d %d %d %d %d %d %d", chTempBuf[0], chTempBuf[1], chTempBuf[2], chTempBuf[3], chTempBuf[4], chTempBuf[5], chTempBuf[6], chTempBuf[7], chTempBuf[8], chTempBuf[9], chTempBuf[10], chTempBuf[11]); initialized = chTempBuf[0]; shift_ratio[0] = (s16)((chTempBuf[2] << 8) + chTempBuf[1]); shift_ratio[1] = (s16)((chTempBuf[4] << 8) + chTempBuf[3]); shift_ratio[2] = (s16)((chTempBuf[6] << 8) + chTempBuf[5]); hw_result = (s8)chTempBuf[7]; total_count = (int)((chTempBuf[11] << 24) + (chTempBuf[10] << 16) + (chTempBuf[9] << 8) + chTempBuf[8]); avg[0] = (long)((chTempBuf[15] << 24) + (chTempBuf[14] << 16) + (chTempBuf[13] << 8) + chTempBuf[12]); avg[1] = (long)((chTempBuf[19] << 24) + (chTempBuf[18] << 16) + (chTempBuf[17] << 8) + chTempBuf[16]); avg[2] = (long)((chTempBuf[23] << 24) + (chTempBuf[22] << 16) + (chTempBuf[21] << 8) + chTempBuf[20]); rms[0] = (long)((chTempBuf[27] << 24) + (chTempBuf[26] << 16) + (chTempBuf[25] << 8) + chTempBuf[24]); rms[1] = (long)((chTempBuf[31] << 24) + (chTempBuf[30] << 16) + (chTempBuf[29] << 8) + chTempBuf[28]); rms[2] = (long)((chTempBuf[35] << 24) + (chTempBuf[34] << 16) + (chTempBuf[33] << 8) + chTempBuf[32]); pr_info("[SSP] init: %d, total cnt: %d\n", initialized, total_count); pr_info("[SSP] hw_result: %d, %d, %d, %d\n", hw_result, shift_ratio[0], shift_ratio[1], shift_ratio[2]); pr_info("[SSP] avg %+8ld %+8ld %+8ld (LSB)\n", avg[0], avg[1], avg[2]); pr_info("[SSP] rms %+8ld %+8ld %+8ld (LSB)\n", rms[0], rms[1], rms[2]); if (total_count == 0) { pr_err("[SSP] %s, total_count is 0. goto exit\n", __func__); ret_val = 2; goto exit; } if (hw_result < 0) { pr_err("[SSP] %s - hw selftest fail(%d), sw selftest skip\n", __func__, hw_result); return sprintf(buf, "-1,0,0,0,0,0,0,%d.%d,%d.%d,%d.%d,0,0,0\n", shift_ratio[0] / 10, shift_ratio[0] % 10, shift_ratio[1] / 10, shift_ratio[1] % 10, shift_ratio[2] / 10, shift_ratio[2] % 10); } #if defined (CONFIG_SEC_PATEK_PROJECT) if (data->ap_rev >= MAXIM_MAX21103_REV) { gyro_bias[0] = (avg[0] * DEF_SCALE_FOR_FLOAT) / DEF_GYRO_SENS_MAXIM; gyro_bias[1] = (avg[1] * DEF_SCALE_FOR_FLOAT) / DEF_GYRO_SENS_MAXIM; gyro_bias[2] = (avg[2] * DEF_SCALE_FOR_FLOAT) / DEF_GYRO_SENS_MAXIM; }else{ gyro_bias[0] = (avg[0] * DEF_SCALE_FOR_FLOAT) / DEF_GYRO_SENS; gyro_bias[1] = (avg[1] * DEF_SCALE_FOR_FLOAT) / DEF_GYRO_SENS; gyro_bias[2] = (avg[2] * DEF_SCALE_FOR_FLOAT) / DEF_GYRO_SENS; } #else gyro_bias[0] = (avg[0] * DEF_SCALE_FOR_FLOAT) / DEF_GYRO_SENS; gyro_bias[1] = (avg[1] * DEF_SCALE_FOR_FLOAT) / DEF_GYRO_SENS; gyro_bias[2] = (avg[2] * DEF_SCALE_FOR_FLOAT) / DEF_GYRO_SENS; #endif iCalData[0] = (s16)avg[0]; iCalData[1] = (s16)avg[1]; iCalData[2] = (s16)avg[2]; if (VERBOSE_OUT) { pr_info("[SSP] abs bias : %+8d.%03d %+8d.%03d %+8d.%03d (dps)\n", (int)abs(gyro_bias[0]) / DEF_SCALE_FOR_FLOAT, (int)abs(gyro_bias[0]) % DEF_SCALE_FOR_FLOAT, (int)abs(gyro_bias[1]) / DEF_SCALE_FOR_FLOAT, (int)abs(gyro_bias[1]) % DEF_SCALE_FOR_FLOAT, (int)abs(gyro_bias[2]) / DEF_SCALE_FOR_FLOAT, (int)abs(gyro_bias[2]) % DEF_SCALE_FOR_FLOAT); } for (j = 0; j < 3; j++) { if (unlikely(abs(avg[j]) > bias_thresh)) { pr_err("[SSP] %s-Gyro bias (%ld) exceeded threshold " "(threshold = %d LSB)\n", a_name[j], avg[j], bias_thresh); ret_val |= 1 << (3 + j); } } /* 3rd, check RMS for dead gyros If any of the RMS noise value returns zero, then we might have dead gyro or FIFO/register failure, the part is sleeping, or the part is not responsive */ if (rms[0] == 0 || rms[1] == 0 || rms[2] == 0) ret_val |= 1 << 6; if (VERBOSE_OUT) { pr_info("[SSP] RMS ^ 2 : %+8ld %+8ld %+8ld\n", (long)rms[0] / total_count, (long)rms[1] / total_count, (long)rms[2] / total_count); } #if defined (CONFIG_SEC_PATEK_PROJECT) if (data->ap_rev >= MAXIM_MAX21103_REV) { for (j = 0; j < 3; j++) { if (unlikely(rms[j] / total_count > DEF_RMS_THRESH_MAXIM)) { pr_err("[SSP] %s-Gyro rms (%ld) exceeded threshold " "(threshold = %d LSB)\n", a_name[j], rms[j] / total_count, DEF_RMS_THRESH_MAXIM); ret_val |= 1 << (7 + j); } } }else{ for (j = 0; j < 3; j++) { if (unlikely(rms[j] / total_count > DEF_RMS_THRESH)) { pr_err("[SSP] %s-Gyro rms (%ld) exceeded threshold " "(threshold = %d LSB)\n", a_name[j], rms[j] / total_count, DEF_RMS_THRESH); ret_val |= 1 << (7 + j); } } } #else for (j = 0; j < 3; j++) { if (unlikely(rms[j] / total_count > DEF_RMS_THRESH)) { pr_err("[SSP] %s-Gyro rms (%ld) exceeded threshold " "(threshold = %d LSB)\n", a_name[j], rms[j] / total_count, DEF_RMS_THRESH); ret_val |= 1 << (7 + j); } } #endif for (i = 0; i < 3; i++) { if (rms[i] > 10000) { temp = ((u32) (rms[i] / total_count)) * DEF_RMS_SCALE_FOR_RMS; } else { temp = ((u32) (rms[i] * DEF_RMS_SCALE_FOR_RMS)) / total_count; } if (rms[i] < 0) temp = 1 << 31; #if defined (CONFIG_SEC_PATEK_PROJECT) if (data->ap_rev >= MAXIM_MAX21103_REV) dps_rms[i] = mpu6050_selftest_sqrt(temp) / DEF_GYRO_SENS_MAXIM; else dps_rms[i] = mpu6050_selftest_sqrt(temp) / DEF_GYRO_SENS; #else dps_rms[i] = mpu6050_selftest_sqrt(temp) / DEF_GYRO_SENS; #endif gyro_rms[i] = dps_rms[i] * DEF_SCALE_FOR_FLOAT / DEF_SQRT_SCALE_FOR_RMS; } pr_info("[SSP] RMS : %+8d.%03d %+8d.%03d %+8d.%03d (dps)\n", (int)abs(gyro_rms[0]) / DEF_SCALE_FOR_FLOAT, (int)abs(gyro_rms[0]) % DEF_SCALE_FOR_FLOAT, (int)abs(gyro_rms[1]) / DEF_SCALE_FOR_FLOAT, (int)abs(gyro_rms[1]) % DEF_SCALE_FOR_FLOAT, (int)abs(gyro_rms[2]) / DEF_SCALE_FOR_FLOAT, (int)abs(gyro_rms[2]) % DEF_SCALE_FOR_FLOAT); if (likely(!ret_val)) { save_gyro_caldata(data, iCalData); } else { pr_err("[SSP] ret_val != 0, gyrocal is 0 at all axis\n"); data->gyrocal.x = 0; data->gyrocal.y = 0; data->gyrocal.z = 0; } #if defined (CONFIG_SEC_PATEK_PROJECT) if (data->ap_rev >= MAXIM_MAX21103_REV){ gyro_bias[0] = gyro_bias[0]/8; gyro_bias[1] = gyro_bias[1]/8; gyro_bias[2] = gyro_bias[2]/8; } #endif exit: ssp_dbg("[SSP]: %s - %d," "%d.%03d,%d.%03d,%d.%03d," "%d.%03d,%d.%03d,%d.%03d," "%d.%d,%d.%d,%d.%d," "%d,%d,%d\n", __func__, ret_val, (int)abs(gyro_bias[0]/1000), (int)abs(gyro_bias[0])%1000, (int)abs(gyro_bias[1]/1000), (int)abs(gyro_bias[1])%1000, (int)abs(gyro_bias[2]/1000), (int)abs(gyro_bias[2])%1000, gyro_rms[0]/1000, (int)abs(gyro_rms[0])%1000, gyro_rms[1]/1000, (int)abs(gyro_rms[1])%1000, gyro_rms[2]/1000, (int)abs(gyro_rms[2])%1000, shift_ratio[0] / 10, shift_ratio[0] % 10, shift_ratio[1] / 10, shift_ratio[1] % 10, shift_ratio[2] / 10, shift_ratio[2] % 10, (int)(total_count/3), (int)(total_count/3), (int)(total_count/3)); return sprintf(buf, "%d," "%d.%03d,%d.%03d,%d.%03d," "%d.%03d,%d.%03d,%d.%03d," "%d.%d,%d.%d,%d.%d," "%d,%d,%d\n", ret_val, (int)abs(gyro_bias[0]/1000), (int)abs(gyro_bias[0])%1000, (int)abs(gyro_bias[1]/1000), (int)abs(gyro_bias[1])%1000, (int)abs(gyro_bias[2]/1000), (int)abs(gyro_bias[2])%1000, gyro_rms[0]/1000, (int)abs(gyro_rms[0])%1000, gyro_rms[1]/1000, (int)abs(gyro_rms[1])%1000, gyro_rms[2]/1000, (int)abs(gyro_rms[2])%1000, shift_ratio[0] / 10, shift_ratio[0] % 10, shift_ratio[1] / 10, shift_ratio[1] % 10, shift_ratio[2] / 10, shift_ratio[2] % 10, (int)(total_count/3), (int)(total_count/3), (int)(total_count/3)); }
void __init early_init_dt_add_memory_arch(u64 base, u64 size) { arc_mem_sz = size & PAGE_MASK; pr_info("Memory size set via devicetree %ldM\n", TO_MB(arc_mem_sz)); }
static int __init mc32_probe1(struct net_device *dev, int slot) { static unsigned version_printed; int i, err; u8 POS; u32 base; struct mc32_local *lp = netdev_priv(dev); static const u16 mca_io_bases[] = { 0x7280,0x7290, 0x7680,0x7690, 0x7A80,0x7A90, 0x7E80,0x7E90 }; static const u32 mca_mem_bases[] = { 0x00C0000, 0x00C4000, 0x00C8000, 0x00CC000, 0x00D0000, 0x00D4000, 0x00D8000, 0x00DC000 }; static const char * const failures[] = { "Processor instruction", "Processor data bus", "Processor data bus", "Processor data bus", "Adapter bus", "ROM checksum", "Base RAM", "Extended RAM", "82586 internal loopback", "82586 initialisation failure", "Adapter list configuration error" }; /* Time to play MCA games */ if (mc32_debug && version_printed++ == 0) pr_debug("%s", version); pr_info("%s: %s found in slot %d: ", dev->name, cardname, slot); POS = mca_read_stored_pos(slot, 2); if(!(POS&1)) { pr_cont("disabled.\n"); return -ENODEV; } /* Fill in the 'dev' fields. */ dev->base_addr = mca_io_bases[(POS>>1)&7]; dev->mem_start = mca_mem_bases[(POS>>4)&7]; POS = mca_read_stored_pos(slot, 4); if(!(POS&1)) { pr_cont("memory window disabled.\n"); return -ENODEV; } POS = mca_read_stored_pos(slot, 5); i=(POS>>4)&3; if(i==3) { pr_cont("invalid memory window.\n"); return -ENODEV; } i*=16384; i+=16384; dev->mem_end=dev->mem_start + i; dev->irq = ((POS>>2)&3)+9; if(!request_region(dev->base_addr, MC32_IO_EXTENT, cardname)) { pr_cont("io 0x%3lX, which is busy.\n", dev->base_addr); return -EBUSY; } pr_cont("io 0x%3lX irq %d mem 0x%lX (%dK)\n", dev->base_addr, dev->irq, dev->mem_start, i/1024); /* We ought to set the cache line size here.. */ /* * Go PROM browsing */ /* Retrieve and print the ethernet address. */ for (i = 0; i < 6; i++) { mca_write_pos(slot, 6, i+12); mca_write_pos(slot, 7, 0); dev->dev_addr[i] = mca_read_pos(slot,3); } pr_info("%s: Address %pM ", dev->name, dev->dev_addr); mca_write_pos(slot, 6, 0); mca_write_pos(slot, 7, 0); POS = mca_read_stored_pos(slot, 4); if(POS&2) pr_cont(": BNC port selected.\n"); else pr_cont(": AUI port selected.\n"); POS=inb(dev->base_addr+HOST_CTRL); POS|=HOST_CTRL_ATTN|HOST_CTRL_RESET; POS&=~HOST_CTRL_INTE; outb(POS, dev->base_addr+HOST_CTRL); /* Reset adapter */ udelay(100); /* Reset off */ POS&=~(HOST_CTRL_ATTN|HOST_CTRL_RESET); outb(POS, dev->base_addr+HOST_CTRL); udelay(300); /* * Grab the IRQ */ err = request_irq(dev->irq, mc32_interrupt, IRQF_SHARED, DRV_NAME, dev); if (err) { release_region(dev->base_addr, MC32_IO_EXTENT); pr_err("%s: unable to get IRQ %d.\n", DRV_NAME, dev->irq); goto err_exit_ports; } memset(lp, 0, sizeof(struct mc32_local)); lp->slot = slot; i=0; base = inb(dev->base_addr); while(base == 0xFF) { i++; if(i == 1000) { pr_err("%s: failed to boot adapter.\n", dev->name); err = -ENODEV; goto err_exit_irq; } udelay(1000); if(inb(dev->base_addr+2)&(1<<5)) base = inb(dev->base_addr); } if(base>0) { if(base < 0x0C) pr_err("%s: %s%s.\n", dev->name, failures[base-1], base<0x0A?" test failure":""); else pr_err("%s: unknown failure %d.\n", dev->name, base); err = -ENODEV; goto err_exit_irq; } base=0; for(i=0;i<4;i++) { int n=0; while(!(inb(dev->base_addr+2)&(1<<5))) { n++; udelay(50); if(n>100) { pr_err("%s: mailbox read fail (%d).\n", dev->name, i); err = -ENODEV; goto err_exit_irq; } } base|=(inb(dev->base_addr)<<(8*i)); } lp->exec_box=isa_bus_to_virt(dev->mem_start+base); base=lp->exec_box->data[1]<<16|lp->exec_box->data[0]; lp->base = dev->mem_start+base; lp->rx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[2]); lp->tx_box=isa_bus_to_virt(lp->base + lp->exec_box->data[3]); lp->stats = isa_bus_to_virt(lp->base + lp->exec_box->data[5]); /* * Descriptor chains (card relative) */ lp->tx_chain = lp->exec_box->data[8]; /* Transmit list start offset */ lp->rx_chain = lp->exec_box->data[10]; /* Receive list start offset */ lp->tx_len = lp->exec_box->data[9]; /* Transmit list count */ lp->rx_len = lp->exec_box->data[11]; /* Receive list count */ sema_init(&lp->cmd_mutex, 0); init_completion(&lp->execution_cmd); init_completion(&lp->xceiver_cmd); pr_info("%s: Firmware Rev %d. %d RX buffers, %d TX buffers. Base of 0x%08X.\n", dev->name, lp->exec_box->data[12], lp->rx_len, lp->tx_len, lp->base); dev->netdev_ops = &netdev_ops; dev->watchdog_timeo = HZ*5; /* Board does all the work */ dev->ethtool_ops = &netdev_ethtool_ops; return 0; err_exit_irq: free_irq(dev->irq, dev); err_exit_ports: release_region(dev->base_addr, MC32_IO_EXTENT); return err; }
static void umts_modem_cfg_gpio(void) { int err = 0; unsigned gpio_reset_req_n = umts_modem_data.gpio_reset_req_n; unsigned gpio_cp_on = umts_modem_data.gpio_cp_on; unsigned gpio_cp_rst = umts_modem_data.gpio_cp_reset; unsigned gpio_pda_active = umts_modem_data.gpio_pda_active; unsigned gpio_phone_active = umts_modem_data.gpio_phone_active; unsigned gpio_cp_dump_int = umts_modem_data.gpio_cp_dump_int; unsigned gpio_flm_uart_sel = umts_modem_data.gpio_flm_uart_sel; unsigned irq_phone_active = umts_modem_res[0].start; if (gpio_reset_req_n) { err = gpio_request(gpio_reset_req_n, "RESET_REQ_N"); if (err) { pr_err(LOG_TAG "fail to request gpio %s : %d\n", "RESET_REQ_N", err); } s3c_gpio_slp_cfgpin(gpio_reset_req_n, S3C_GPIO_SLP_OUT1); gpio_direction_output(gpio_reset_req_n, 0); } if (gpio_cp_on) { err = gpio_request(gpio_cp_on, "CP_ON"); if (err) { pr_err(LOG_TAG "fail to request gpio %s : %d\n", "CP_ON", err); } gpio_direction_output(gpio_cp_on, 0); } if (gpio_cp_rst) { err = gpio_request(gpio_cp_rst, "CP_RST"); if (err) { pr_err(LOG_TAG "fail to request gpio %s : %d\n", "CP_RST", err); } s3c_gpio_slp_cfgpin(gpio_cp_rst, S3C_GPIO_SLP_OUT1); gpio_direction_output(gpio_cp_rst, 0); } if (gpio_pda_active) { err = gpio_request(gpio_pda_active, "PDA_ACTIVE"); if (err) { pr_err(LOG_TAG "fail to request gpio %s : %d\n", "PDA_ACTIVE", err); } gpio_direction_output(gpio_pda_active, 0); } if (gpio_phone_active) { err = gpio_request(gpio_phone_active, "PHONE_ACTIVE"); if (err) { pr_err(LOG_TAG "fail to request gpio %s : %d\n", "PHONE_ACTIVE", err); } gpio_direction_input(gpio_phone_active); pr_err(LOG_TAG "check phone active = %d\n", irq_phone_active); } if (gpio_cp_dump_int) { err = gpio_request(gpio_cp_dump_int, "CP_DUMP_INT"); if (err) { pr_err(LOG_TAG "fail to request gpio %s : %d\n", "CP_DUMP_INT", err); } gpio_direction_input(gpio_cp_dump_int); } if (gpio_flm_uart_sel) { err = gpio_request(gpio_flm_uart_sel, "GPS_UART_SEL"); if (err) { pr_err(LOG_TAG "fail to request gpio %s : %d\n", "GPS_UART_SEL", err); } gpio_direction_output(gpio_reset_req_n, 0); } if (gpio_phone_active) irq_set_irq_type(gpio_to_irq(gpio_phone_active), IRQ_TYPE_LEVEL_HIGH); /* set low unused gpios between AP and CP */ err = gpio_request(GPIO_FLM_RXD, "FLM_RXD"); if (err) pr_err(LOG_TAG "fail to request gpio %s : %d\n", "FLM_RXD", err); else { gpio_direction_output(GPIO_FLM_RXD, 0); s3c_gpio_setpull(GPIO_FLM_RXD, S3C_GPIO_PULL_NONE); } err = gpio_request(GPIO_FLM_TXD, "FLM_TXD"); if (err) pr_err(LOG_TAG "fail to request gpio %s : %d\n", "FLM_TXD", err); else { gpio_direction_output(GPIO_FLM_TXD, 0); s3c_gpio_setpull(GPIO_FLM_TXD, S3C_GPIO_PULL_NONE); } err = gpio_request(GPIO_SUSPEND_REQUEST, "SUS_REQ"); if (err) pr_err(LOG_TAG "fail to request gpio %s : %d\n", "SUS_REQ", err); else { gpio_direction_output(GPIO_SUSPEND_REQUEST, 0); s3c_gpio_setpull(GPIO_SUSPEND_REQUEST, S3C_GPIO_PULL_NONE); } err = gpio_request(GPIO_GPS_CNTL, "GPS_CNTL"); if (err) pr_err(LOG_TAG "fail to request gpio %s : %d\n", "GPS_CNTL", err); else { gpio_direction_output(GPIO_GPS_CNTL, 0); s3c_gpio_setpull(GPIO_GPS_CNTL, S3C_GPIO_PULL_NONE); } pr_info(LOG_TAG "umts_modem_cfg_gpio done\n"); }
static int mc32_open(struct net_device *dev) { int ioaddr = dev->base_addr; struct mc32_local *lp = netdev_priv(dev); u8 one=1; u8 regs; u16 descnumbuffs[2] = {TX_RING_LEN, RX_RING_LEN}; /* * Interrupts enabled */ regs=inb(ioaddr+HOST_CTRL); regs|=HOST_CTRL_INTE; outb(regs, ioaddr+HOST_CTRL); /* * Allow ourselves to issue commands */ up(&lp->cmd_mutex); /* * Send the indications on command */ mc32_command(dev, 4, &one, 2); /* * Poke it to make sure it's really dead. */ mc32_halt_transceiver(dev); mc32_flush_tx_ring(dev); /* * Ask card to set up on-card descriptors to our spec */ if(mc32_command(dev, 8, descnumbuffs, 4)) { pr_info("%s: %s rejected our buffer configuration!\n", dev->name, cardname); mc32_close(dev); return -ENOBUFS; } /* Report new configuration */ mc32_command(dev, 6, NULL, 0); lp->tx_chain = lp->exec_box->data[8]; /* Transmit list start offset */ lp->rx_chain = lp->exec_box->data[10]; /* Receive list start offset */ lp->tx_len = lp->exec_box->data[9]; /* Transmit list count */ lp->rx_len = lp->exec_box->data[11]; /* Receive list count */ /* Set Network Address */ mc32_command(dev, 1, dev->dev_addr, 6); /* Set the filters */ mc32_set_multicast_list(dev); if (WORKAROUND_82586) { u16 zero_word=0; mc32_command(dev, 0x0D, &zero_word, 2); /* 82586 bug workaround on */ } mc32_load_tx_ring(dev); if(mc32_load_rx_ring(dev)) { mc32_close(dev); return -ENOBUFS; } lp->xceiver_desired_state = RUNNING; /* And finally, set the ball rolling... */ mc32_start_transceiver(dev); netif_start_queue(dev); return 0; }
static ssize_t bluetooth_write(struct file *filp, const char __user *buf, size_t count, loff_t *offset) { int ret = 0; int val = 0; int error_no = 0; pr_info("%s enter\n",__func__); if(NULL == buf){ pr_err("%s: input para buf is NULL!\n", __func__); return -EINVAL; } pr_info("%s: dsm report op:%s\n", __func__, buf); if (1 != sscanf(buf, "%2d", &val)){ pr_err("%s : get buf failed: %s\n", __func__,buf); return -EINVAL; } if(!bt_dclient){ pr_err("%s: bt_dclient is NULL!\n", __func__); return -1; } if(dsm_client_ocuppy(bt_dclient)){ pr_err("%s: buffer is busy!\n", __func__); return -1; } switch(val) { case DSM_BLUETOOTH_DM_OPEN: error_no = DSM_BLUETOOTH_DM_OPEN_ERROR; ret = dsm_client_record(bt_dclient, "bluetooth open fail"); break; case DSM_BLUETOOTH_DM_GET_ADDR: error_no = DSM_BLUETOOTH_DM_GET_ADDR_ERROR; ret = dsm_client_record(bt_dclient, "get bt addr fail"); break; case DSM_BLUETOOTH_A2DP_CONNECT: error_no = DSM_BLUETOOTH_A2DP_CONNECT_ERROR; ret = dsm_client_record(bt_dclient, "a2dp connect fail"); break; case DSM_BLUETOOTH_A2DP_AUDIO: error_no = DSM_BLUETOOTH_A2DP_AUDIO_ERROR; ret = dsm_client_record(bt_dclient, "a2dp audio fail"); break; case DSM_BLUETOOTH_HFP_CONNECT: error_no = DSM_BLUETOOTH_HFP_CONNECT_ERROR; ret = dsm_client_record(bt_dclient, "hfp connect fail"); break; case DSM_BLUETOOTH_HFP_SCO_CONNECT: error_no = DSM_BLUETOOTH_HFP_SCO_CONNECT_ERROR; ret = dsm_client_record(bt_dclient, "hfp sco connect fail"); break; case DSM_BLUETOOTH_BLE_CONNECT: error_no = DSM_BLUETOOTH_BLE_CONNECT_ERROR; ret = dsm_client_record(bt_dclient, "ble connect fail"); break; default : break; } if(!ret){ pr_err("%s: no need report! error no:%d\n", __func__,error_no ); return 0; } /*call dsm report interface*/ dsm_client_notify(bt_dclient, error_no); return 0; }
static int __devinit mipi_samsung_disp_probe(struct platform_device *pdev) { struct platform_device *msm_fb_added_dev; #if defined(CONFIG_LCD_CLASS_DEVICE) struct lcd_device *lcd_device; int ret; #endif #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) struct backlight_device *bd; #endif msd.dstat.acl_on = false; if (pdev->id == 0) { msd.mipi_samsung_disp_pdata = pdev->dev.platform_data; first_on = false; return 0; } msm_fb_added_dev = msm_fb_add_device(pdev); mutex_init(&dsi_tx_mutex); #if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_LCD_CLASS_DEVICE) msd.msm_pdev = msm_fb_added_dev; #endif #if defined(CONFIG_HAS_EARLYSUSPEND) msd.early_suspend.suspend = mipi_samsung_disp_early_suspend; msd.early_suspend.resume = mipi_samsung_disp_late_resume; msd.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; register_early_suspend(&msd.early_suspend); #endif #if defined(CONFIG_ESD_ERR_FG_RECOVERY) INIT_WORK(&err_fg_work, err_fg_work_func); err_fg_gpio = MSM_GPIO_TO_INT(GPIO_ESD_VGH_DET); ret = gpio_request(GPIO_ESD_VGH_DET, "err_fg"); if (ret) { pr_err("request gpio GPIO_LCD_ESD_DET failed, ret=%d\n",ret); gpio_free(GPIO_ESD_VGH_DET); return ret; } gpio_tlmm_config(GPIO_CFG(GPIO_ESD_VGH_DET, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA),GPIO_CFG_ENABLE); ret = request_threaded_irq(err_fg_gpio, NULL, err_fg_irq_handler, IRQF_TRIGGER_HIGH | IRQF_ONESHOT, "esd_detect", NULL); if (ret) { pr_err("%s : Failed to request_irq. :ret=%d", __func__, ret); } disable_irq(err_fg_gpio); #endif #if defined(CONFIG_LCD_CLASS_DEVICE) lcd_device = lcd_device_register("panel", &pdev->dev, NULL, &mipi_samsung_disp_props); if (IS_ERR(lcd_device)) { ret = PTR_ERR(lcd_device); printk(KERN_ERR "lcd : failed to register device\n"); return ret; } #ifdef WA_FOR_FACTORY_MODE sysfs_remove_file(&lcd_device->dev.kobj, &dev_attr_lcd_power.attr); ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_power.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_lcd_power.attr.name); } #endif ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_type.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_lcd_type.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_gamma_mode.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_gamma_mode.attr.name); } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_power_reduce.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_power_reduce.attr.name); } #if defined(CONFIG_BACKLIGHT_CLASS_DEVICE) bd = backlight_device_register("panel", &lcd_device->dev, NULL, NULL, NULL); if (IS_ERR(bd)) { ret = PTR_ERR(bd); pr_info("backlight : failed to register device\n"); return ret; } ret = sysfs_create_file(&bd->dev.kobj, &dev_attr_auto_brightness.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_auto_brightness.attr.name); } #endif #endif #if defined(CONFIG_MDNIE_LITE_TUNING) \ || defined(CONFIG_FB_MDP4_ENHANCE) /* mdnie sysfs create */ init_mdnie_class(); #endif mipi_dsi_buf_alloc(&mdnie_tune_tx_buf, DSI_BUF_SIZE); #if defined(DDI_VIDEO_ENHANCE_TUNING) ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_tuning.attr); if (ret) { pr_info("sysfs create fail-%s\n", dev_attr_tuning.attr.name); } #endif return 0; }
static long pn547_dev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { struct pn547_dev *pn547_dev = filp->private_data; switch (cmd) { case PN547_SET_PWR: if (arg == 2) { /* power on with firmware download (requires hw reset) */ #if defined(CONFIG_SEC_MILLETWIFI_COMMON) || defined(CONFIG_SEC_RUBENSLTE_COMMON) || defined(CONFIG_SEC_RUBENSWIFI_COMMON) gpio_direction_output(pn547_dev->ven_gpio, 1); #endif gpio_set_value_cansleep(pn547_dev->ven_gpio, 1); gpio_set_value(pn547_dev->firm_gpio, 1); usleep_range(10000, 10050); gpio_set_value_cansleep(pn547_dev->ven_gpio, 0); usleep_range(10000, 10050); gpio_set_value_cansleep(pn547_dev->ven_gpio, 1); usleep_range(10000, 10050); if (atomic_read(&pn547_dev->irq_enabled) == 0) { atomic_set(&pn547_dev->irq_enabled, 1); enable_irq(pn547_dev->client->irq); enable_irq_wake(pn547_dev->client->irq); } pr_info("%s power on with firmware, irq=%d\n", __func__, atomic_read(&pn547_dev->irq_enabled)); } else if (arg == 1) { /* power on */ if (pn547_dev->conf_gpio) pn547_dev->conf_gpio(); gpio_set_value(pn547_dev->firm_gpio, 0); #if defined(CONFIG_SEC_MILLETWIFI_COMMON) || defined(CONFIG_SEC_RUBENSLTE_COMMON) || defined(CONFIG_SEC_RUBENSWIFI_COMMON) gpio_direction_output(pn547_dev->ven_gpio, 1); #endif gpio_set_value_cansleep(pn547_dev->ven_gpio, 1); usleep_range(10000, 10050); if (atomic_read(&pn547_dev->irq_enabled) == 0) { atomic_set(&pn547_dev->irq_enabled, 1); enable_irq(pn547_dev->client->irq); enable_irq_wake(pn547_dev->client->irq); } pr_info("%s power on, irq=%d\n", __func__, atomic_read(&pn547_dev->irq_enabled)); } else if (arg == 0) { /* power off */ if (atomic_read(&pn547_dev->irq_enabled) == 1) { atomic_set(&pn547_dev->irq_enabled, 0); disable_irq_wake(pn547_dev->client->irq); disable_irq_nosync(pn547_dev->client->irq); } pr_info("%s power off, irq=%d\n", __func__, atomic_read(&pn547_dev->irq_enabled)); gpio_set_value(pn547_dev->firm_gpio, 0); #if defined(CONFIG_SEC_MILLETWIFI_COMMON) || defined(CONFIG_SEC_RUBENSLTE_COMMON) || defined(CONFIG_SEC_RUBENSWIFI_COMMON) gpio_direction_output(pn547_dev->ven_gpio, 0); #endif gpio_set_value_cansleep(pn547_dev->ven_gpio, 0); usleep_range(10000, 10050); } else if (arg == 3) { pr_info("%s Read Cancel\n", __func__); pn547_dev->cancel_read = true; atomic_set(&pn547_dev->read_flag, 1); wake_up(&pn547_dev->read_wq); } else { pr_err("%s bad arg %lu\n", __func__, arg); return -EINVAL; } break; default: pr_err("%s bad ioctl %u\n", __func__, cmd); return -EINVAL; } return 0; }
static int mipi_samsung_disp_send_cmd(struct msm_fb_data_type *mfd, enum mipi_samsung_cmd_list cmd, unsigned char lock) { struct dsi_cmd_desc *cmd_desc; struct dcs_cmd_req cmdreq; int cmd_size = 0; /* wake_lock(&idle_wake_lock);*//*temp*/ if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_lock(&dsi_tx_mutex); else { if (lock) mutex_lock(&mfd->dma->ov_mutex); } pr_info("%s cmd = 0x%x\n", __func__, cmd); switch (cmd) { case PANEL_READY_TO_ON: /*work*/ cmd_desc = msd.mpd->ready_to_on.cmd; cmd_size = msd.mpd->ready_to_on.size; break; case PANEL_READY_TO_OFF: cmd_desc = msd.mpd->ready_to_off.cmd; cmd_size = msd.mpd->ready_to_off.size; break; case PANEL_ON: cmd_desc = msd.mpd->on.cmd; cmd_size = msd.mpd->on.size; break; case PANEL_OFF: cmd_desc = msd.mpd->off.cmd; cmd_size = msd.mpd->off.size; break; case PANEL_LATE_ON: cmd_desc = msd.mpd->late_on.cmd; cmd_size = msd.mpd->late_on.size; break; case PANEL_EARLY_OFF: cmd_desc = msd.mpd->early_off.cmd; cmd_size = msd.mpd->early_off.size; break; case MTP_READ_ENABLE: cmd_desc = msd.mpd->mtp_read_enable.cmd; cmd_size = msd.mpd->mtp_read_enable.size; break; /* case PANEL_TUNE_CTRL: cmd_desc = msd.mpd->tune.cmd; cmd_size = msd.mpd->tune.size; break; */ default: goto unknown_command; ; } if (!cmd_size) goto unknown_command; cmdreq.cmds = cmd_desc; cmdreq.cmds_cnt = cmd_size; cmdreq.flags = CMD_REQ_COMMIT; cmdreq.rlen = 0; cmdreq.cb = NULL; mipi_dsi_cmdlist_put(&cmdreq); if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_unlock(&dsi_tx_mutex); else { if (lock) mutex_unlock(&mfd->dma->ov_mutex); } return 0; unknown_command: if (mfd->panel.type == MIPI_VIDEO_PANEL) mutex_unlock(&dsi_tx_mutex); else { if (lock) mutex_unlock(&mfd->dma->ov_mutex); } return 0; }
static int afe_debug_open(struct inode *inode, struct file *file) { file->private_data = inode->i_private; pr_info("debug intf %s\n", (char *) file->private_data); return 0; }
static int mipi_samsung_disp_on(struct platform_device *pdev) { struct msm_fb_data_type *mfd; struct mipi_panel_info *mipi; static int boot_on; #ifdef __DEBUG__ static int test=0 ; #endif mfd = platform_get_drvdata(pdev); if (unlikely(!mfd)) return -ENODEV; if (unlikely(mfd->key != MFD_KEY)) return -EINVAL; mipi = &mfd->panel_info.mipi; #ifdef USE_READ_ID if (unlikely(!boot_on)) { msd.mpd->manufacture_id = mipi_samsung_manufacture_id(mfd); /*Display was initialized in bootloader,same settings are carried when splash is enabled*/ } #endif #if defined(CONFIG_FB_MDP4_ENHANCE) is_negativeMode_on(); #endif #ifdef __DEBUG__ if(test==0) if(0) dumpreg(1); test++; #endif mipi_samsung_disp_send_cmd(mfd, PANEL_READY_TO_ON, false); if(!boot_on) boot_on = 1; else msleep(100); #if defined(CONFIG_ESD_ERR_FG_RECOVERY) enable_irq(err_fg_gpio); #endif #ifndef CONFIG_MACH_CANE_EUR_3G pr_info("%s: DISP_BL_CONT_GPIO High\n", __func__); gpio_set_value(DISP_BL_CONT_GPIO, 1); #endif #if !defined(CONFIG_HAS_EARLYSUSPEND) mipi_samsung_disp_send_cmd(mfd, PANEL_LATE_ON, false); #endif #if defined(CONFIG_MACH_CANE_EUR_3G) mfd->resume_state = MIPI_RESUME_STATE; #endif return 0; }
int afe_close(int port_id) { struct afe_port_stop_command stop; int ret = 0; if (this_afe.apr == NULL) { pr_err("AFE is already closed\n"); ret = -EINVAL; goto fail_cmd; } pr_debug("%s: port_id=%d\n", __func__, port_id); if ((port_id == RT_PROXY_DAI_001_RX) || (port_id == RT_PROXY_DAI_002_TX)) { pr_debug("%s: before decrementing pcm_afe_instance %d\n", __func__, pcm_afe_instance[port_id & 0x1]); port_id = VIRTUAL_ID_TO_PORTID(port_id); pcm_afe_instance[port_id & 0x1]--; if (!(pcm_afe_instance[port_id & 0x1] == 0 && proxy_afe_instance[port_id & 0x1] == 0)) return 0; else afe_close_done[port_id & 0x1] = true; } if ((port_id == RT_PROXY_DAI_002_RX) || (port_id == RT_PROXY_DAI_001_TX)) { pr_debug("%s: before decrementing proxy_afe_instance %d\n", __func__, proxy_afe_instance[port_id & 0x1]); port_id = VIRTUAL_ID_TO_PORTID(port_id); proxy_afe_instance[port_id & 0x1]--; if (!(pcm_afe_instance[port_id & 0x1] == 0 && proxy_afe_instance[port_id & 0x1] == 0)) return 0; else afe_close_done[port_id & 0x1] = true; } port_id = afe_convert_virtual_to_portid(port_id); stop.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD, APR_HDR_LEN(APR_HDR_SIZE), APR_PKT_VER); stop.hdr.pkt_size = sizeof(stop); stop.hdr.src_port = 0; stop.hdr.dest_port = 0; stop.hdr.token = 0; stop.hdr.opcode = AFE_PORT_CMD_STOP; stop.port_id = port_id; stop.reserved = 0; atomic_set(&this_afe.state, 1); ret = apr_send_pkt(this_afe.apr, (uint32_t *) &stop); if (ret == -ENETRESET) { pr_info("%s: Need to reset, calling APR deregister", __func__); return apr_deregister(this_afe.apr); } if (ret < 0) { pr_err("%s: AFE close failed\n", __func__); ret = -EINVAL; goto fail_cmd; } ret = wait_event_timeout(this_afe.wait, (atomic_read(&this_afe.state) == 0), msecs_to_jiffies(TIMEOUT_MS)); if (!ret) { pr_err("%s: wait_event timeout\n", __func__); ret = -EINVAL; goto fail_cmd; } fail_cmd: return ret; }
static int it660x_i2c_remove(struct i2c_client *client) { pr_info("%s driver removed ok.\n", client->name); return 0; }
static long audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct q6audio_aio *audio = file->private_data; int rc = 0; switch (cmd) { case AUDIO_START: { struct asm_aac_cfg aac_cfg; struct msm_audio_aac_config *aac_config; uint32_t sbr_ps = 0x00; pr_debug("%s: AUDIO_START session_id[%d]\n", __func__, audio->ac->session); if (audio->feedback == NON_TUNNEL_MODE) { /* Configure PCM output block */ rc = q6asm_enc_cfg_blk_pcm(audio->ac, 0, 0); if (rc < 0) { pr_err("pcm output block config failed\n"); break; } } /* turn on both sbr and ps */ rc = q6asm_enable_sbrps(audio->ac, sbr_ps); if (rc < 0) pr_err("sbr-ps enable failed\n"); aac_config = (struct msm_audio_aac_config *)audio->codec_cfg; if (aac_config->sbr_ps_on_flag) aac_cfg.aot = AAC_ENC_MODE_EAAC_P; else if (aac_config->sbr_on_flag) aac_cfg.aot = AAC_ENC_MODE_AAC_P; else aac_cfg.aot = AAC_ENC_MODE_AAC_LC; switch (aac_config->format) { case AUDIO_AAC_FORMAT_ADTS: aac_cfg.format = 0x00; break; case AUDIO_AAC_FORMAT_LOAS: aac_cfg.format = 0x01; break; case AUDIO_AAC_FORMAT_ADIF: aac_cfg.format = 0x02; break; default: case AUDIO_AAC_FORMAT_RAW: aac_cfg.format = 0x03; } aac_cfg.ep_config = aac_config->ep_config; aac_cfg.section_data_resilience = aac_config->aac_section_data_resilience_flag; aac_cfg.scalefactor_data_resilience = aac_config->aac_scalefactor_data_resilience_flag; aac_cfg.spectral_data_resilience = aac_config->aac_spectral_data_resilience_flag; aac_cfg.ch_cfg = audio->pcm_cfg.channel_count; aac_cfg.sample_rate = audio->pcm_cfg.sample_rate; pr_debug("%s:format=%x aot=%d ch=%d sr=%d\n", __func__, aac_cfg.format, aac_cfg.aot, aac_cfg.ch_cfg, aac_cfg.sample_rate); /* Configure Media format block */ rc = q6asm_media_format_block_aac(audio->ac, &aac_cfg); if (rc < 0) { pr_err("cmd media format block failed\n"); break; } rc = audio_aio_enable(audio); audio->eos_rsp = 0; audio->eos_flag = 0; if (!rc) { audio->enabled = 1; } else { audio->enabled = 0; pr_err("Audio Start procedure failed rc=%d\n", rc); break; } pr_info("%s: AUDIO_START sessionid[%d]enable[%d]\n", __func__, audio->ac->session, audio->enabled); if (audio->stopped == 1) audio->stopped = 0; break; } case AUDIO_GET_AAC_CONFIG: { if (copy_to_user((void *)arg, audio->codec_cfg, sizeof(struct msm_audio_aac_config))) { rc = -EFAULT; break; } break; } case AUDIO_SET_AAC_CONFIG: { struct msm_audio_aac_config *aac_config; pr_debug("%s: AUDIO_SET_AAC_CONFIG\n", __func__); if (copy_from_user(audio->codec_cfg, (void *)arg, sizeof(struct msm_audio_aac_config))) { rc = -EFAULT; break; } else { uint16_t sce_left = 1, sce_right = 2; aac_config = audio->codec_cfg; if ((aac_config->dual_mono_mode < AUDIO_AAC_DUAL_MONO_PL_PR) || (aac_config->dual_mono_mode > AUDIO_AAC_DUAL_MONO_PL_SR)) { pr_err("%s:AUDIO_SET_AAC_CONFIG: Invalid" "dual_mono mode =%d\n", __func__, aac_config->dual_mono_mode); } else { /* convert the data from user into sce_left * and sce_right based on the definitions */ pr_debug("%s: AUDIO_SET_AAC_CONFIG: modify" "dual_mono mode =%d\n", __func__, aac_config->dual_mono_mode); switch (aac_config->dual_mono_mode) { case AUDIO_AAC_DUAL_MONO_PL_PR: sce_left = 1; sce_right = 1; break; case AUDIO_AAC_DUAL_MONO_SL_SR: sce_left = 2; sce_right = 2; break; case AUDIO_AAC_DUAL_MONO_SL_PR: sce_left = 2; sce_right = 1; break; case AUDIO_AAC_DUAL_MONO_PL_SR: default: sce_left = 1; sce_right = 2; break; } rc = q6asm_cfg_dual_mono_aac(audio->ac, sce_left, sce_right); if (rc < 0) pr_err("%s: asm cmd dualmono failed" " rc=%d\n", __func__, rc); } } break; } default: pr_debug("%s[%p]: Calling utils ioctl\n", __func__, audio); rc = audio->codec_ioctl(file, cmd, arg); if (rc) pr_err("%s[%p]:Failed in utils_ioctl: %d\n", __func__, audio, rc); } return rc; }
static inline void set_restart_reason(unsigned int reason) { pr_info("%s: set restart reason = %08x\r\n", __func__, reason); reboot_params->reboot_reason = reason; mb(); }