int samsung_display_sysfs_create( struct platform_device *pdev, struct platform_device *msm_fb_dev, char *panel_name) { int ret; struct lcd_device *lcd_device; if ((!pdev) || (!msm_fb_dev)) return -ENODEV; if (!panel_name) return -EFAULT; set_panel_name(panel_name, strnlen(panel_name, MAX_PANEL_NAME)); get_platform_data(msm_fb_dev); lcd_device = lcd_device_register("panel", &pdev->dev, NULL, &display_props); if (IS_ERR(lcd_device)) { ret = PTR_ERR(lcd_device); printk(KERN_ERR "lcd : failed to register device\n"); return ret; } ret = sysfs_create_file(&lcd_device->dev.kobj, &dev_attr_lcd_type.attr); if (ret) printk(KERN_ERR "sysfs create fail - %s\n", dev_attr_lcd_type.attr.name); return 0; }
void cause_polygon_damage( short polygon_index, short monster_index) { struct polygon_data *polygon= get_polygon_data(polygon_index); struct monster_data *monster= get_monster_data(monster_index); struct object_data *object= get_object_data(monster->object_index); short polygon_type = polygon->type; // apply damage from flooded platforms if (polygon->type == _polygon_is_platform) { struct platform_data *platform= get_platform_data(polygon->permutation); if (platform && PLATFORM_IS_FLOODED(platform)) { short adj_index = find_flooding_polygon(polygon_index); if (adj_index != NONE) { struct polygon_data *adj_polygon = get_polygon_data(adj_index); polygon_type = adj_polygon->type; } } } // #if 0 if ((polygon_type==_polygon_is_minor_ouch && !(dynamic_world->tick_count&MINOR_OUCH_FREQUENCY) && object->location.z==polygon->floor_height) || (polygon_type==_polygon_is_major_ouch && !(dynamic_world->tick_count&MAJOR_OUCH_FREQUENCY))) { struct damage_definition damage; damage.flags= _alien_damage; damage.type= polygon_type==_polygon_is_minor_ouch ? _damage_polygon : _damage_major_polygon; damage.base= polygon_type==_polygon_is_minor_ouch ? MINOR_OUCH_DAMAGE : MAJOR_OUCH_DAMAGE; damage.random= 0; damage.scale= FIXED_ONE; damage_monster(monster_index, NONE, NONE, (world_point3d *) NULL, &damage, NONE); } // #endif }
static bool test_item_retrieval(short polygon_index1, world_point3d *location1, world_point3d *location2) { bool valid_retrieval= true; auto polygon_index = polygon_index1; do { auto line_index= find_line_crossed_leaving_polygon(polygon_index, (world_point2d *) location1, (world_point2d *) location2); if (line_index!=NONE) { polygon_index= find_adjacent_polygon(polygon_index, line_index); if (LINE_IS_SOLID(get_line_data(line_index))) valid_retrieval= false; if (polygon_index!=NONE) { polygon_data *polygon= get_polygon_data(polygon_index); if (polygon->type==_polygon_is_platform) { platform_data *platform= get_platform_data(polygon->permutation); if (PLATFORM_IS_MOVING(platform)) valid_retrieval= false; } } } else { polygon_index= NONE; } } while (polygon_index!=NONE && valid_retrieval); return valid_retrieval; }
void *smb347_platform_data(void *info) { return get_platform_data(); }
static int wl1271_probe(struct sdio_func *func, const struct sdio_device_id *id) { struct wlcore_platdev_data pdev_data; struct wl12xx_sdio_glue *glue; struct resource res[1]; mmc_pm_flag_t mmcflags; int ret = -ENOMEM; const char *chip_family; /* We are only able to handle the wlan function */ if (func->num != 0x02) return -ENODEV; pdev_data.if_ops = &sdio_ops; glue = kzalloc(sizeof(*glue), GFP_KERNEL); if (!glue) { dev_err(&func->dev, "can't allocate glue\n"); goto out; } glue->dev = &func->dev; /* Grab access to FN0 for ELP reg. */ func->card->quirks |= MMC_QUIRK_LENIENT_FN0; /* Use block mode for transferring over one block size of data */ func->card->quirks |= MMC_QUIRK_BLKSZ_FOR_BYTE_MODE; pdev_data.pdata = get_platform_data(&func->dev); if (!pdev_data.pdata) goto out_free_glue; /* if sdio can keep power while host is suspended, enable wow */ mmcflags = sdio_get_host_pm_caps(func); dev_dbg(glue->dev, "sdio PM caps = 0x%x\n", mmcflags); if (mmcflags & MMC_PM_KEEP_POWER) pdev_data.pdata->pwr_in_suspend = true; sdio_set_drvdata(func, glue); /* Tell PM core that we don't need the card to be powered now */ pm_runtime_put_noidle(&func->dev); /* * Due to a hardware bug, we can't differentiate wl18xx from * wl12xx, because both report the same device ID. The only * way to differentiate is by checking the SDIO revision, * which is 3.00 on the wl18xx chips. */ if (func->card->cccr.sdio_vsn == SDIO_SDIO_REV_3_00) chip_family = "wl18xx"; else chip_family = "wl12xx"; glue->core = platform_device_alloc(chip_family, PLATFORM_DEVID_AUTO); if (!glue->core) { dev_err(glue->dev, "can't allocate platform_device"); ret = -ENOMEM; goto out_free_pdata; } glue->core->dev.parent = &func->dev; memset(res, 0x00, sizeof(res)); res[0].start = pdev_data.pdata->irq ?: gpio_to_irq(pdev_data.pdata->gpio); res[0].flags = IORESOURCE_IRQ; res[0].name = "irq"; ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res)); if (ret) { dev_err(glue->dev, "can't add resources\n"); goto out_dev_put; } ret = platform_device_add_data(glue->core, &pdev_data, sizeof(pdev_data)); if (ret) { dev_err(glue->dev, "can't add platform data\n"); goto out_dev_put; } ret = platform_device_add(glue->core); if (ret) { dev_err(glue->dev, "can't add platform device\n"); goto out_dev_put; } return 0; out_dev_put: platform_device_put(glue->core); out_free_pdata: del_platform_data(pdev_data.pdata); out_free_glue: kfree(glue); out: return ret; }
void *dollarcove_chrg_pdata(void *info) { return get_platform_data(); }
static int ktd_backlight_probe(struct platform_device *pdev) { struct platform_ktd2801_backlight_data *data = NULL; struct backlight_device *bl; struct ktd_bl_data *ktd; struct backlight_properties props; int ret=0; BLDBG("[BACKLIGHT] backlight driver probe\n"); if (pdev->dev.of_node) { data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); if (!data) { dev_err(&pdev->dev, "no memory for state\n"); return -ENOMEM; } if (get_platform_data(pdev, data)) { dev_err(&pdev->dev, "get_platform_data error\n"); return -EINVAL; } } else { dev_info(&pdev->dev, "No Device Tree\n"); data = pdev->dev.platform_data; } ktd = devm_kzalloc(&pdev->dev, sizeof(*ktd), GFP_KERNEL); if (!ktd) { dev_err(&pdev->dev, "no memory for state\n"); return -ENOMEM; } //backlight_pin = data->ctrl_pin; backlight_pin = 24; ret = gpio_request(backlight_pin, "BL_CTRL"); if(ret) BLDBG("BACKLIGHT GPIO REQUEST FAIL!\n"); gpio_direction_output(backlight_pin, 1); BLDBG("[BACKLIGHT] backlight_pin == %d\n", backlight_pin); memset(&props, 0, sizeof(struct backlight_properties)); props.max_brightness = data->max_brightness; props.type = BACKLIGHT_PLATFORM; bl = backlight_device_register("panel", &pdev->dev, ktd, &ktd_backlight_ops, &props); if (IS_ERR(bl)) { dev_err(&pdev->dev, "failed to register backlight\n"); return PTR_ERR(bl); } #if CABC_FEATURE_ON lcd_device_register("panel", &pdev->dev, NULL, NULL); ret = device_create_file(&bl->dev, &dev_attr_auto_brightness); if (ret < 0) dev_err(&pdev->dev, "failed to add sysfs entries\n"); #endif #if LCD_REGISTER lcd_device_register("panel", &pdev->dev, NULL, NULL); ret = device_create_file(&bl->dev, &dev_attr_manual_pulseset); if (ret < 0) dev_err(&pdev->dev, "failed to add sysfs entries\n"); #endif #ifdef CONFIG_HAS_EARLYSUSPEND ktd->pdev = pdev; ktd->early_suspend_desc.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN; ktd->early_suspend_desc.suspend = ktd_backlight_earlysuspend; ktd->early_suspend_desc.resume = ktd_backlight_lateresume; register_early_suspend(&ktd->early_suspend_desc); #endif bl->props.max_brightness = data->max_brightness; bl->props.brightness = data->dft_brightness; platform_set_drvdata(pdev, bl); return 0; }