static void ws2401_dpi_mcde_panel_late_resume(
struct early_suspend *earlysuspend)
{
struct ws2401_dpi *lcd = container_of(earlysuspend,
struct ws2401_dpi,
earlysuspend);
#ifdef ESD_OPERATION
if (lcd->lcd_connected)
enable_irq(GPIO_TO_IRQ(lcd->esd_port));
#endif
if (prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP,
"codina_lcd_dpi", 100)) {
pr_info("pcrm_qos_add APE failed\n");
}
ws2401_dpi_mcde_panel_resume(lcd->mdd);
if (lcd->pd->bl_ctrl)
lcd->bd_enable = TRUE;
#ifdef ESD_OPERATION
if (lcd->lcd_connected) {
set_irq_type(GPIO_TO_IRQ(lcd->esd_port), IRQF_TRIGGER_RISING);
lcd->esd_enable = 1;
pr_info("%s change lcd->esd_enable :%d", __func__,
lcd->esd_enable);
} else
pr_info("%s lcd_connected : %d", lcd->lcd_connected);
#endif
}
static int clk_prcmu_opp_prepare(struct clk_hw *hw)
{
int err;
struct clk_prcmu *clk = to_clk_prcmu(hw);
if (!clk->opp_requested) {
err = prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP,
(char *)__clk_get_name(hw->clk),
100);
if (err) {
pr_err("clk_prcmu: %s fail req APE OPP for %s.\n",
__func__, __clk_get_name(hw->clk));
return err;
}
clk->opp_requested = 1;
}
err = prcmu_request_clock(clk->cg_sel, true);
if (err) {
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP,
(char *)__clk_get_name(hw->clk));
clk->opp_requested = 0;
return err;
}
clk->is_prepared = 1;
return 0;
}
static int ws2401_update(struct mcde_display_device *ddev,
bool tripple_buffer)
{
struct ws2401_lcd *lcd = dev_get_drvdata(&ddev->dev);
int ret = 0;
dev_dbg(&ddev->dev, "%s\n", __func__);
return 0;
/* Add 100% APE OPP request */
if (!lcd->opp_is_requested) {
if (prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, "ws2401", 100)) {
dev_err(&ddev->dev, "APE OPP 100 failed\n");
return -EFAULT;
}
lcd->opp_is_requested = true;
}
/* For a display running DSI Command Mode (i.e. with an internal framebuffer),
the OPP request can be released once the frame has been output to the display.
When running DSI Video Mode, the OPP request must remain
in place contnuously whilst the panel is on. */
if (ddev->port->mode == MCDE_PORTMODE_CMD) {
cancel_delayed_work(&lcd->opp_timeout_work);
schedule_delayed_work(&lcd->opp_timeout_work, msecs_to_jiffies(OPP_TIMER));
}
if (ddev->power_mode != MCDE_DISPLAY_PM_ON && ddev->set_power_mode) {
ret = ddev->set_power_mode(ddev, MCDE_DISPLAY_PM_ON);
if (ret < 0) {
dev_warn(&ddev->dev,
"%s:Failed to set power mode to on\n",
__func__);
return ret;
}
}
/* TODO: Calculate & set update rect */
ret = mcde_chnl_update(ddev->chnl_state, &ddev->update_area,
tripple_buffer);
if (ret < 0) {
dev_warn(&ddev->dev, "%s:Failed to update channel\n", __func__);
return ret;
}
if (ddev->first_update && ddev->on_first_update)
ddev->on_first_update(ddev);
dev_dbg(&ddev->dev, "Overlay updated, chnl=%d\n", ddev->chnl_id);
return 0;
}
static void s6d27a1_request_opp(struct s6d27a1_dpi *lcd)
{
if ((!lcd->opp_is_requested) && (lcd->pd->min_ddr_opp > 0)) {
if (prcmu_qos_add_requirement(PRCMU_QOS_DDR_OPP,
LCD_DRIVER_NAME_S6D27A1,
lcd->pd->min_ddr_opp)) {
dev_err(lcd->dev, "add DDR OPP %d failed\n",
lcd->pd->min_ddr_opp);
}
dev_dbg(lcd->dev, "DDR OPP requested at %d%%\n",lcd->pd->min_ddr_opp);
lcd->opp_is_requested = true;
}
}
static __init int ux500_suspend_init(void)
{
suspend_wakeups = PRCMU_WAKEUP(ABB) | PRCMU_WAKEUP(RTC);
running_wakeups = (PRCMU_WAKEUP(ARM) | PRCMU_WAKEUP(RTC) |
PRCMU_WAKEUP(ABB));
ux500_suspend_dbg_init();
prcmu_qos_add_requirement(PRCMU_QOS_ARM_KHZ,
"suspend",
PRCMU_QOS_DEFAULT_VALUE);
suspend_set_ops(&ux500_suspend_ops);
return 0;
}
static int __init performance_register(void)
{
int ret_mmc;
int ret_wlan;
int ret;
#ifdef CONFIG_MMC_BLOCK
ret_mmc = prcmu_qos_add_requirement(PRCMU_QOS_ARM_KHZ, "mmc",
PRCMU_QOS_DEFAULT_VALUE);
if (!ret_mmc)
ret_mmc = prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, "mmc",
PRCMU_QOS_DEFAULT_VALUE);
if (!ret_mmc)
ret_mmc = prcmu_qos_add_requirement(PRCMU_QOS_DDR_OPP, "mmc",
PRCMU_QOS_DEFAULT_VALUE);
if (ret_mmc) {
pr_err("%s: Failed to add PRCMU QoS req for mmc\n", __func__);
prcmu_qos_remove_requirement(PRCMU_QOS_ARM_KHZ, "mmc");
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "mmc");
prcmu_qos_remove_requirement(PRCMU_QOS_DDR_OPP, "mmc");
} else {
INIT_DELAYED_WORK_DEFERRABLE(&work_mmc, mmc_load);
schedule_delayed_work(&work_mmc,
msecs_to_jiffies(perf_mmc_probe_delay));
}
#endif
ret_wlan = prcmu_qos_add_requirement(PRCMU_QOS_ARM_KHZ, "wlan",
PRCMU_QOS_DEFAULT_VALUE);
if (!ret_wlan)
ret_wlan = prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, "wlan",
PRCMU_QOS_DEFAULT_VALUE);
if (!ret_wlan)
ret_wlan = prcmu_qos_add_requirement(PRCMU_QOS_DDR_OPP, "wlan",
PRCMU_QOS_DEFAULT_VALUE);
if (ret_wlan) {
pr_err("%s: Failed to add PRCMU QoS req for wlan\n", __func__);
prcmu_qos_remove_requirement(PRCMU_QOS_ARM_KHZ, "wlan");
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "wlan");
prcmu_qos_remove_requirement(PRCMU_QOS_DDR_OPP, "wlan");
} else {
INIT_DELAYED_WORK_DEFERRABLE(&work_wlan_workaround, wlan_load);
schedule_delayed_work_on(0, &work_wlan_workaround,
msecs_to_jiffies(wlan_probe_delay));
}
performance_kobject = kobject_create_and_add("performance", kernel_kobj);
if (!performance_kobject) {
pr_err("[Performance] Failed to create kobject interface\n");
}
ret = sysfs_create_group(performance_kobject, &performance_interface_group);
if (ret) {
kobject_put(performance_kobject);
}
/* Only return one error code */
return ret_mmc ? ret_mmc : (ret_wlan ? ret_wlan : ret);
}
static int request_ape_opp100(bool enable)
{
static unsigned int requests;
if (enable) {
if (0 == requests++) {
return prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP,
"clock", 100);
}
} else if (1 == requests--) {
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "clock");
}
return 0;
}
/* Rationale behind the values for:
* MALI_HIGH_LEVEL_UTILIZATION_LIMIT and MALI_LOW_LEVEL_UTILIZATION_LIMIT
* When operating at half clock frequency a faster clock is requested when
* reaching 75% utilization. When operating at full clock frequency a slower
* clock is requested when reaching 25% utilization. There is a margin of 25%
* at the high range of the slow clock to avoid complete saturation of the
* hardware and there is some overlap to avoid an oscillating situation where
* the clock goes back and forth from high to low.
*
* Utilization on full speed clock
* 0 64 128 192 255
* |---------------|---------------|---------------|---------------|
* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
* | ^
* V |
* XXXXXXXXXXXXXXXXXXXXXXXXX
* 0 64 128 192 255
* |-------|-------|-------|-------|
* Utilization on half speed clock
*/
void mali_utilization_function(struct work_struct *ptr)
{
/*By default, platform start with 50% APE OPP and 25% DDR OPP*/
static u32 has_requested_low = 1;
if (last_utilization > MALI_LOW_TO_HIGH_LEVEL_UTILIZATION_LIMIT) {
if (has_requested_low) {
MALI_DEBUG_PRINT(5, ("MALI GPU utilization: %u SIGNAL_HIGH\n", last_utilization));
/*Request 100% APE_OPP.*/
if (prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, "mali", 100)) {
MALI_DEBUG_PRINT(2, ("MALI 100% APE_OPP failed\n"));
return;
}
/*
* Since the utilization values will be reported higher
* if DDR_OPP is lowered, we also request 100% DDR_OPP.
*/
if (prcmu_qos_add_requirement(PRCMU_QOS_DDR_OPP, "mali", 100)) {
MALI_DEBUG_PRINT(2, ("MALI 100% DDR_OPP failed\n"));
return;
}
has_requested_low = 0;
}
} else {
if (last_utilization < MALI_HIGH_TO_LOW_LEVEL_UTILIZATION_LIMIT) {
if (!has_requested_low) {
/*Remove APE_OPP and DDR_OPP requests*/
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP, "mali");
prcmu_qos_remove_requirement(PRCMU_QOS_DDR_OPP, "mali");
MALI_DEBUG_PRINT(5, ("MALI GPU utilization: %u SIGNAL_LOW\n", last_utilization));
has_requested_low = 1;
}
}
}
MALI_DEBUG_PRINT(5, ("MALI GPU utilization: %u\n", last_utilization));
}
static int __init pm_init(void)
{
int error = pm_start_workqueue();
if (error)
return error;
hibernate_image_size_init();
hibernate_reserved_size_init();
power_kobj = kobject_create_and_add("power", NULL);
if (!power_kobj)
return -ENOMEM;
#ifdef CONFIG_DVFS_LIMIT
cpufreq_register_notifier(&dvfs_cpufreq_notifier_block,
CPUFREQ_POLICY_NOTIFIER);
prcmu_qos_add_requirement(PRCMU_QOS_ARM_KHZ, "power",
PRCMU_QOS_DEFAULT_VALUE);
#endif
return sysfs_create_group(power_kobj, &attr_group);
}
int mmio_cam_initboard(
struct mmio_info *info)
{
int err = 0;
dev_dbg(info->dev, "%s\n", __func__);
err = prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP,
(char *)info->misc_dev.name,
MAX_PRCMU_QOS_APP);
if (err) {
dev_err(info->dev, "Error adding PRCMU QoS requirement %d\n",
err);
goto out;
}
/* Initialize platform specific data */
err = info->pdata->platform_init(info->pdata);
if (err) {
dev_err(info->dev,
"Failed to execute platform init: %d\n",
err);
goto out;
}
/* Enable I2C */
err = info->pdata->config_i2c_pins(info->pdata, MMIO_ACTIVATE_I2C);
if (err) {
dev_err(info->dev,
"Failed to enable I2C: %d\n",
err);
goto out;
}
out:
return err;
}
/**
* musb_phy_en : register USB callback handlers for ab8500
* @mode: value for mode.
*
* This function is used to register USB callback handlers for ab8500.
*/
int musb_phy_en(u8 mode)
{
int ret = -1;
u8 save_val;
if (!device)
return -EINVAL;
ab8500_rev = abx500_get_chip_id(device);
if (ab8500_rev < 0) {
dev_err(device, "get chip id failed\n");
return ab8500_rev;
}
if (!((ab8500_rev == AB8500_REV_20)
|| (ab8500_rev == AB8500_REV_30)
|| (ab8500_rev == AB8500_REV_33))) {
dev_err(device, "Unknown AB type!\n");
return -ENODEV;
}
musb_vape_supply = regulator_get(device, "v-ape");
if (IS_ERR(musb_vape_supply)) {
dev_err(device, "Could not get %s:v-ape supply\n",
dev_name(device));
ret = PTR_ERR(musb_vape_supply);
return ret;
}
musb_vintcore_supply = regulator_get(device, "v-intcore");
if (IS_ERR(musb_vintcore_supply)) {
dev_err(device, "Could not get %s:v-intcore12 supply\n",
dev_name(device));
ret = PTR_ERR(musb_vintcore_supply);
return ret;
}
musb_smps2_supply = regulator_get(device, "musb_1v8");
if (IS_ERR(musb_smps2_supply)) {
dev_err(device, "Could not get %s:v-intcore12 supply\n",
dev_name(device));
ret = PTR_ERR(musb_smps2_supply);
return ret;
}
sysclock = clk_get(device, "sysclk");
if (IS_ERR(sysclock)) {
ret = PTR_ERR(sysclock);
sysclock = NULL;
return ret;
}
/*
* When usb cable is not connected,set Qos for VAPE to 50.
* This is done to run APE at low OPP when usb is not used.
*/
prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, DEVICE_NAME, 50);
if (mode == MUSB_HOST || mode == MUSB_OTG) {
ret = request_threaded_irq(irq_host_remove, NULL,
usb_host_remove_handler,
IRQF_NO_SUSPEND | IRQF_SHARED,
"usb-host-remove", device);
if (ret < 0) {
printk(KERN_ERR "failed to set the callback"
" handler for usb host"
" removal\n");
return ret;
}
}
if ((mode == MUSB_PERIPHERAL) || (mode == MUSB_OTG)) {
ret = request_threaded_irq(irq_device_remove, NULL,
usb_device_remove_handler,
IRQF_NO_SUSPEND | IRQF_SHARED,
"usb-device-remove", device);
if (ret < 0) {
printk(KERN_ERR "failed to set the callback"
" handler for usb host"
" removal\n");
return ret;
}
}
/* create a thread for work */
usb_cable_wq = create_singlethread_workqueue(
"usb_cable_wq");
if (usb_cable_wq == NULL)
return -ENOMEM;
ret = request_threaded_irq(irq_device_insert, NULL,
usb_device_insert_handler,
IRQF_NO_SUSPEND | IRQF_SHARED,
"usb-device-insert", device);
if (ret < 0) {
printk(KERN_ERR "failed to set the callback"
" handler for usb device"
" insert\n");
return ret;
}
INIT_WORK(&usb_host_remove, usb_host_remove_work);
INIT_WORK(&usb_device_remove, usb_device_remove_work);
INIT_WORK(&usb_lnk_status_update,
usb_link_status_update_work);
if (ab8500_rev == AB8500_REV_20)
INIT_WORK(&usb_dedicated_charger_remove,
usb_dedicated_charger_remove_work);
/* Required for Host, Device and OTG mode */
init_completion(&usb_link_status_update);
ret = request_threaded_irq(irq_link_status_update,
NULL, usb_link_status_update_handler,
IRQF_NO_SUSPEND | IRQF_SHARED,
"usb-link-status-update", device);
if (ret < 0) {
printk(KERN_ERR "failed to set the callback"
" handler for usb charge"
" detect done\n");
return ret;
}
#ifdef CONFIG_USB_OTG_20
ret = request_threaded_irq(irq_adp_plug, NULL,
irq_adp_plug_handler,
IRQF_SHARED, "usb-adp-plug", device);
if (ret < 0) {
printk(KERN_ERR "failed to set the callback"
" handler for usb adp"
" plug\n");
return ret;
}
ret = request_threaded_irq(irq_adp_unplug, NULL,
irq_adp_unplug_handler,
IRQF_SHARED, "usb-adp-unplug", device);
if (ret < 0) {
printk(KERN_ERR "failed to set the callback"
" handler for usb adp"
" unplug\n");
return ret;
}
#endif
/* Write Phy tuning values */
if ((ab8500_rev == AB8500_REV_30)
|| (ab8500_rev == AB8500_REV_33)) {
/* Enable the PBT/Bank 0x12 access
* Save old bank settings for
* later restore
*/
ret = abx500_get_register_interruptible(device,
AB8500_DEVELOPMENT,
AB8500_BANK12_ACCESS,
&save_val);
ret = abx500_set_register_interruptible(device,
AB8500_DEVELOPMENT,
AB8500_BANK12_ACCESS,
0x01);
if (ret < 0)
printk(KERN_ERR "Failed to enable bank12"
" access ret=%d\n", ret);
ret = abx500_set_register_interruptible(device,
AB8500_DEBUG,
AB8500_USB_PHY_TUNE1,
0xC8);
if (ret < 0)
printk(KERN_ERR "Failed to set PHY_TUNE1"
" register ret=%d\n", ret);
ret = abx500_set_register_interruptible(device,
AB8500_DEBUG,
AB8500_USB_PHY_TUNE2,
0x00);
if (ret < 0)
printk(KERN_ERR "Failed to set PHY_TUNE2"
" register ret=%d\n", ret);
ret = abx500_set_register_interruptible(device,
AB8500_DEBUG,
AB8500_USB_PHY_TUNE3,
0x78);
if (ret < 0)
printk(KERN_ERR "Failed to set PHY_TUNE3"
" regester ret=%d\n", ret);
/* Switch back to previous mode/disable Bank 0x12 access */
ret = abx500_set_register_interruptible(device,
AB8500_DEVELOPMENT,
AB8500_BANK12_ACCESS,
save_val);
if (ret < 0)
printk(KERN_ERR "Failed to switch bank12"
" access ret=%d\n", ret);
}
return 0;
}
static int ux500_msp_drv_probe(struct platform_device *pdev)
{
struct ux500_msp_i2s_drvdata *drvdata;
int ret = 0;
dev_dbg(&pdev->dev, "%s: Enter (pdev->name = %s).\n", __func__,
pdev->name);
drvdata = devm_kzalloc(&pdev->dev,
sizeof(struct ux500_msp_i2s_drvdata),
GFP_KERNEL);
if (!drvdata)
return -ENOMEM;
drvdata->fmt = 0;
drvdata->slots = 1;
drvdata->tx_mask = 0x01;
drvdata->rx_mask = 0x01;
drvdata->slot_width = 16;
drvdata->master_clk = MSP_INPUT_FREQ_APB;
drvdata->reg_vape = devm_regulator_get(&pdev->dev, "v-ape");
if (IS_ERR(drvdata->reg_vape)) {
ret = (int)PTR_ERR(drvdata->reg_vape);
dev_err(&pdev->dev,
"%s: ERROR: Failed to get Vape supply (%d)!\n",
__func__, ret);
return ret;
}
prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, (char *)pdev->name, 50);
drvdata->pclk = clk_get(&pdev->dev, "apb_pclk");
if (IS_ERR(drvdata->pclk)) {
ret = (int)PTR_ERR(drvdata->pclk);
dev_err(&pdev->dev, "%s: ERROR: clk_get of pclk failed (%d)!\n",
__func__, ret);
goto err_pclk;
}
drvdata->clk = clk_get(&pdev->dev, NULL);
if (IS_ERR(drvdata->clk)) {
ret = (int)PTR_ERR(drvdata->clk);
dev_err(&pdev->dev, "%s: ERROR: clk_get failed (%d)!\n",
__func__, ret);
goto err_clk;
}
ret = ux500_msp_i2s_init_msp(pdev, &drvdata->msp,
pdev->dev.platform_data);
if (!drvdata->msp) {
dev_err(&pdev->dev,
"%s: ERROR: Failed to init MSP-struct (%d)!",
__func__, ret);
goto err_init_msp;
}
dev_set_drvdata(&pdev->dev, drvdata);
ret = snd_soc_register_component(&pdev->dev, &ux500_msp_component,
&ux500_msp_dai_drv[drvdata->msp->id], 1);
if (ret < 0) {
dev_err(&pdev->dev, "Error: %s: Failed to register MSP%d!\n",
__func__, drvdata->msp->id);
goto err_init_msp;
}
ret = ux500_pcm_register_platform(pdev);
if (ret < 0) {
dev_err(&pdev->dev,
"Error: %s: Failed to register PCM platform device!\n",
__func__);
goto err_reg_plat;
}
return 0;
err_reg_plat:
snd_soc_unregister_component(&pdev->dev);
err_init_msp:
clk_put(drvdata->clk);
err_clk:
clk_put(drvdata->pclk);
err_pclk:
devm_regulator_put(drvdata->reg_vape);
return ret;
}
_mali_osk_errcode_t mali_platform_init()
{
int ret;
is_running = false;
mali_last_utilization = 0;
if (!is_initialized) {
prcmu_write(PRCMU_PLLSOC0, PRCMU_PLLSOC0_INIT);
prcmu_write(PRCMU_SGACLK, PRCMU_SGACLK_INIT);
mali_boost_init();
mali_utilization_workqueue = create_singlethread_workqueue("mali_utilization_workqueue");
if (NULL == mali_utilization_workqueue) {
MALI_DEBUG_PRINT(2, ("%s: Failed to setup workqueue %s\n", __func__, "mali_utilization_workqueue"));
goto error;
}
INIT_WORK(&mali_utilization_work, mali_utilization_function);
//TODO register a notifier block with prcmu opp update func to monitor ape opp
INIT_DELAYED_WORK(&mali_boost_delayedwork, mali_boost_work);
regulator = regulator_get(NULL, "v-mali");
if (IS_ERR(regulator)) {
MALI_DEBUG_PRINT(2, ("%s: Failed to get regulator %s\n", __func__, "v-mali"));
goto error;
}
clk_sga = clk_get_sys("mali", NULL);
if (IS_ERR(clk_sga)) {
regulator_put(regulator);
MALI_DEBUG_PRINT(2, ("%s: Failed to get clock %s\n", __func__, "mali"));
goto error;
}
#if CONFIG_HAS_WAKELOCK
wake_lock_init(&wakelock, WAKE_LOCK_SUSPEND, "mali_wakelock");
#endif
mali_kobject = kobject_create_and_add("mali", kernel_kobj);
if (!mali_kobject) {
pr_err("[Mali] Failed to create kobject interface\n");
}
ret = sysfs_create_group(mali_kobject, &mali_interface_group);
if (ret) {
kobject_put(mali_kobject);
}
prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP, "mali", PRCMU_QOS_DEFAULT_VALUE);
prcmu_qos_add_requirement(PRCMU_QOS_DDR_OPP, "mali", PRCMU_QOS_DEFAULT_VALUE);
pr_info("[Mali] DB8500 GPU OC Initialized (%s)\n", MALI_UX500_VERSION);
is_initialized = true;
}
MALI_SUCCESS;
error:
MALI_DEBUG_PRINT(1, ("SGA initialization failed.\n"));
MALI_ERROR(_MALI_OSK_ERR_FAULT);
}
static int __devinit ws2401_dpi_mcde_panel_probe(
struct mcde_display_device *ddev)
{
int ret = 0;
struct ws2401_dpi *lcd = NULL;
struct backlight_device *bd = NULL;
struct ssg_dpi_display_platform_data *pdata = ddev->dev.platform_data;
dev_dbg(&ddev->dev, "Invoked %s\n", __func__);
if (pdata == NULL) {
dev_err(&ddev->dev, "%s:Platform data missing\n", __func__);
ret = -EINVAL;
goto no_pdata;
}
if (ddev->port->type != MCDE_PORTTYPE_DPI) {
dev_err(&ddev->dev,
"%s:Invalid port type %d\n",
__func__, ddev->port->type);
ret = -EINVAL;
goto invalid_port_type;
}
ddev->prepare_for_update = NULL;
ddev->try_video_mode = try_video_mode;
ddev->set_video_mode = set_video_mode;
lcd = kzalloc(sizeof(struct ws2401_dpi), GFP_KERNEL);
if (!lcd)
return -ENOMEM;
mutex_init(&lcd->lock);
dev_set_drvdata(&ddev->dev, lcd);
lcd->mdd = ddev;
lcd->dev = &ddev->dev;
lcd->pd = pdata;
#ifdef CONFIG_LCD_CLASS_DEVICE
lcd->ld = lcd_device_register("panel", &ddev->dev,
lcd, &ws2401_dpi_lcd_ops);
if (IS_ERR(lcd->ld)) {
ret = PTR_ERR(lcd->ld);
goto out_free_lcd;
} else {
ret = device_create_file(&(lcd->ld->dev), &dev_attr_panel_type);
if (ret < 0)
dev_err(&(lcd->ld->dev),
"failed to add panel_type sysfs entries\n");
ret = device_create_file(&(lcd->ld->dev), &dev_attr_panel_id);
if (ret < 0)
dev_err(&(lcd->ld->dev),
"failed to add panel_id sysfs entries\n");
}
#endif
mutex_init(&lcd->lock);
if (pdata->bl_ctrl) {
bd = backlight_device_register("pwm-backlight",
&ddev->dev,
lcd,
&ws2401_dpi_backlight_ops,
NULL);
if (IS_ERR(bd)) {
ret = PTR_ERR(bd);
goto out_backlight_unregister;
}
lcd->bd = bd;
lcd->bd_enable = TRUE;
lcd->bd->props.max_brightness = MAX_BRIGHTNESS;
lcd->bd->props.brightness = DEFAULT_BRIGHTNESS;
}
ret = device_create_file(&(ddev->dev), &dev_attr_lcd_power);
if (ret < 0)
dev_err(&(ddev->dev),
"failed to add lcd_power sysfs entries\n");
lcd->spi_drv.driver.name = "pri_lcd_spi";
lcd->spi_drv.driver.bus = &spi_bus_type;
lcd->spi_drv.driver.owner = THIS_MODULE;
lcd->spi_drv.probe = ws2401_dpi_spi_probe;
ret = spi_register_driver(&lcd->spi_drv);
if (ret < 0) {
dev_err(&(ddev->dev), "Failed to register SPI driver");
goto out_backlight_unregister;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
lcd->earlysuspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1;
lcd->earlysuspend.suspend = ws2401_dpi_mcde_panel_early_suspend;
lcd->earlysuspend.resume = ws2401_dpi_mcde_panel_late_resume;
register_early_suspend(&lcd->earlysuspend);
#endif
ws2401_update_brightness(lcd);
if (prcmu_qos_add_requirement(PRCMU_QOS_APE_OPP,
"codina_lcd_dpi", 100)) {
pr_info("pcrm_qos_add APE failed\n");
}
dev_dbg(&ddev->dev, "DPI display probed\n");
goto out;
out_backlight_unregister:
if (pdata->bl_ctrl)
backlight_device_unregister(bd);
out_free_lcd:
mutex_destroy(&lcd->lock);
kfree(lcd);
invalid_port_type:
no_pdata:
out:
return ret;
}
