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;
}
