static void cpufreq_allstats_free(void)
{
int cpu;
struct all_cpufreq_stats *all_stat;
sysfs_remove_file(cpufreq_global_kobject,
&_attr_all_time_in_state.attr);
for_each_possible_cpu(cpu) {
all_stat = per_cpu(all_cpufreq_stats, cpu);
if (!all_stat)
continue;
kfree(all_stat->time_in_state);
kfree(all_stat);
per_cpu(all_cpufreq_stats, cpu) = NULL;
}
if (all_freq_table) {
kfree(all_freq_table->freq_table);
kfree(all_freq_table);
all_freq_table = NULL;
}
}
static void synaptics_rmi4_prox_remove(struct synaptics_rmi4_data *rmi4_data)
{
unsigned char attr_count;
if (!prox)
goto exit;
for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) {
sysfs_remove_file(&rmi4_data->input_dev->dev.kobj,
&attrs[attr_count].attr);
}
input_unregister_device(prox->prox_dev);
kfree(prox->finger_data);
kfree(prox);
prox = NULL;
exit:
complete(&prox_remove_complete);
return;
}
static void cpufreq_allstats_free(void)
{
int i;
struct all_cpufreq_stats *all_stat;
sysfs_remove_file(cpufreq_global_kobject,
&_attr_all_time_in_state.attr);
for (i = 0; i < total_cpus; i++) {
all_stat = per_cpu(all_cpufreq_stats, i);
if (!all_stat)
continue;
kfree(all_stat->time_in_state);
kfree(all_stat);
per_cpu(all_cpufreq_stats, i) = NULL;
}
if (all_freq_table) {
kfree(all_freq_table->freq_table);
kfree(all_freq_table);
all_freq_table = NULL;
}
}
static int __init enhance_init(void)
{
int retval;
int attr_count = 0;
enhance__kobj = kobject_create_and_add("lcd_enhance", kernel_kobj);
if (!enhance__kobj)
return -ENOMEM;
/* Create the files associated with this kobject */
for (attr_count = 0; attr_count < ARRAY_SIZE(attrs); attr_count++) {
if(!zte_enhance_val.en_colortmp && (attr_count == 1))
continue;
retval = sysfs_create_file(enhance__kobj, &attrs[attr_count].attr);
if (retval < 0) {
pr_err("%s: Failed to create sysfs attributes\n", __func__);
goto err_sys;
}
}
pr_info("lcd: %s Done.\n",__func__);
return retval;
err_sys:
for (attr_count--; attr_count >= 0; attr_count--) {
sysfs_remove_file(enhance__kobj, &attrs[attr_count].attr);
}
kobject_put(enhance__kobj);
pr_info("lcd: %s init ERR.\n",__func__);
return retval;
}
static int __init edac_init_mce_inject(void)
{
struct sysdev_class *edac_class = NULL;
int i, err = 0;
edac_class = edac_get_sysfs_class();
if (!edac_class)
return -EINVAL;
mce_kobj = kobject_create_and_add("mce", &edac_class->kset.kobj);
if (!mce_kobj) {
printk(KERN_ERR "Error creating a mce kset.\n");
err = -ENOMEM;
goto err_mce_kobj;
}
for (i = 0; i < ARRAY_SIZE(sysfs_attrs); i++) {
err = sysfs_create_file(mce_kobj, &sysfs_attrs[i]->attr);
if (err) {
printk(KERN_ERR "Error creating %s in sysfs.\n",
sysfs_attrs[i]->attr.name);
goto err_sysfs_create;
}
}
return 0;
err_sysfs_create:
while (--i >= 0)
sysfs_remove_file(mce_kobj, &sysfs_attrs[i]->attr);
kobject_del(mce_kobj);
err_mce_kobj:
edac_put_sysfs_class();
return err;
}
int sysfs_add_meshif(struct net_device *dev)
{
struct kobject *batif_kobject = &dev->dev.kobj;
struct bat_priv *bat_priv = netdev_priv(dev);
struct bat_attribute **bat_attr;
int err;
bat_priv->mesh_obj = kobject_create_and_add(SYSFS_IF_MESH_SUBDIR,
batif_kobject);
if (!bat_priv->mesh_obj) {
bat_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
SYSFS_IF_MESH_SUBDIR);
goto out;
}
for (bat_attr = mesh_attrs; *bat_attr; ++bat_attr) {
err = sysfs_create_file(bat_priv->mesh_obj,
&((*bat_attr)->attr));
if (err) {
bat_err(dev, "Can't add sysfs file: %s/%s/%s\n",
dev->name, SYSFS_IF_MESH_SUBDIR,
((*bat_attr)->attr).name);
goto rem_attr;
}
}
return 0;
rem_attr:
for (bat_attr = mesh_attrs; *bat_attr; ++bat_attr)
sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
kobject_put(bat_priv->mesh_obj);
bat_priv->mesh_obj = NULL;
out:
return -ENOMEM;
}
static int bu21150_remove(struct spi_device *client)
{
struct bu21150_data *ts = spi_get_drvdata(client);
int i;
mutex_destroy(&ts->mutex_wake);
if (ts->wake_up)
device_init_wakeup(&client->dev, 0);
for (i = 0; i < ARRAY_SIZE(bu21150_prop_attrs); i++)
sysfs_remove_file(ts->bu21150_obj,
&bu21150_prop_attrs[i].attr);
kobject_put(ts->bu21150_obj);
fb_unregister_client(&ts->fb_notif);
misc_deregister(&g_bu21150_misc_device);
bu21150_power_enable(ts, false);
bu21150_regulator_config(ts, false);
free_irq(client->irq, ts);
mutex_destroy(&ts->mutex_frame);
bu21150_pin_enable(ts, false);
kfree(ts);
return 0;
}
/*
* edac_device_delete_block(edac_dev,block);
*/
static void edac_device_delete_block(struct edac_device_ctl_info *edac_dev,
struct edac_device_block *block)
{
struct edac_dev_sysfs_block_attribute *sysfs_attrib;
int i;
/* if this block has 'attributes' then we need to iterate over the list
* and 'remove' the attributes on this block
*/
sysfs_attrib = block->block_attributes;
if (sysfs_attrib && block->nr_attribs) {
for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) {
/* remove each block_attrib file */
sysfs_remove_file(&block->kobj,
(struct attribute *) sysfs_attrib);
}
}
/* unregister this block's kobject, SEE:
* edac_device_ctrl_block_release() callback operation
*/
kobject_put(&block->kobj);
}
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;
#endif
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
struct backlight_device *bd = NULL;
#endif
int ret = 0;
int i;
msd.dstat.acl_on = false;
if (pdev->id == 0) {
msd.mipi_samsung_disp_pdata = pdev->dev.platform_data;
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
msd.mpd->lcd_no = get_disp_switch();
for (i = 0; i < LCD_LOTS; i++) {
msd.dstat.is_elvss_loaded[i] = false;
msd.dstat.is_smart_dim_loaded[i] = false;
}
#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);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_siop_enable.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_siop_enable.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_backlight.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_backlight.attr.name);
}
#if defined(CONFIG_RUNTIME_MIPI_CLK_CHANGE)
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_fps_change.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_fps_change.attr.name);
}
#endif
#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)
init_mdnie_class();
#endif
#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 void __devexit etb_sysfs_exit(void)
{
sysfs_remove_file(etb.kobj, &trigger_cntr_attr.attr);
kobject_put(etb.kobj);
}
static void qdss_sysfs_exit(void)
{
sysfs_remove_file(qdss.modulekobj, &max_clk_attr.attr);
}
static void met_emi_delete(void)
{
sysfs_remove_file(kobj_emi, &rwtype_attr.attr);
sysfs_remove_file(kobj_emi, &emi_clock_rate_attr.attr);
kobj_emi = NULL;
}
static void __exit lpm_mode_exit(void)
{
sysfs_remove_file(mot_lpm_kobj, (const struct attribute *) &lpm_mode);
kobject_del(mot_lpm_kobj);
}
static void iommu_group_remove_file(struct iommu_group *group,
struct iommu_group_attribute *attr)
{
sysfs_remove_file(&group->kobj, &attr->attr);
}
int mdss_dsi_panel_init(struct device_node *node,
struct mdss_dsi_ctrl_pdata *ctrl_pdata,
bool cmd_cfg_cont_splash)
{
int rc = 0;
static const char *panel_name;
bool cont_splash_enabled;
#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
int disp_esd_gpio;
#endif
#if defined(CONFIG_LCD_CLASS_DEVICE)
struct lcd_device *lcd_device;
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
struct backlight_device *bd = NULL;
#endif
#endif
#if defined(CONFIG_LCD_CLASS_DEVICE)
struct device_node *np = NULL;
struct platform_device *pdev = NULL;
np = of_parse_phandle(node,
"qcom,mdss-dsi-panel-controller", 0);
if (!np) {
pr_err("%s: Dsi controller node not initialized\n", __func__);
return -EPROBE_DEFER;
}
pdev = of_find_device_by_node(np);
#endif
#if defined(CONFIG_BACKLIGHT_IC_KTD253)
mutex_init(&bg_lock);
#endif
#if defined(CONFIG_FB_MSM8x26_MDSS_CHECK_LCD_CONNECTION)
printk("%s: LCD attached status: %d !\n",
__func__, get_samsung_lcd_attached());
#endif
#ifdef DDI_VIDEO_ENHANCE_TUNING
mutex_init(&msd.lock);
#endif
if (!node) {
pr_err("%s: no panel node\n", __func__);
return -ENODEV;
}
pr_debug("%s:%d\n", __func__, __LINE__);
panel_name = of_get_property(node, "qcom,mdss-dsi-panel-name", NULL);
if (!panel_name)
pr_info("%s:%d, Panel name not specified\n",
__func__, __LINE__);
else
pr_info("%s: Panel Name = %s\n", __func__, panel_name);
#if defined(CONFIG_BACKLIGHT_IC_KTD2801)
virt_mmss_gp0_base = ioremap(MMSS_GP0_BASE,MMSS_GP0_SIZE);
if(virt_mmss_gp0_base == NULL) {
pr_err("%s: I/O remap failed \n", __func__);
return 0;
}
#endif
rc = mdss_panel_parse_dt(node, ctrl_pdata);
if (rc) {
pr_err("%s:%d panel dt parse failed\n", __func__, __LINE__);
return rc;
}
#if defined(CONFIG_SEC_VICTOR3GDSDTV_PROJECT)
gpio_tlmm_config(GPIO_CFG(34, 0, GPIO_CFG_INPUT,GPIO_CFG_PULL_DOWN,GPIO_CFG_8MA),GPIO_CFG_ENABLE);
#else
gpio_tlmm_config(GPIO_CFG(24, 0, GPIO_CFG_INPUT,GPIO_CFG_PULL_DOWN,GPIO_CFG_8MA),GPIO_CFG_ENABLE);
gpio_set_value(24, 0);
#endif
cont_splash_enabled = of_property_read_bool(node,
"qcom,cont-splash-enabled");
if (!cont_splash_enabled) {
pr_info("%s:%d Continuous splash flag not found.\n",
__func__, __LINE__);
ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 0;
} else {
pr_info("%s:%d Continuous splash flag enabled.\n",
__func__, __LINE__);
ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 1;
}
#if defined(CONFIG_FB_MSM8x26_MDSS_CHECK_LCD_CONNECTION)
pr_err("CONFIG_LCD_CONNECTION_CHECK is set kky\n");
if (get_samsung_lcd_attached() == 0)
{
printk("%s: aaaLCD not connected.... Disabling Continous Splash!\n",__func__);
// ctrl_pdata->panel_data.panel_info.cont_splash_enabled = 0;
}
#endif
ctrl_pdata->on = mdss_dsi_panel_on;
ctrl_pdata->off = mdss_dsi_panel_off;
ctrl_pdata->panel_reset = mdss_dsi_himax_panel_reset;
ctrl_pdata->panel_data.set_backlight = mdss_dsi_panel_bl_ctrl;
#if defined(CONFIG_LCD_CLASS_DEVICE)
lcd_device = lcd_device_register("panel", &pdev->dev, NULL,
&mdss_himax_disp_props);
if (IS_ERR(lcd_device)) {
rc = PTR_ERR(lcd_device);
printk(KERN_ERR "lcd : failed to register device\n");
return rc;
}
sysfs_remove_file(&lcd_device->dev.kobj,&dev_attr_lcd_power.attr);
rc = sysfs_create_file(&lcd_device->dev.kobj,&dev_attr_lcd_power.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",dev_attr_lcd_power.attr.name);
}
rc = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_lcd_type.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",
dev_attr_lcd_type.attr.name);
}
rc= sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_siop_enable.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",
dev_attr_siop_enable.attr.name);
}
#if defined(CONFIG_BACKLIGHT_CLASS_DEVICE)
bd = backlight_device_register("panel", &lcd_device->dev,
NULL, NULL, NULL);
if (IS_ERR(bd)) {
rc = PTR_ERR(bd);
pr_info("backlight : failed to register device\n");
return rc;
}
rc= sysfs_create_file(&bd->dev.kobj,
&dev_attr_auto_brightness.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",
dev_attr_auto_brightness.attr.name);
}
#endif
#endif
#if defined(DDI_VIDEO_ENHANCE_TUNING)
rc = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_tuning.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",
dev_attr_tuning.attr.name);
}
#endif
#if defined(CONFIG_MDNIE_LITE_TUNING) || defined(CONFIG_MDNIE_VIDEO_ENHANCED)
pr_info("[%s] CONFIG_MDNIE_LITE_TUNING ok ! initclass called!\n",__func__);
init_mdnie_class();
#if defined(CONFIG_MDNIE_LITE_TUNING)
mdnie_lite_tuning_init(&msd);
#endif
#endif
#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
#ifdef ESD_DEBUG
rc = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_esd_check.attr);
if (rc) {
pr_info("sysfs create fail-%s\n",
dev_attr_esd_check.attr.name);
}
#endif
msd.msm_pdev = pdev;
disp_esd_gpio =of_get_named_gpio(node,"qcom,oled-esd-gpio", 0);
err_fg_gpio = gpio_to_irq(disp_esd_gpio);
rc = gpio_request(disp_esd_gpio, "err_fg");
if (rc) {
pr_err("request gpio GPIO_ESD failed, ret=%d\n",rc);
gpio_free(disp_esd_gpio);
return rc;
}
gpio_tlmm_config(GPIO_CFG(disp_esd_gpio, 0, GPIO_CFG_INPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA),GPIO_CFG_ENABLE);
rc = gpio_direction_input(disp_esd_gpio);
if (unlikely(rc < 0)) {
pr_err("%s: failed to set gpio %d as input (%d)\n",
__func__, disp_esd_gpio, rc);
}
#endif
return 0;
}
static int __devinit mipi_novatek_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;
is_lcd_on = LCD_STATUS_ON;
if (pdev->id == 0) {
msd.mipi_novatek_disp_pdata = pdev->dev.platform_data;
#ifdef CONFIG_SAMSUNG_CMC624
if (samsung_has_cmc624()) {
printk(KERN_DEBUG "Is_There_cmc624 : CMC624 is there!!!!");
samsung_cmc624_init();
} else {
printk(KERN_DEBUG "Is_There_cmc624 : CMC624 is not there!!!!");
}
#endif
return 0;
}
msm_fb_added_dev = msm_fb_add_device(pdev);
#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_novatek_disp_early_suspend;
msd.early_suspend.resume = mipi_novatek_disp_late_resume;
msd.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
register_early_suspend(&msd.early_suspend);
#endif
#if defined(CONFIG_LCD_CLASS_DEVICE)
lcd_device = lcd_device_register("panel", &pdev->dev, NULL,
&mipi_novatek_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_MACH_MELIUS)
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_siop_enable.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_siop_enable.attr.name);
}
#endif
#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
#ifdef CONFIG_SAMSUNG_CMC624
if (samsung_has_cmc624()) {
ret = cmc624_sysfs_init();
if (ret < 0)
pr_debug("CMC624 sysfs initialize FAILED\n");
}
else
#if defined(CONFIG_FB_MDP4_ENHANCE)
init_mdnie_class();
#endif
#endif
pr_debug("%s:Display probe completed\n", __func__);
return 0;
}
static int __devinit pch_phub_probe(struct pci_dev *pdev,
const struct pci_device_id *id)
{
int retval;
int ret;
ssize_t rom_size;
struct pch_phub_reg *chip;
chip = kzalloc(sizeof(struct pch_phub_reg), GFP_KERNEL);
if (chip == NULL)
return -ENOMEM;
ret = pci_enable_device(pdev);
if (ret) {
dev_err(&pdev->dev,
"%s : pci_enable_device FAILED(ret=%d)", __func__, ret);
goto err_pci_enable_dev;
}
dev_dbg(&pdev->dev, "%s : pci_enable_device returns %d\n", __func__,
ret);
ret = pci_request_regions(pdev, KBUILD_MODNAME);
if (ret) {
dev_err(&pdev->dev,
"%s : pci_request_regions FAILED(ret=%d)", __func__, ret);
goto err_req_regions;
}
dev_dbg(&pdev->dev, "%s : "
"pci_request_regions returns %d\n", __func__, ret);
chip->pch_phub_base_address = pci_iomap(pdev, 1, 0);
if (chip->pch_phub_base_address == 0) {
dev_err(&pdev->dev, "%s : pci_iomap FAILED", __func__);
ret = -ENOMEM;
goto err_pci_iomap;
}
dev_dbg(&pdev->dev, "%s : pci_iomap SUCCESS and value "
"in pch_phub_base_address variable is %p\n", __func__,
chip->pch_phub_base_address);
chip->pch_phub_extrom_base_address = pci_map_rom(pdev, &rom_size);
if (chip->pch_phub_extrom_base_address == 0) {
dev_err(&pdev->dev, "%s : pci_map_rom FAILED", __func__);
ret = -ENOMEM;
goto err_pci_map;
}
dev_dbg(&pdev->dev, "%s : "
"pci_map_rom SUCCESS and value in "
"pch_phub_extrom_base_address variable is %p\n", __func__,
chip->pch_phub_extrom_base_address);
if (id->driver_data == 1) {
retval = sysfs_create_file(&pdev->dev.kobj,
&dev_attr_pch_mac.attr);
if (retval)
goto err_sysfs_create;
retval = sysfs_create_bin_file(&pdev->dev.kobj, &pch_bin_attr);
if (retval)
goto exit_bin_attr;
pch_phub_read_modify_write_reg(chip,
(unsigned int)CLKCFG_REG_OFFSET,
CLKCFG_CAN_50MHZ,
CLKCFG_CANCLK_MASK);
/* quirk for CM-iTC board */
if (strstr(dmi_get_system_info(DMI_BOARD_NAME), "CM-iTC"))
pch_phub_read_modify_write_reg(chip,
(unsigned int)CLKCFG_REG_OFFSET,
CLKCFG_UART_48MHZ | CLKCFG_BAUDDIV |
CLKCFG_PLL2VCO | CLKCFG_UARTCLKSEL,
CLKCFG_UART_MASK);
/* set the prefech value */
iowrite32(0x000affaa, chip->pch_phub_base_address + 0x14);
/* set the interrupt delay value */
iowrite32(0x25, chip->pch_phub_base_address + 0x44);
} else if (id->driver_data == 2) {
retval = sysfs_create_bin_file(&pdev->dev.kobj, &pch_bin_attr);
if (retval)
goto err_sysfs_create;
/* set the prefech value
* Device2(USB OHCI #1/ USB EHCI #1/ USB Device):a
* Device4(SDIO #0,1,2):f
* Device6(SATA 2):f
* Device8(USB OHCI #0/ USB EHCI #0):a
*/
iowrite32(0x000affa0, chip->pch_phub_base_address + 0x14);
}
pci_set_drvdata(pdev, chip);
return 0;
exit_bin_attr:
sysfs_remove_file(&pdev->dev.kobj, &dev_attr_pch_mac.attr);
err_sysfs_create:
pci_unmap_rom(pdev, chip->pch_phub_extrom_base_address);
err_pci_map:
pci_iounmap(pdev, chip->pch_phub_base_address);
err_pci_iomap:
pci_release_regions(pdev);
err_req_regions:
pci_disable_device(pdev);
err_pci_enable_dev:
kfree(chip);
dev_err(&pdev->dev, "%s returns %d\n", __func__, ret);
return ret;
}
static void xen_sysfs_type_destroy(void)
{
sysfs_remove_file(hypervisor_kobj, &type_attr.attr);
}
static void taskmonitor_exit(void)
{
sysfs_remove_file(kernel_kobj, &(hellosysfs_kattr.attr));
pr_info("rmmod: removed module hellosysfs\n");
}
static int ge_counter_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct ge_counter_platform_data *pdata = dev_get_platdata(dev);
struct driver_data *data;
struct counter_data *dest;
unsigned int irq;
int i, ret;
if (!pdata) {
pdata = ge_counter_get_devtree_pdata(dev);
if (IS_ERR(pdata))
return PTR_ERR(pdata);
}
data = kzalloc(sizeof(struct driver_data) + sizeof(struct counter_data)
* pdata->num_counter, GFP_KERNEL);
if (!data)
return -ENOMEM;
data->dir = kobject_create_and_add("counter", &pdev->dev.kobj);
if (!data->dir) {
dev_err(&pdev->dev, "Cannot create sysfs counter dir 'counter'\n");
kfree(data);
return -EIO;
}
data->num_counter = pdata->num_counter;
for (i = 0; i < pdata->num_counter; i++) {
struct ge_counter *src = &pdata->counter[i];
dest = &data->vdata[i];
if (!src->name) {
dev_err(&pdev->dev, "Counter name must be set\n");
ret = -EINVAL;
goto err;
}
if (!src->gpio || gpio_request(src->gpio, src->name)) {
dev_err(&pdev->dev, "Invalid counter GPIO %d\n", src->gpio);
ret = -EINVAL;
goto err;
}
gpio_direction_input(src->gpio);
irq = gpio_to_irq(src->gpio);
enable_irq_wake(irq);
ret = request_any_context_irq(irq, counter_event, src->irq_type,
"ge_counter", dest);
if (ret < 0) {
dev_err(&pdev->dev, "Cannot request IRQ %u for GPIO %u", irq, src->gpio);
ret = -EINVAL;
goto err_gpio;
}
dest->subdir = kobject_create_and_add(src->name, data->dir);
if (!dest->subdir) {
dev_err(&pdev->dev, "Cannot create sysfs counter dir '%s'\n",
src->name);
ret = -EIO;
goto err_irq;
}
spin_lock_init(&dest->lock);
dest->gpio = src->gpio;
dest->interval = msecs_to_jiffies(src->interval);
dest->counter = 0UL;
dest->start_jiffies = jiffies;
dest->start_count = 0UL;
dest->reset_on_read = src->reset_on_read;
dest->use_timer = false;
dest->interval_count_valid = false;
dest->counter_attr.show = counter_show;
dest->counter_attr.store = counter_store;
sysfs_attr_init(&dest->counter_attr.attr);
dest->counter_attr.attr.name = "counter";
dest->counter_attr.attr.mode = S_IRUGO | S_IWUSR;
ret = sysfs_create_file(dest->subdir, &dest->counter_attr.attr);
if (ret)
goto err_dir;
dest->elapsed_attr.show = elapsed_show;
dest->elapsed_attr.store = elapsed_store;
sysfs_attr_init(&dest->elapsed_attr.attr);
dest->elapsed_attr.attr.name = "elapsed";
dest->elapsed_attr.attr.mode = S_IRUGO | S_IWUSR;
ret = sysfs_create_file(dest->subdir, &dest->elapsed_attr.attr);
if (ret)
goto err_file1;
dest->state_attr.show = state_show;
sysfs_attr_init(&dest->state_attr.attr);
dest->state_attr.attr.name = "state";
dest->state_attr.attr.mode = S_IRUGO;
ret = sysfs_create_file(dest->subdir, &dest->state_attr.attr);
if (ret)
goto err_file2;
dest->reset_on_read_attr.show = reset_on_read_show;
dest->reset_on_read_attr.store = reset_on_read_store;
sysfs_attr_init(&dest->reset_on_read_attr.attr);
dest->reset_on_read_attr.attr.name = "reset_on_read";
dest->reset_on_read_attr.attr.mode = S_IRUGO | S_IWUSR;
ret = sysfs_create_file(dest->subdir, &dest->reset_on_read_attr.attr);
if (ret)
goto err_file3;
if (src->interval) {
dest->interval_attr.show = interval_show;
dest->interval_attr.store = interval_store;
sysfs_attr_init(&dest->interval_attr.attr);
dest->interval_attr.attr.name = "interval";
dest->interval_attr.attr.mode = S_IRUGO | S_IWUSR;
ret = sysfs_create_file(dest->subdir, &dest->interval_attr.attr);
if (ret)
goto err_file4;
dest->interval_count_attr.show = interval_count_show;
sysfs_attr_init(&dest->interval_count_attr.attr);
dest->interval_count_attr.attr.name = "interval_count";
dest->interval_count_attr.attr.mode = S_IRUGO;
ret = sysfs_create_file(dest->subdir, &dest->interval_count_attr.attr);
if (ret)
goto err_file5;
dest->use_timer = true;
init_timer(&dest->timer);
dest->timer.data = (unsigned long)dest;
dest->timer.function = timeout;
dest->jiffies = jiffies;
dest->timer.expires = jiffies + dest->interval;
add_timer(&dest->timer);
}
}
platform_set_drvdata(pdev, data);
return 0;
err_file5:
sysfs_remove_file(dest->subdir, &dest->interval_attr.attr);
err_file4:
sysfs_remove_file(dest->subdir, &dest->reset_on_read_attr.attr);
err_file3:
sysfs_remove_file(dest->subdir, &dest->state_attr.attr);
err_file2:
sysfs_remove_file(dest->subdir, &dest->elapsed_attr.attr);
err_file1:
sysfs_remove_file(dest->subdir, &dest->counter_attr.attr);
err_dir:
kobject_put(dest->subdir);
err_irq:
free_irq(irq, dest);
err_gpio:
gpio_free(dest->gpio);
err:
for (--i; i >= 0; i--)
delete_counter(&data->vdata[i]);
kobject_put(data->dir);
kfree(data);
return ret;
}
static void __devexit funnel_sysfs_exit(void)
{
sysfs_remove_file(drvdata->kobj, &dev_attr_priority.attr);
kobject_put(drvdata->kobj);
}
static int gsensor_sysfs_init(void)
{
int ret ;
android_gsensor_kobj = kobject_create_and_add("android_gsensor", NULL);
if (android_gsensor_kobj == NULL) {
printk(KERN_ERR
"akm8977 gsensor_sysfs_init:"\
"subsystem_register failed\n");
ret = -ENOMEM;
goto err;
}
ret = sysfs_create_file(android_gsensor_kobj, &dev_attr_vendor.attr);
if (ret) {
printk(KERN_ERR
"akm8977 gsensor_sysfs_init:"\
"sysfs_create_group failed\n");
goto err4;
}
#if SENSOR_6AXIS_STATE_TEST
ret = sysfs_create_file(android_gsensor_kobj, &dev_attr_speaker.attr);
if (ret) {
printk(KERN_ERR
"akm8977 gsensor_sysfs_init:"\
"sysfs_create_group failed\n");
goto err4;
}
memset(g_spkstat, 0, 8);
memcpy(g_spkstat, "off", 4);
#endif
#if SENSOR_6AXIS_ACCEL_MODE_TEST
akmd_acceleration_mode = AKMD_ACCELERATION_MODE_NORMAL;
ret = sysfs_create_file(android_gsensor_kobj, &dev_attr_acceleration_mode.attr);
if (ret) {
printk(KERN_ERR
"akm8977 gsensor_sysfs_init:"\
"sysfs_create_group failed\n");
goto err5;
}
#endif
return 0 ;
#if SENSOR_6AXIS_ACCEL_MODE_TEST
err5:
sysfs_remove_file(android_gsensor_kobj, &dev_attr_acceleration_mode.attr);
#endif
err4:
#if SENSOR_6AXIS_STATE_TEST
sysfs_remove_file(android_gsensor_kobj, &dev_attr_vendor.attr);
#endif
kobject_del(android_gsensor_kobj);
err:
return ret ;
}
static int __devinit mipi_samsung_disp_probe(struct platform_device *pdev)
{
int ret, rc;
struct platform_device *msm_fb_added_dev;
struct lcd_device *lcd_device;
struct backlight_device *bd = NULL;
printk(KERN_INFO "[lcd] mipi_samsung_disp_probe start\n");
if (pdev->id == 0) {
msd.mipi_samsung_disp_pdata = pdev->dev.platform_data;
printk(KERN_INFO
"[lcd] pdev->id =%d, pdev-name = %s\n", pdev->id, pdev->name);
sec_debug_mdp_init();
printk(KERN_INFO "[lcd] mipi_samsung_disp_probe end since pdev-id is 0\n");
return 0;
}
printk(KERN_INFO "[lcd] msm_fb_add_device : %s\n", pdev->name);
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
pm_gpio8 = PM8921_GPIO_PM_TO_SYS(PMIC_GPIO_ERR_FG);
rc = gpio_request(pm_gpio8, "err_fg");
if (rc) {
pr_err("request gpio err_fg failed, rc=%d\n", rc);
return -ENODEV;
}
rc = pm8xxx_gpio_config(pm_gpio8, &gpio_get_param);
if (rc) {
pr_err("gpio_config mlcd_rst failed (3), rc=%d\n", rc);
return -EINVAL;
}
#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_LCD_CLASS_DEVICE)
printk(KERN_INFO "[lcd] lcd_device_register for panel start\n");
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;
}
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);
}
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_window_type.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_window_type.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);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_siop_enable.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_siop_enable.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_backlight.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_backlight.attr.name);
}
#if defined(RUMTIME_MIPI_CLK_CHANGE)
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_fps_change.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_fps_change.attr.name);
}
#endif
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_temperature.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_temperature.attr.name);
}
ret = sysfs_create_file(&lcd_device->dev.kobj,
&dev_attr_panel_colors.attr);
if (ret) {
pr_info("sysfs create fail-%s\n",
dev_attr_panel_colors.attr.name);
}
printk(KERN_INFO "[lcd] backlight_device_register for panel start\n");
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
#if defined(CONFIG_MDNIE_LITE_TUNING)
pr_info("[%s] CONFIG_MDNIE_LITE_TUNING ok ! init class called!\n",
__func__);
mdnie_lite_tuning_init();
#endif
#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
printk(KERN_INFO "[lcd] mipi_samsung_disp_probe end\n");
return 0;
}
void sysfs_remove_files(struct kobject * kobj, const struct attribute **ptr)
{
int i;
for (i = 0; ptr[i]; i++)
sysfs_remove_file(kobj, ptr[i]);
}
static int qpnp_haptic_probe(struct spmi_device *spmi)
{
struct qpnp_hap *hap;
struct resource *hap_resource;
int rc, i;
hap = devm_kzalloc(&spmi->dev, sizeof(*hap), GFP_KERNEL);
if (!hap)
return -ENOMEM;
hap->spmi = spmi;
hap_resource = spmi_get_resource(spmi, 0, IORESOURCE_MEM, 0);
if (!hap_resource) {
dev_err(&spmi->dev, "Unable to get haptic base address\n");
return -EINVAL;
}
hap->base = hap_resource->start;
dev_set_drvdata(&spmi->dev, hap);
rc = qpnp_hap_parse_dt(hap);
if (rc) {
dev_err(&spmi->dev, "DT parsing failed\n");
return rc;
}
rc = qpnp_hap_config(hap);
if (rc) {
dev_err(&spmi->dev, "hap config failed\n");
return rc;
}
mutex_init(&hap->lock);
mutex_init(&hap->wf_lock);
INIT_WORK(&hap->work, qpnp_hap_worker);
hrtimer_init(&hap->hap_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
hap->hap_timer.function = qpnp_hap_timer;
hap->timed_dev.name = "vibrator";
hap->timed_dev.get_time = qpnp_hap_get_time;
hap->timed_dev.enable = qpnp_hap_td_enable;
rc = timed_output_dev_register(&hap->timed_dev);
if (rc < 0) {
dev_err(&spmi->dev, "timed_output registration failed\n");
goto timed_output_fail;
}
for (i = 0; i < ARRAY_SIZE(qpnp_hap_attrs); i++) {
rc = sysfs_create_file(&hap->timed_dev.dev->kobj,
&qpnp_hap_attrs[i].attr);
if (rc < 0) {
dev_err(&spmi->dev, "sysfs creation failed\n");
goto sysfs_fail;
}
}
return 0;
sysfs_fail:
for (i--; i >= 0; i--)
sysfs_remove_file(&hap->timed_dev.dev->kobj,
&qpnp_hap_attrs[i].attr);
timed_output_dev_unregister(&hap->timed_dev);
timed_output_fail:
cancel_work_sync(&hap->work);
hrtimer_cancel(&hap->hap_timer);
mutex_destroy(&hap->lock);
mutex_destroy(&hap->wf_lock);
return rc;
}
static int qpnp_wled_probe(struct spmi_device *spmi)
{
struct qpnp_wled *wled;
struct resource *wled_resource;
int rc, i;
wled = devm_kzalloc(&spmi->dev, sizeof(*wled), GFP_KERNEL);
if (!wled)
return -ENOMEM;
wled->spmi = spmi;
wled_resource = spmi_get_resource_byname(spmi, NULL, IORESOURCE_MEM,
QPNP_WLED_SINK_BASE);
if (!wled_resource) {
dev_err(&spmi->dev, "Unable to get wled sink base address\n");
return -EINVAL;
}
wled->sink_base = wled_resource->start;
wled_resource = spmi_get_resource_byname(spmi, NULL, IORESOURCE_MEM,
QPNP_WLED_CTRL_BASE);
if (!wled_resource) {
dev_err(&spmi->dev, "Unable to get wled ctrl base address\n");
return -EINVAL;
}
wled->ctrl_base = wled_resource->start;
wled_resource = spmi_get_resource_byname(spmi, NULL, IORESOURCE_MEM,
QPNP_WLED_IBB_BASE);
if (!wled_resource) {
dev_err(&spmi->dev, "Unable to get IBB base address\n");
return -EINVAL;
}
wled->ibb_base = wled_resource->start;
wled_resource = spmi_get_resource_byname(spmi, NULL, IORESOURCE_MEM,
QPNP_WLED_LAB_BASE);
if (!wled_resource) {
dev_err(&spmi->dev, "Unable to get LAB base address\n");
return -EINVAL;
}
wled->lab_base = wled_resource->start;
dev_set_drvdata(&spmi->dev, wled);
rc = qpnp_wled_parse_dt(wled);
if (rc) {
dev_err(&spmi->dev, "DT parsing failed\n");
return rc;
}
rc = qpnp_wled_config(wled);
if (rc) {
dev_err(&spmi->dev, "wled config failed\n");
return rc;
}
mutex_init(&wled->lock);
INIT_WORK(&wled->work, qpnp_wled_work);
wled->ramp_ms = QPNP_WLED_RAMP_DLY_MS;
wled->ramp_step = 1;
wled->cdev.brightness_set = qpnp_wled_set;
wled->cdev.brightness_get = qpnp_wled_get;
if (wled->en_9b_dim_res)
wled->cdev.max_brightness = WLED_MAX_LEVEL_511;
else
wled->cdev.max_brightness = WLED_MAX_LEVEL_4095;
rc = led_classdev_register(&spmi->dev, &wled->cdev);
if (rc) {
dev_err(&spmi->dev, "wled registration failed(%d)\n", rc);
goto wled_register_fail;
}
for (i = 0; i < ARRAY_SIZE(qpnp_wled_attrs); i++) {
rc = sysfs_create_file(&wled->cdev.dev->kobj,
&qpnp_wled_attrs[i].attr);
if (rc < 0) {
dev_err(&spmi->dev, "sysfs creation failed\n");
goto sysfs_fail;
}
}
gwled = wled;
return 0;
sysfs_fail:
for (i--; i >= 0; i--)
sysfs_remove_file(&wled->cdev.dev->kobj,
&qpnp_wled_attrs[i].attr);
led_classdev_unregister(&wled->cdev);
wled_register_fail:
cancel_work_sync(&wled->work);
mutex_destroy(&wled->lock);
return rc;
}
static int pch_phub_probe(struct pci_dev *pdev,
const struct pci_device_id *id)
{
int ret;
struct pch_phub_reg *chip;
chip = kzalloc(sizeof(struct pch_phub_reg), GFP_KERNEL);
if (chip == NULL)
return -ENOMEM;
ret = pci_enable_device(pdev);
if (ret) {
dev_err(&pdev->dev,
"%s : pci_enable_device FAILED(ret=%d)", __func__, ret);
goto err_pci_enable_dev;
}
dev_dbg(&pdev->dev, "%s : pci_enable_device returns %d\n", __func__,
ret);
ret = pci_request_regions(pdev, KBUILD_MODNAME);
if (ret) {
dev_err(&pdev->dev,
"%s : pci_request_regions FAILED(ret=%d)", __func__, ret);
goto err_req_regions;
}
dev_dbg(&pdev->dev, "%s : "
"pci_request_regions returns %d\n", __func__, ret);
chip->pch_phub_base_address = pci_iomap(pdev, 1, 0);
if (chip->pch_phub_base_address == NULL) {
dev_err(&pdev->dev, "%s : pci_iomap FAILED", __func__);
ret = -ENOMEM;
goto err_pci_iomap;
}
dev_dbg(&pdev->dev, "%s : pci_iomap SUCCESS and value "
"in pch_phub_base_address variable is %p\n", __func__,
chip->pch_phub_base_address);
chip->pdev = pdev; /* Save pci device struct */
if (id->driver_data == 1) { /* EG20T PCH */
const char *board_name;
ret = sysfs_create_file(&pdev->dev.kobj,
&dev_attr_pch_mac.attr);
if (ret)
goto err_sysfs_create;
ret = sysfs_create_bin_file(&pdev->dev.kobj, &pch_bin_attr);
if (ret)
goto exit_bin_attr;
pch_phub_read_modify_write_reg(chip,
(unsigned int)CLKCFG_REG_OFFSET,
CLKCFG_CAN_50MHZ,
CLKCFG_CANCLK_MASK);
/* quirk for CM-iTC board */
board_name = dmi_get_system_info(DMI_BOARD_NAME);
if (board_name && strstr(board_name, "CM-iTC"))
pch_phub_read_modify_write_reg(chip,
(unsigned int)CLKCFG_REG_OFFSET,
CLKCFG_UART_48MHZ | CLKCFG_BAUDDIV |
CLKCFG_PLL2VCO | CLKCFG_UARTCLKSEL,
CLKCFG_UART_MASK);
/* set the prefech value */
iowrite32(0x000affaa, chip->pch_phub_base_address + 0x14);
/* set the interrupt delay value */
iowrite32(0x25, chip->pch_phub_base_address + 0x44);
chip->pch_opt_rom_start_address = PCH_PHUB_ROM_START_ADDR_EG20T;
chip->pch_mac_start_address = PCH_PHUB_MAC_START_ADDR_EG20T;
} else if (id->driver_data == 2) { /* ML7213 IOH */
ret = sysfs_create_bin_file(&pdev->dev.kobj, &pch_bin_attr);
if (ret)
goto err_sysfs_create;
/* set the prefech value
* Device2(USB OHCI #1/ USB EHCI #1/ USB Device):a
* Device4(SDIO #0,1,2):f
* Device6(SATA 2):f
* Device8(USB OHCI #0/ USB EHCI #0):a
*/
iowrite32(0x000affa0, chip->pch_phub_base_address + 0x14);
chip->pch_opt_rom_start_address =\
PCH_PHUB_ROM_START_ADDR_ML7213;
} else if (id->driver_data == 3) { /* ML7223 IOH Bus-m*/
/* set the prefech value
* Device8(GbE)
*/
iowrite32(0x000a0000, chip->pch_phub_base_address + 0x14);
/* set the interrupt delay value */
iowrite32(0x25, chip->pch_phub_base_address + 0x140);
chip->pch_opt_rom_start_address =\
PCH_PHUB_ROM_START_ADDR_ML7223;
chip->pch_mac_start_address = PCH_PHUB_MAC_START_ADDR_ML7223;
} else if (id->driver_data == 4) { /* ML7223 IOH Bus-n*/
ret = sysfs_create_file(&pdev->dev.kobj,
&dev_attr_pch_mac.attr);
if (ret)
goto err_sysfs_create;
ret = sysfs_create_bin_file(&pdev->dev.kobj, &pch_bin_attr);
if (ret)
goto exit_bin_attr;
/* set the prefech value
* Device2(USB OHCI #0,1,2,3/ USB EHCI #0):a
* Device4(SDIO #0,1):f
* Device6(SATA 2):f
*/
iowrite32(0x0000ffa0, chip->pch_phub_base_address + 0x14);
chip->pch_opt_rom_start_address =\
PCH_PHUB_ROM_START_ADDR_ML7223;
chip->pch_mac_start_address = PCH_PHUB_MAC_START_ADDR_ML7223;
} else if (id->driver_data == 5) { /* ML7831 */
ret = sysfs_create_file(&pdev->dev.kobj,
&dev_attr_pch_mac.attr);
if (ret)
goto err_sysfs_create;
ret = sysfs_create_bin_file(&pdev->dev.kobj, &pch_bin_attr);
if (ret)
goto exit_bin_attr;
/* set the prefech value */
iowrite32(0x000affaa, chip->pch_phub_base_address + 0x14);
/* set the interrupt delay value */
iowrite32(0x25, chip->pch_phub_base_address + 0x44);
chip->pch_opt_rom_start_address = PCH_PHUB_ROM_START_ADDR_EG20T;
chip->pch_mac_start_address = PCH_PHUB_MAC_START_ADDR_EG20T;
}
chip->ioh_type = id->driver_data;
pci_set_drvdata(pdev, chip);
return 0;
exit_bin_attr:
sysfs_remove_file(&pdev->dev.kobj, &dev_attr_pch_mac.attr);
err_sysfs_create:
pci_iounmap(pdev, chip->pch_phub_base_address);
err_pci_iomap:
pci_release_regions(pdev);
err_req_regions:
pci_disable_device(pdev);
err_pci_enable_dev:
kfree(chip);
dev_err(&pdev->dev, "%s returns %d\n", __func__, ret);
return ret;
}
static void ts_key_report_deinit(void)
{
sysfs_remove_file(virtual_key_kobj, &dev_attr_virtualkeys.attr);
kobject_del(virtual_key_kobj);
}
/**
* driver_remove_file - remove sysfs file for driver.
* @drv: driver.
* @attr: driver attribute descriptor.
*/
void driver_remove_file(struct device_driver *drv,
struct driver_attribute *attr)
{
if (drv)
sysfs_remove_file(&drv->p->kobj, &attr->attr);
}
void skl_nhlt_remove_sysfs(struct skl *skl)
{
struct device *dev = &skl->pci->dev;
sysfs_remove_file(&dev->kobj, &dev_attr_platform_id.attr);
}