static int __init lcdc_driver_init(void) { pixel_mdp_clk = clk_get(NULL, "pixel_mdp_clk"); if (IS_ERR(pixel_mdp_clk)) pixel_mdp_clk = NULL; if (pixel_mdp_clk) { pixel_lcdc_clk = clk_get(NULL, "pixel_lcdc_clk"); if (IS_ERR(pixel_lcdc_clk)) { printk(KERN_ERR "Couldnt find pixel_lcdc_clk\n"); return -EINVAL; } } else { pixel_mdp_clk = clk_get(NULL, "mdp_lcdc_pclk_clk"); if (IS_ERR(pixel_mdp_clk)) { printk(KERN_ERR "Couldnt find mdp_lcdc_pclk_clk\n"); return -EINVAL; } pixel_lcdc_clk = clk_get(NULL, "mdp_lcdc_pad_pclk_clk"); if (IS_ERR(pixel_lcdc_clk)) { printk(KERN_ERR "Couldnt find mdp_lcdc_pad_pclk_clk\n"); return -EINVAL; } } pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ , "lcdc", PM_QOS_DEFAULT_VALUE); return lcdc_register_driver(); }
static int __init mddi_driver_init(void) { int ret; mddi_clk = clk_get(NULL, "mddi_clk"); if (IS_ERR(mddi_clk)) { printk(KERN_ERR "can't find mddi_clk \n"); return PTR_ERR(mddi_clk); } #ifdef CONFIG_SHLCDC_BOARD pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, "mddi", 117000); #endif clk_enable(mddi_clk); ret = mddi_register_driver(); if (ret) { clk_disable(mddi_clk); #ifdef CONFIG_SHLCDC_BOARD pm_qos_remove_requirement(PM_QOS_SYSTEM_BUS_FREQ, "mddi"); #endif clk_put(mddi_clk); printk(KERN_ERR "mddi_register_driver() failed!\n"); return ret; } mddi_init(); return ret; }
u32 res_trk_power_up(void) { VCDRES_MSG_LOW("clk_regime_rail_enable"); VCDRES_MSG_LOW("clk_regime_sel_rail_control"); #ifdef AXI_CLK_SCALING { int rc; VCDRES_MSG_MED("\n res_trk_power_up():: " "Calling AXI add requirement\n"); rc = pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, MSM_AXI_QOS_NAME, PM_QOS_DEFAULT_VALUE); if (rc < 0) { VCDRES_MSG_ERROR("Request AXI bus QOS fails. rc = %d\n", rc); return FALSE; } } #endif #ifdef USE_RES_TRACKER VCDRES_MSG_MED("\n res_trk_power_up():: Calling " "vid_c_enable_pwr_rail()\n"); return vid_c_enable_pwr_rail(); #endif return TRUE; }
static int __init ehci_msm_probe(struct platform_device *pdev) { struct usb_hcd *hcd; struct resource *res; struct msm_usb_host_platform_data *pdata; int retval; struct msmusb_hcd *mhcd; hcd = usb_create_hcd(&msm_hc_driver, &pdev->dev, dev_name(&pdev->dev)); if (!hcd) return -ENOMEM; hcd->irq = platform_get_irq(pdev, 0); if (hcd->irq < 0) { usb_put_hcd(hcd); return hcd->irq; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { usb_put_hcd(hcd); return -ENODEV; } hcd->rsrc_start = res->start; hcd->rsrc_len = resource_size(res); mhcd = hcd_to_mhcd(hcd); spin_lock_init(&mhcd->lock); mhcd->in_lpm = 0; mhcd->running = 0; device_init_wakeup(&pdev->dev, 1); pdata = pdev->dev.platform_data; if (PHY_TYPE(pdata->phy_info) == USB_PHY_UNDEFINED) { usb_put_hcd(hcd); return -ENODEV; } hcd->power_budget = pdata->power_budget; mhcd->pdata = pdata; INIT_WORK(&mhcd->lpm_exit_work, usb_lpm_exit_w); wake_lock_init(&mhcd->wlock, WAKE_LOCK_SUSPEND, dev_name(&pdev->dev)); pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, (char *)dev_name(&pdev->dev), PM_QOS_DEFAULT_VALUE); retval = msm_xusb_init_host(mhcd); if (retval < 0) { usb_put_hcd(hcd); wake_lock_destroy(&mhcd->wlock); pm_qos_remove_requirement(PM_QOS_SYSTEM_BUS_FREQ, (char *) dev_name(&pdev->dev)); } return retval; }
int add_axi_qos(void) { int rc = 0; rc = pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, MSM_AXI_QOS_NAME, PM_QOS_DEFAULT_VALUE); if (rc < 0) CDBG("request AXI bus QOS fails. rc = %d\n", rc); return rc; }
static int __init lcdc_driver_init(void) { mdp_lcdc_pclk_clk = clk_get(NULL, "mdp_lcdc_pclk_clk"); if (IS_ERR(mdp_lcdc_pclk_clk)) { printk(KERN_ERR "error: can't get mdp_lcdc_pclk_clk!\n"); return IS_ERR(mdp_lcdc_pclk_clk); } mdp_lcdc_pad_pclk_clk = clk_get(NULL, "mdp_lcdc_pad_pclk_clk"); if (IS_ERR(mdp_lcdc_pad_pclk_clk)) { printk(KERN_ERR "error: can't get mdp_lcdc_pad_pclk_clk!\n"); return IS_ERR(mdp_lcdc_pad_pclk_clk); } pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ , "lcdc", PM_QOS_DEFAULT_VALUE); return lcdc_register_driver(); }
int request_axi_qos(void) { int rc = 0; if (!axi_qos_requested) { rc = pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ , "msm_camera", MSM_AXI_MAX_FREQ); if (rc < 0) { printk(KERN_ERR "Unable to request AXI bus QOS\n"); } else { CDBG("%s: request successful\n", __func__); axi_qos_requested = 1; msleep(5); } } return rc; }
int request_axi_qos(uint32_t freq) { int rc = 0; if (!axi_qos_requested) { rc = pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, MSM_AXI_QOS_NAME, freq); if (rc < 0) CDBG("request AXI bus QOS fails. rc = %d\n", rc); else { CDBG("%s: request successful\n", __func__); axi_qos_requested = 1; msleep(5); } } return rc; }
static int __init tovis_qvga_init(void) { int ret; struct msm_panel_info *pinfo; ret = platform_driver_register(&this_driver); if (!ret) { printk("kurze-LCD is Tovis (END Key Pressed!)\n"); tovis_qvga_panel_data.on = tovis_qvga_disp_on; tovis_qvga_panel_data.off = tovis_qvga_disp_off; tovis_qvga_panel_data.set_backlight = NULL; tovis_qvga_panel_data.set_rect = tovis_qvga_disp_set_rect; pinfo = &tovis_qvga_panel_data.panel_info; pinfo->xres = 240; pinfo->yres = 320; pinfo->type = EBI2_PANEL; pinfo->pdest = DISPLAY_1; pinfo->wait_cycle = 0x109104; // ebi2 timing reduced by bongkyu.kim #ifdef TOVIS_LCD_18BPP pinfo->bpp = 18; #else pinfo->bpp = 16; #endif pinfo->fb_num = 2; pinfo->lcd.vsync_enable = TRUE; pinfo->lcd.refx100 = 6000; pinfo->lcd.v_back_porch = 8; pinfo->lcd.v_front_porch = 4; pinfo->lcd.v_pulse_width = 0; pinfo->lcd.hw_vsync_mode = TRUE; pinfo->lcd.vsync_notifier_period = 0; ret = platform_device_register(&this_device); if (ret) platform_driver_unregister(&this_driver); } pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, "ebi2_lcd", PM_QOS_DEFAULT_VALUE); return ret; }
static int __init dtv_driver_init(void) { tv_enc_clk = clk_get(NULL, "tv_enc_clk"); if (IS_ERR(tv_enc_clk)) { printk(KERN_ERR "error: can't get tv_enc_clk!\n"); return IS_ERR(tv_enc_clk); } tv_dac_clk = clk_get(NULL, "tv_dac_clk"); if (IS_ERR(tv_dac_clk)) { printk(KERN_ERR "error: can't get tv_dac_clk!\n"); return IS_ERR(tv_dac_clk); } tv_src_clk = clk_get(NULL, "tv_src_clk"); if (IS_ERR(tv_src_clk)) { tv_src_clk = tv_enc_clk; /* Fallback to slave */ pr_info("%s: tv_src_clk not available, using tv_enc_clk" " instead\n", __func__); } hdmi_clk = clk_get(NULL, "hdmi_clk"); if (IS_ERR(hdmi_clk)) { printk(KERN_ERR "error: can't get hdmi_clk!\n"); return IS_ERR(hdmi_clk); } mdp_tv_clk = clk_get(NULL, "mdp_tv_clk"); if (IS_ERR(mdp_tv_clk)) mdp_tv_clk = NULL; pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ , "dtv", PM_QOS_DEFAULT_VALUE); return dtv_register_driver(); }
static int __init ehci_msm_probe(struct platform_device *pdev) { struct usb_hcd *hcd; struct resource *res; struct msm_usb_host_platform_data *pdata; int retval; int id = pdev->id; struct msmusb_hcd *mhcd; char *usb_clks[] = { "usb_hs_clk", "usb_hs2_clk" }; char *usb_pclks[] = { "usb_hs_pclk", "usb_hs2_pclk" }; hcd = usb_create_hcd(&msm_hc_driver, &pdev->dev, pdev->dev.bus_id); if (!hcd) return -ENOMEM; hcd->irq = platform_get_irq(pdev, 0); if (hcd->irq < 0) { retval = hcd->irq; goto err_free_hcd; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { retval = -ENODEV; goto err_free_hcd; } hcd->rsrc_start = res->start; hcd->rsrc_len = resource_size(res); hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len); if (!hcd->regs) { retval = -EFAULT; goto err_free_hcd; } mhcd = hcd_to_mhcd(hcd); spin_lock_init(&mhcd->lock); mhcd->in_lpm = 0; mhcd->running = 0; device_init_wakeup(&pdev->dev, 1); /* get usb clocks */ mhcd->clk = clk_get(&pdev->dev, usb_clks[id]); if (IS_ERR(mhcd->clk)) { retval = -ENODEV; goto err_map; } mhcd->pclk = clk_get(&pdev->dev, usb_pclks[id]); if (IS_ERR(mhcd->pclk)) { retval = -ENODEV; goto err_map; } pdata = pdev->dev.platform_data; if (PHY_TYPE(pdata->phy_info) == USB_PHY_UNDEFINED) { retval = -ENODEV; goto err_map; } mhcd->pdata = pdata; INIT_WORK(&mhcd->lpm_exit_work, usb_lpm_exit_w); wake_lock_init(&mhcd->wlock, WAKE_LOCK_SUSPEND, pdev->dev.bus_id); pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, pdev->dev.bus_id, PM_QOS_DEFAULT_VALUE); /* Register with otg driver. If registration fails, start usb host */ mhcd->otg_ops.request = msm_hsusb_request_host; mhcd->otg_ops.handle = (void *) mhcd; retval = msm_xusb_otg_register(mhcd); if (retval < 0) goto err_map; return retval; err_map: iounmap(hcd->regs); err_free_hcd: usb_put_hcd(hcd); return retval; }
static int msm_i2c_probe(struct platform_device *pdev) { struct msm_i2c_dev *dev; struct resource *mem, *irq, *ioarea; int ret; int fs_div; int hs_div; int i2c_clk; int clk_ctl; struct clk *clk; struct msm_i2c_platform_data *pdata; printk(KERN_INFO "msm_i2c_probe\n"); /* NOTE: driver uses the static register mapping */ mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!mem) { dev_err(&pdev->dev, "no mem resource?\n"); return -ENODEV; } irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0); if (!irq) { dev_err(&pdev->dev, "no irq resource?\n"); return -ENODEV; } ioarea = request_mem_region(mem->start, (mem->end - mem->start) + 1, pdev->name); if (!ioarea) { dev_err(&pdev->dev, "I2C region already claimed\n"); return -EBUSY; } clk = clk_get(&pdev->dev, "i2c_clk"); if (IS_ERR(clk)) { dev_err(&pdev->dev, "Could not get clock\n"); ret = PTR_ERR(clk); goto err_clk_get_failed; } pdata = pdev->dev.platform_data; if (!pdata) { dev_err(&pdev->dev, "platform data not initialized\n"); ret = -ENOSYS; goto err_clk_get_failed; } if (!pdata->msm_i2c_config_gpio) { dev_err(&pdev->dev, "config_gpio function not initialized\n"); ret = -ENOSYS; goto err_clk_get_failed; } /* We support frequencies upto FAST Mode(400KHz) */ if (pdata->clk_freq <= 0 || pdata->clk_freq > 400000) { dev_err(&pdev->dev, "clock frequency not supported\n"); ret = -EIO; goto err_clk_get_failed; } dev = kzalloc(sizeof(struct msm_i2c_dev), GFP_KERNEL); if (!dev) { ret = -ENOMEM; goto err_alloc_dev_failed; } dev->dev = &pdev->dev; dev->irq = irq->start; dev->clk = clk; dev->pdata = pdata; dev->base = ioremap(mem->start, (mem->end - mem->start) + 1); if (!dev->base) { ret = -ENOMEM; goto err_ioremap_failed; } spin_lock_init(&dev->lock); platform_set_drvdata(pdev, dev); clk_enable(clk); if (pdata->rmutex != NULL) remote_spin_lock_init(&dev->rspin_lock, pdata->rsl_id); /* I2C_HS_CLK = I2C_CLK/(3*(HS_DIVIDER_VALUE+1) */ /* I2C_FS_CLK = I2C_CLK/(2*(FS_DIVIDER_VALUE+3) */ /* FS_DIVIDER_VALUE = ((I2C_CLK / I2C_FS_CLK) / 2) - 3 */ i2c_clk = 19200000; /* input clock */ fs_div = ((i2c_clk / pdata->clk_freq) / 2) - 3; hs_div = 3; clk_ctl = ((hs_div & 0x7) << 8) | (fs_div & 0xff); writel(clk_ctl, dev->base + I2C_CLK_CTL); printk(KERN_INFO "msm_i2c_probe: clk_ctl %x, %d Hz\n", clk_ctl, i2c_clk / (2 * ((clk_ctl & 0xff) + 3))); i2c_set_adapdata(&dev->adap_pri, dev); dev->adap_pri.algo = &msm_i2c_algo; strlcpy(dev->adap_pri.name, "MSM I2C adapter-PRI", sizeof(dev->adap_pri.name)); dev->adap_pri.nr = pdev->id; ret = i2c_add_numbered_adapter(&dev->adap_pri); if (ret) { dev_err(&pdev->dev, "Primary i2c_add_adapter failed\n"); goto err_i2c_add_adapter_failed; } ret = request_irq(dev->irq, msm_i2c_interrupt, IRQF_TRIGGER_RISING, pdev->name, dev); if (ret) { dev_err(&pdev->dev, "request_irq failed\n"); goto err_request_irq_failed; } pm_qos_add_requirement(PM_QOS_CPU_DMA_LATENCY, "msm_i2c", PM_QOS_DEFAULT_VALUE); disable_irq(dev->irq); dev->suspended = 0; mutex_init(&dev->mlock); /* Config GPIOs for primary and secondary lines */ pdata->msm_i2c_config_gpio(dev->adap_pri.nr, 1); return 0; err_request_irq_failed: i2c_del_adapter(&dev->adap_pri); err_i2c_add_adapter_failed: clk_disable(clk); iounmap(dev->base); err_ioremap_failed: kfree(dev); err_alloc_dev_failed: clk_put(clk); err_clk_get_failed: release_mem_region(mem->start, (mem->end - mem->start) + 1); return ret; }
static int mddi_probe(struct platform_device *pdev) { struct msm_fb_data_type *mfd; struct platform_device *mdp_dev = NULL; struct msm_fb_panel_data *pdata = NULL; int rc; resource_size_t size ; u32 clk_rate; if ((pdev->id == 0) && (pdev->num_resources >= 0)) { mddi_pdata = pdev->dev.platform_data; size = resource_size(&pdev->resource[0]); msm_pmdh_base = ioremap(pdev->resource[0].start, size); MSM_FB_INFO("primary mddi base phy_addr = 0x%x virt = 0x%x\n", pdev->resource[0].start, (int) msm_pmdh_base); if (unlikely(!msm_pmdh_base)) return -ENOMEM; if (mddi_pdata && mddi_pdata->mddi_power_save) mddi_pdata->mddi_power_save(1); mddi_resource_initialized = 1; return 0; } if (!mddi_resource_initialized) return -EPERM; mfd = platform_get_drvdata(pdev); if (!mfd) return -ENODEV; if (mfd->key != MFD_KEY) return -EINVAL; if (pdev_list_cnt >= MSM_FB_MAX_DEV_LIST) return -ENOMEM; mdp_dev = platform_device_alloc("mdp", pdev->id); if (!mdp_dev) return -ENOMEM; /* * link to the latest pdev */ mfd->pdev = mdp_dev; mfd->dest = DISPLAY_LCD; /* * alloc panel device data */ if (platform_device_add_data (mdp_dev, pdev->dev.platform_data, sizeof(struct msm_fb_panel_data))) { printk(KERN_ERR "mddi_probe: platform_device_add_data failed!\n"); platform_device_put(mdp_dev); return -ENOMEM; } /* * data chain */ pdata = mdp_dev->dev.platform_data; pdata->on = mddi_on; pdata->off = mddi_off; pdata->next = pdev; /* * get/set panel specific fb info */ mfd->panel_info = pdata->panel_info; if (mfd->index == 0) mfd->fb_imgType = MSMFB_DEFAULT_TYPE; else mfd->fb_imgType = MDP_RGB_565; clk_rate = mfd->panel_info.clk_max; if (mddi_pdata && mddi_pdata->mddi_sel_clk && mddi_pdata->mddi_sel_clk(&clk_rate)) printk(KERN_ERR "%s: can't select mddi io clk targate rate = %d\n", __func__, clk_rate); if (clk_set_max_rate(mddi_clk, clk_rate) < 0) printk(KERN_ERR "%s: clk_set_max_rate failed\n", __func__); mfd->panel_info.clk_rate = mfd->panel_info.clk_min; if (!mddi_client_type) mddi_client_type = mfd->panel_info.lcd.rev; else if (!mfd->panel_info.lcd.rev) printk(KERN_ERR "%s: mddi client is trying to revert back to type 1 !!!\n", __func__); /* * set driver data */ platform_set_drvdata(mdp_dev, mfd); /* * register in mdp driver */ rc = platform_device_add(mdp_dev); if (rc) goto mddi_probe_err; pdev_list[pdev_list_cnt++] = pdev; #ifdef CONFIG_HAS_EARLYSUSPEND mfd->mddi_early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB; mfd->mddi_early_suspend.suspend = mddi_early_suspend; mfd->mddi_early_suspend.resume = mddi_early_resume; register_early_suspend(&mfd->mddi_early_suspend); #endif pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ , "mddi", PM_QOS_DEFAULT_VALUE); return 0; mddi_probe_err: platform_device_put(mdp_dev); return rc; }
int kgsl_pwrctrl_init(struct kgsl_device *device) { int i, result = 0; struct clk *clk; struct platform_device *pdev = container_of(device->parentdev, struct platform_device, dev); struct kgsl_pwrctrl *pwr = &device->pwrctrl; struct kgsl_device_platform_data *pdata_dev = pdev->dev.platform_data; struct kgsl_device_pwr_data *pdata_pwr = &pdata_dev->pwr_data; const char *clk_names[KGSL_MAX_CLKS] = {pwr->src_clk_name, pdata_dev->clk.name.clk, pdata_dev->clk.name.pclk, pdata_dev->imem_clk_name.clk, pdata_dev->imem_clk_name.pclk}; /*acquire clocks */ for (i = 1; i < KGSL_MAX_CLKS; i++) { if (clk_names[i]) { clk = clk_get(&pdev->dev, clk_names[i]); if (IS_ERR(clk)) goto clk_err; pwr->grp_clks[i] = clk; } } /* Make sure we have a source clk for freq setting */ clk = clk_get(&pdev->dev, clk_names[0]); pwr->grp_clks[0] = (IS_ERR(clk)) ? pwr->grp_clks[1] : clk; /* put the AXI bus into asynchronous mode with the graphics cores */ if (pdata_pwr->set_grp_async != NULL) pdata_pwr->set_grp_async(); if (pdata_pwr->num_levels > KGSL_MAX_PWRLEVELS) { KGSL_PWR_ERR(device, "invalid power level count: %d\n", pdata_pwr->num_levels); result = -EINVAL; goto done; } pwr->num_pwrlevels = pdata_pwr->num_levels; pwr->active_pwrlevel = pdata_pwr->init_level; for (i = 0; i < pdata_pwr->num_levels; i++) { pwr->pwrlevels[i].gpu_freq = (pdata_pwr->pwrlevel[i].gpu_freq > 0) ? clk_round_rate(pwr->grp_clks[0], pdata_pwr->pwrlevel[i]. gpu_freq) : 0; pwr->pwrlevels[i].bus_freq = pdata_pwr->pwrlevel[i].bus_freq; pwr->pwrlevels[i].io_fraction = pdata_pwr->pwrlevel[i].io_fraction; } /* Do not set_rate for targets in sync with AXI */ if (pwr->pwrlevels[0].gpu_freq > 0) clk_set_rate(pwr->grp_clks[0], pwr-> pwrlevels[pwr->num_pwrlevels - 1].gpu_freq); pwr->gpu_reg = regulator_get(NULL, pwr->regulator_name); if (IS_ERR(pwr->gpu_reg)) pwr->gpu_reg = NULL; if (internal_pwr_rail_mode(device->pwrctrl.pwr_rail, PWR_RAIL_CTL_MANUAL)) { KGSL_PWR_ERR(device, "internal_pwr_rail_mode failed\n"); result = -EINVAL; goto done; } pwr->power_flags = 0; pwr->nap_allowed = pdata_pwr->nap_allowed; pwr->interval_timeout = pdata_pwr->idle_timeout; pwr->ebi1_clk = clk_get(&pdev->dev, "bus_clk"); if (IS_ERR(pwr->ebi1_clk)) pwr->ebi1_clk = NULL; else clk_set_rate(pwr->ebi1_clk, pwr->pwrlevels[pwr->active_pwrlevel]. bus_freq); pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, "kgsl_3d", PM_QOS_DEFAULT_VALUE); /*acquire interrupt */ pwr->interrupt_num = platform_get_irq_byname(pdev, pwr->irq_name); if (pwr->interrupt_num <= 0) { KGSL_PWR_ERR(device, "platform_get_irq_byname failed: %d\n", pwr->interrupt_num); result = -EINVAL; goto done; } register_early_suspend(&device->display_off); return result; clk_err: result = PTR_ERR(clk); KGSL_PWR_ERR(device, "clk_get(%s) failed: %d\n", clk_names[i], result); done: return result; }
static int __init mic_init(void) { int ret, i; adapter_init(); unaligned_cache = micscif_kmem_cache_create(); if (!unaligned_cache) { ret = -ENOMEM; goto init_free_ports; } mic_lindata.dd_pcidriver.name = "mic"; mic_lindata.dd_pcidriver.id_table = mic_pci_tbl; mic_lindata.dd_pcidriver.probe = mic_probe; mic_lindata.dd_pcidriver.remove = mic_remove; mic_lindata.dd_pcidriver.driver.pm = &pci_dev_pm_ops; mic_lindata.dd_pcidriver.shutdown = mic_shutdown; if ((ret = alloc_chrdev_region(&mic_lindata.dd_dev, 0, MAX_DLDR_MINORS, "mic") != 0)) { printk("Error allocating device nodes: %d\n", ret); goto init_free_ports; } cdev_init(&mic_lindata.dd_cdev, &mic_fops); mic_lindata.dd_cdev.owner = THIS_MODULE; mic_lindata.dd_cdev.ops = &mic_fops; if ((ret = cdev_add(&mic_lindata.dd_cdev, mic_lindata.dd_dev, MAX_DLDR_MINORS) != 0)) { kobject_put(&mic_lindata.dd_cdev.kobj); goto init_free_region; } mic_lindata.dd_class = class_create(THIS_MODULE, "mic"); if (IS_ERR(mic_lindata.dd_class)) { printk("MICDLDR: Error createing mic class\n"); cdev_del(&mic_lindata.dd_cdev); ret = PTR_ERR(mic_lindata.dd_class); goto init_free_region; } #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31) mic_lindata.dd_class->devnode = mic_devnode; #endif mic_lindata.dd_hostdev = device_create(mic_lindata.dd_class, NULL, mic_lindata.dd_dev, NULL, "ctrl"); mic_lindata.dd_scifdev = device_create(mic_lindata.dd_class, NULL, mic_lindata.dd_dev + 1, NULL, "scif"); ret = sysfs_create_group(&mic_lindata.dd_hostdev->kobj, &host_attr_group); ret = sysfs_create_group(&mic_lindata.dd_scifdev->kobj, &scif_attr_group); #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,31) mic_lindata.dd_class->devnode = NULL; #endif if (micveth_init(mic_lindata.dd_hostdev)) printk(KERN_ERR "%s: micveth_init failed\n", __func__); ret = pci_register_driver(&mic_lindata.dd_pcidriver); if (ret) { micscif_destroy(); printk("mic: failed to register pci driver %d\n", ret); goto clean_unregister; } if (!mic_data.dd_numdevs) { printk("mic: No MIC boards present. SCIF available in loopback mode\n"); } else { printk("mic: number of devices detected %d \n", mic_data.dd_numdevs); } for (i = 0; i < mic_data.dd_numdevs; i++) { mic_ctx_t *mic_ctx = get_per_dev_ctx(i); wait_event(mic_ctx->ioremapwq, mic_ctx->aper.va || mic_ctx->state == MIC_RESETFAIL); destroy_workqueue(mic_ctx->ioremapworkq); } micveth_init_legacy(mic_data.dd_numdevs, mic_lindata.dd_hostdev); ret = acptboot_init(); #ifdef USE_VCONSOLE micvcons_create(mic_data.dd_numdevs); #endif /* Initialize Data structures for PM Disconnect */ ret = micpm_disconn_init(mic_data.dd_numdevs + 1); if (ret) printk(KERN_ERR "%s: Failed to initialize PM disconnect" " data structures. PM may not work as expected." " ret = %d\n", __func__, ret); register_pm_notifier(&mic_pm_notifer); #if (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,34)) ret = pm_qos_add_requirement(PM_QOS_CPU_DMA_LATENCY, "mic", mic_pm_qos_cpu_dma_lat); if (ret) { printk(KERN_ERR "%s %d mic_pm_qos_cpu_dma_lat %d ret %d\n", __func__, __LINE__, mic_pm_qos_cpu_dma_lat, ret); ret = 0; /* Dont fail driver load due to PM QoS API. Fall through */ } #endif return 0; clean_unregister: device_destroy(mic_lindata.dd_class, mic_lindata.dd_dev + 1); device_destroy(mic_lindata.dd_class, mic_lindata.dd_dev); class_destroy(mic_lindata.dd_class); cdev_del(&mic_lindata.dd_cdev); unregister_pm_notifier(&mic_pm_notifer); init_free_region: unregister_chrdev_region(mic_lindata.dd_dev, MAX_DLDR_MINORS); init_free_ports: micpm_uninit(); return ret; }
static int msm72k_probe(struct platform_device *pdev) { struct usb_info *ui; struct msm_hsusb_gadget_platform_data *pdata; struct msm_otg *otg; int retval; INFO("msm72k_probe\n"); ui = kzalloc(sizeof(struct usb_info), GFP_KERNEL); if (!ui) return -ENOMEM; ui->pdev = pdev; if (pdev->dev.platform_data) { pdata = pdev->dev.platform_data; ui->phy_reset = pdata->phy_reset; ui->phy_init_seq = pdata->phy_init_seq; ui->chg_init = pdata->chg_init; ui->chg_connected = pdata->chg_connected; ui->chg_vbus_draw = pdata->chg_vbus_draw; ui->usb_connected = pdata->usb_connected; } if (ui->chg_init) ui->chg_init(1); ui->buf = dma_alloc_coherent(&pdev->dev, 4096, &ui->dma, GFP_KERNEL); if (!ui->buf) return usb_free(ui, -ENOMEM); ui->pool = dma_pool_create("msm72k_udc", NULL, 32, 32, 0); if (!ui->pool) return usb_free(ui, -ENOMEM); /* FIXME: dmb cannot be called from interrupt context * for the first time; Need to verify on how it needs * to be fixed */ dmb(); ui->xceiv = otg_get_transceiver(); if (!ui->xceiv) return usb_free(ui, -ENODEV); otg = to_msm_otg(ui->xceiv); ui->addr = otg->regs; ui->gadget.ops = &msm72k_ops; ui->gadget.is_dualspeed = 1; device_initialize(&ui->gadget.dev); strcpy(ui->gadget.dev.bus_id, "gadget"); ui->gadget.dev.parent = &pdev->dev; ui->gadget.dev.dma_mask = pdev->dev.dma_mask; the_usb_info = ui; pm_qos_add_requirement(PM_QOS_CPU_DMA_LATENCY, DRIVER_NAME, PM_QOS_DEFAULT_VALUE); pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, DRIVER_NAME, PM_QOS_DEFAULT_VALUE); usb_debugfs_init(ui); usb_prepare(ui); retval = otg_set_peripheral(ui->xceiv, &ui->gadget); if (retval) { pr_err("%s: Cannot bind the transceiver, retval:(%d)\n", __func__, retval); return usb_free(ui, retval); } return 0; }
static int __init pnx_serial_init(void) { int i; struct clk *pClk_13M; struct clk *pClk_26M; struct clk *pClk_pclk; struct pnx_uart *uart_pnx; pClk_13M=clk_get(NULL,"clk13m_ck"); pClk_26M=clk_get(NULL,"clk26m_ck"); pClk_pclk=clk_get(NULL,"pclk2_ck"); if (IS_ERR(pClk_13M) || IS_ERR(pClk_26M) || IS_ERR(pClk_pclk) ){ printk(KERN_WARNING "%s: parents clk failed\n", __func__); goto out; } /* supress void element from loop */ for (i = 0; i < (ARRAY_SIZE(serial_platform_data) - 1); i++) { struct clk *clk_tmp=NULL; /* Allocation of pnx struct on uart X */ uart_pnx=kzalloc(sizeof(*uart_pnx),GFP_KERNEL); if (!uart_pnx) continue; if (serial_platform_data[i].irq == IRQ_UART1) { clk_tmp = clk_get(NULL, "UART1"); strcpy(uart_pnx->uart_name, "UART1"); } else if (serial_platform_data[i].irq == IRQ_UART2) { clk_tmp = clk_get(NULL, "UART2"); strcpy(uart_pnx->uart_name, "UART2"); } /* initialize pclk2 rate management */ uart_pnx->pm_qos_status = PNX_UART_PM_QOS_DOWN; pm_qos_add_requirement(PM_QOS_PCLK2_THROUGHPUT, uart_pnx->uart_name, PM_QOS_DEFAULT_VALUE); uart_pnx->irq_enabled = 1; init_timer(&(uart_pnx->pm_qos_timer)); uart_pnx->pm_qos_timer.function = &pnx_serial_pm_qos_timeout; uart_pnx->pm_qos_timer.data= (unsigned long)uart_pnx; if ( !IS_ERR(clk_tmp) && clk_tmp!=NULL ){ uart_pnx->uartClk=clk_tmp; uart_pnx->pClk_13M=pClk_13M; uart_pnx->pClk_26M=pClk_26M; uart_pnx->pClk_pclk=pClk_pclk; serial_platform_data[i].private_data=uart_pnx; } else { printk(KERN_WARNING "%s - get uart clock failed error:%ld\n", __func__, PTR_ERR(clk_tmp)); kfree(uart_pnx); continue; } /* initialize uart1 activity detection (for console) */ pnx_serial_set_activity_detect(uart_pnx); } out: /* free clks */ clk_put(pClk_13M); clk_put(pClk_26M); clk_put(pClk_pclk); return platform_device_register(&serial_device); }
int msm_gemini_platform_clk_enable(void) { /* MP*fps*(1 + %blanking) 2MP: 24MHz ------ 2 x 10 x 1.2 3MP: 36MHz ------ 3 x 10 x 1.2 5MP: 60MHz ------ 5 x 10 x 1.2 8MP: 96MHz ------ 8 x 10 x 1.2 12MP: 144MHz ------12 x 10 x 1.2 */ int rc = -1; u32 rate = 144000000; if (jpeg_clk == NULL) { jpeg_clk = clk_get(NULL, "jpeg_clk"); if (jpeg_clk == NULL) { GMN_PR_ERR("%s:%d] fail rc = %d\n", __func__, __LINE__, rc); goto fail; } } rc = clk_set_min_rate(jpeg_clk, rate); if (rc) { GMN_PR_ERR("%s:%d] fail rc = %d\n", __func__, __LINE__, rc); goto fail; } rc = clk_enable(jpeg_clk); if (rc) { GMN_PR_ERR("%s:%d] fail rc = %d\n", __func__, __LINE__, rc); goto fail; } if (jpeg_pclk == NULL) { jpeg_pclk = clk_get(NULL, "jpeg_pclk"); if (jpeg_pclk == NULL) { GMN_PR_ERR("%s:%d] fail rc = %d\n", __func__, __LINE__, rc); goto fail; } } rc = clk_enable(jpeg_pclk); if (rc) { GMN_PR_ERR("%s:%d] fail rc = %d\n", __func__, __LINE__, rc); goto fail; } rc = pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, "msm_gemini", MSM_SYSTEM_BUS_RATE); if (rc) { GMN_PR_ERR("request AXI bus QOS fails. rc = %d\n", rc); goto fail; } GMN_DBG("%s:%d]\n", __func__, __LINE__); return rc; fail: GMN_PR_ERR("%s:%d] fail rc = %d\n", __func__, __LINE__, rc); return rc; }