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 void ws2401_dpi_mcde_panel_early_suspend(
struct early_suspend *earlysuspend)
{
struct ws2401_dpi *lcd = container_of(earlysuspend,
struct ws2401_dpi,
earlysuspend);
pm_message_t dummy;
if (lcd->pd->bl_ctrl)
lcd->bd_enable = FALSE;
#ifdef ESD_OPERATION
if (lcd->esd_enable) {
lcd->esd_enable = 0;
set_irq_type(GPIO_TO_IRQ(lcd->esd_port), IRQF_TRIGGER_NONE);
disable_irq_nosync(GPIO_TO_IRQ(lcd->esd_port));
if (!list_empty(&(lcd->esd_work.entry))) {
cancel_work_sync(&(lcd->esd_work));
pr_info("%s cancel_work_sync", __func__);
}
pr_info("%s change lcd->esd_enable :%d", __func__,
lcd->esd_enable);
}
#endif
ws2401_dpi_mcde_panel_suspend(lcd->mdd, dummy);
prcmu_qos_remove_requirement(PRCMU_QOS_APE_OPP,
"codina_lcd_dpi");
}
static int __init mot_setup_mdm6600_usb_ipc(int irq)
{
if (irq) {
gpio_request(irq, "mdm6600_usb_wakeup");
gpio_direction_input(irq);
mdm6600_resources[0].start = GPIO_TO_IRQ(irq);
mdm6600_resources[0].end = GPIO_TO_IRQ(irq);
}
return platform_device_register(&mdm6600_usb_platform_device);
}
static int __devinit synaptics_ts_init(void)
{
printk("[TSP] %s\n", __func__ );
gpio_request(TSP_INT, "ts_irq");
gpio_direction_input(TSP_INT);
//bcm_gpio_pull_up(TSP_INT, true);
//bcm_gpio_pull_up_down_enable(TSP_INT, true);
set_irq_type(GPIO_TO_IRQ(TSP_INT), IRQF_TRIGGER_FALLING);
//disable BB internal pulls for touch int, scl, sda pin
bcm_gpio_pull_up_down_enable(TSP_INT, 0);
bcm_gpio_pull_up_down_enable(TSP_SCL, 0);
bcm_gpio_pull_up_down_enable(TSP_SDA, 0);
#if USE_THREADED_IRQ
#else
synaptics_wq = create_singlethread_workqueue("synaptics_wq");
if (!synaptics_wq)
return -ENOMEM;
#endif
check_ic_wq = create_singlethread_workqueue("check_ic_wq");
if (!check_ic_wq)
return -ENOMEM;
touch_regulator = regulator_get(NULL,"touch_vcc");
return i2c_add_driver(&synaptics_ts_driver);
}
/* that function will returns :
1) return : Host gpio interrupt number per customer platform
2) irq_flags_ptr : Type of Host interrupt as Level or Edge
NOTE :
Customer should check his platform definitions
and hist Host Interrupt spec
to figure out the proper setting for his platform.
BRCM provides just reference settings as example.
*/
int dhd_customer_oob_irq_map(unsigned long *irq_flags_ptr)
{
int host_oob_irq = 0;
#if defined(CUSTOM_OOB_GPIO_NUM)
if (dhd_oob_gpio_num < 0) {
dhd_oob_gpio_num = CUSTOM_OOB_GPIO_NUM;
}
#endif
if (dhd_oob_gpio_num < 0) {
WL_ERROR(("%s: ERROR customer specific Host GPIO is NOT defined \n",
__FUNCTION__));
return (dhd_oob_gpio_num);
}
WL_ERROR(("%s: customer specific Host GPIO number is (%d), flag=0x%X\n",
__FUNCTION__, dhd_oob_gpio_num, (unsigned int)*irq_flags_ptr));
#ifdef CONFIG_MACH_SAMSUNG_P3
host_oob_irq = gpio_to_irq(dhd_oob_gpio_num);
#elif defined(CONFIG_MACH_U8500)
host_oob_irq = GPIO_TO_IRQ(dhd_oob_gpio_num);
#elif defined(SYSLSI_SPECIFIC)
host_oob_irq = dhd_oob_gpio_num;
#elif defined(CONFIG_WIFI_CONTROL_FUNC)
host_oob_irq = wifi_get_irq_number(irq_flags_ptr);
#endif
return (host_oob_irq);
}
/****************************************************************************
*
* This function sets all the GPIO Rows input and request to register the IRQ
*
***************************************************************************/
static int SetRowInput( int array[], int row_count, struct CBLK *bcm_kp )
{
int i, gpio;
int ret;
for(i=0;i< row_count; i++ )
{
gpio = array[i];
if( gpio != BCM_NO_COLUMN )
{
reg_gpio_set_pull_up_down(gpio, 1);
reg_gpio_set_pull_up_down_enable(gpio);
reg_gpio_set_debounce_value_enable( gpio, GPIO_DEBOUNCE_16_MS );
ret = request_irq( GPIO_TO_IRQ(gpio), keypad_gpio_irq, ( IRQF_SHARED | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING ), \
"GPIO Keypad", bcm_kp);
if(ret < 0)
{
printk(KERN_ERR "%s(%s:%u)::GPIO %d request_irq failed IRQ %d\n", __FUNCTION__, __FILE__, __LINE__, gpio, GPIO_TO_IRQ(gpio));
return ret;
}
}
}
return(0);
}
static void est_test_timer_func(unsigned long data)
{
pr_info("%s\n", __func__);
if (list_empty(&(pdsi->esd_work.entry))) {
disable_irq_nosync(GPIO_TO_IRQ(pdsi->esd_port));
queue_work(pdsi->esd_workqueue, &(pdsi->esd_work));
pr_info("%s invoked\n", __func__);
}
mod_timer(&pdsi->esd_test_timer, jiffies + (10*HZ));
}
/****************************************************************************
*
* This function free the IRQ for the GPIO interrupt
*
***************************************************************************/
static void free_all_irqs( struct CBLK *bcm_kp )
{
int i;
for(i=0;i<bcm_kp->row_count;i++)
{
if( bcm_kp->keyRowArray[i] != BCM_NO_COLUMN )
free_irq( GPIO_TO_IRQ(bcm_kp->keyRowArray[i]), (void *)bcm_kp );
}
return;
}
static int __devinit synaptics_ts_init(void)
{
#if defined (CONFIG_TOUCHSCREEN_MMS128_TASSCOOPER)
Synaptics_Loaded = 1;
printk("[TSP][Synaptics][%s] %s\n", __func__,"Init Func Called");
if(Is_MMS128_Connected() == 1)
{
printk("[TSP][Synaptics][%s] %s\n", __func__,"Melfas already detected !!");
return -ENXIO;
}
if(Is_MMS128_Loaded() == 0)
{
#endif
printk("[TSP] %s\n", __func__ );
gpio_request(TSP_INT, "ts_irq");
gpio_direction_input(TSP_INT);
bcm_gpio_pull_up(TSP_INT, true);
bcm_gpio_pull_up_down_enable(TSP_INT, true);
set_irq_type(GPIO_TO_IRQ(TSP_INT), IRQF_TRIGGER_FALLING);
//#if defined (CONFIG_TOUCHSCREEN_MMS128_TASSCOOPER)
//disable BB internal pulls for touch int, scl, sda pin
bcm_gpio_pull_up_down_enable(TSP_INT, 0);
bcm_gpio_pull_up_down_enable(TSP_SCL, 0);
bcm_gpio_pull_up_down_enable(TSP_SDA, 0);
//#endif
#if defined (CONFIG_TOUCHSCREEN_MMS128_TASSCOOPER)
}
#endif
#if USE_THREADED_IRQ
#else
synaptics_wq = create_singlethread_workqueue("synaptics_wq");
if (!synaptics_wq)
return -ENOMEM;
#endif
touch_regulator = regulator_get(NULL,"touch_vcc");
return i2c_add_driver(&synaptics_ts_driver);
}
static int __devinit synaptics_ts_init(void)
{
printk("[TSP] %s\n", __func__ );
gpio_request(TSP_INT, "ts_irq");
gpio_direction_input(TSP_INT);
bcm_gpio_pull_up(TSP_INT, true);
bcm_gpio_pull_up_down_enable(TSP_INT, true);
set_irq_type(GPIO_TO_IRQ(TSP_INT), IRQF_TRIGGER_FALLING);
synaptics_wq = create_singlethread_workqueue("synaptics_wq");
if (!synaptics_wq)
return -ENOMEM;
touch_regulator = regulator_get(NULL,"touch_vcc");
return i2c_add_driver(&synaptics_ts_driver);
}
static void ws2401_dpi_mcde_panel_shutdown(struct mcde_display_device *ddev)
{
struct ws2401_dpi *lcd = dev_get_drvdata(&ddev->dev);
dev_dbg(&ddev->dev, "Invoked %s\n", __func__);
if (lcd->pd->bl_ctrl)
lcd->bd_enable = FALSE;
#ifdef ESD_OPERATION
if (lcd->esd_enable) {
lcd->esd_enable = 0;
disable_irq_nosync(GPIO_TO_IRQ(lcd->esd_port));
if (!list_empty(&(lcd->esd_work.entry))) {
cancel_work_sync(&(lcd->esd_work));
pr_info("%s cancel_work_sync", __func__);
}
destroy_workqueue(lcd->esd_workqueue);
}
#endif
ws2401_dpi_power(lcd, FB_BLANK_POWERDOWN);
if (lcd->pd->bl_ctrl)
backlight_device_unregister(lcd->bd);
spi_unregister_driver(&lcd->spi_drv);
#ifdef CONFIG_HAS_EARLYSUSPEND
unregister_early_suspend(&lcd->earlysuspend);
#endif
kfree(lcd);
dev_dbg(&ddev->dev, "end %s\n", __func__);
}
static irqreturn_t slave_ready_irq(int irq, void *dev)
{
struct ipc_link_context *context = (struct ipc_link_context *)dev;
struct modem_m6718_spi_link_platform_data *link = context->link;
struct spi_device *sdev = context->sdev;
if (irq != GPIO_TO_IRQ(link->gpio.int_pin)) {
dev_err(&sdev->dev,
"link %d error: spurious slave irq!", link->id);
return IRQ_NONE;
}
#ifdef WORKAROUND_DUPLICATED_IRQ
if (pl022_tfr_in_progress(sdev)) {
dev_warn(&sdev->dev,
"link %d warning: slave irq while transfer "
"is active! discarding event\n", link->id);
return IRQ_HANDLED;
}
#endif
ipc_sm_kick(IPC_SM_RUN_SLAVE_IRQ, context);
return IRQ_HANDLED;
}
},
#if defined(CONFIG_TEGRA_ODM_OLYMPUS)
{
/* ISL 29030 (prox/ALS) driver */
I2C_BOARD_INFO(LD_ISL29030_NAME, 0x44),
.platform_data = &isl29030_als_ir_data_Olympus,
.irq = 180,
},
#endif
};
static struct i2c_board_info tegra_i2c_bus2_board_info[] = {
{
/* only exists on Etna P2+; probe will gracefully fail if HW doesn't exist */
I2C_BOARD_INFO(L3G4200D_NAME, 0x68),
.platform_data = &tegra_gyro_pdata,
.irq = GPIO_TO_IRQ(TEGRA_GPIO_PH2),
},
};
static struct i2c_board_info tegra_i2c_bus3_board_info[] = {
{
I2C_BOARD_INFO("akm8975", 0x0C),
.platform_data = &akm8975_data,
.irq = GPIO_TO_IRQ(TEGRA_GPIO_PE2),
},
{
I2C_BOARD_INFO("kxtf9", 0x0F),
.platform_data = &kxtf9_data,
},
#if defined(CONFIG_TEGRA_ODM_ETNA)
{
/* ISL 29030 (prox/ALS) driver */
int size = ARRAY_SIZE(brcm_wlan_translate_custom_table);
int i;
if (!ccode)
return NULL;
for (i = 0; i < size; i++)
if (strcmp(ccode, brcm_wlan_translate_custom_table[i].iso_abbrev) == 0)
return &brcm_wlan_translate_custom_table[i];
return &brcm_wlan_translate_custom_table[0];
}
static struct resource brcm_wlan_resources[] = {
[0] = {
.name = "bcmdhd_wlan_irq",
.start = GPIO_TO_IRQ(WL_HOST_WAKE_GOLDEN_BRINGUP),
.end = GPIO_TO_IRQ(WL_HOST_WAKE_GOLDEN_BRINGUP),
//chanyun 12.21 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWEDGE,
.flags = IORESOURCE_IRQ | IRQF_TRIGGER_FALLING /*IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL | IORESOURCE_IRQ_SHAREABLE*/,
},
};
static struct wifi_platform_data brcm_wlan_control = {
.set_power = brcm_wlan_power,
.set_reset = brcm_wlan_reset,
.set_carddetect = brcm_set_carddetect,
#ifdef CONFIG_BROADCOM_WIFI_RESERVED_MEM
.mem_prealloc = brcm_wlan_mem_prealloc,
#endif
.get_country_code = brcm_wlan_get_country_code,
};
void ux500_suspend_dbg_remove_wake_on_uart(void)
{
irq_set_irq_wake(GPIO_TO_IRQ(ux500_console_uart_gpio_pin), 0);
}
void ux500_suspend_dbg_add_wake_on_uart(void)
{
irq_set_irq_wake(GPIO_TO_IRQ(ux500_console_uart_gpio_pin), 1);
irq_set_irq_type(GPIO_TO_IRQ(ux500_console_uart_gpio_pin),
IRQ_TYPE_EDGE_BOTH);
}
.name_a = "lsm303dlh.0",
.name_m = "lsm303dlh.1",
.axis_map_x = 1,
.axis_map_y = 0,
.axis_map_z = 2,
.negative_x = 0,
.negative_y = 0,
.negative_z = 1,
};
/*
* Touchscreen
*/
static struct synaptics_rmi4_platform_data rmi4_i2c_platformdata = {
.irq_number = GPIO_TO_IRQ(179),
.irq_type = (IRQF_TRIGGER_FALLING | IRQF_SHARED),
#if defined(CONFIG_DISPLAY_GENERIC_DSI_PRIMARY_ROTATION_ANGLE) && \
CONFIG_DISPLAY_GENERIC_DSI_PRIMARY_ROTATION_ANGLE == 270
.x_flip = true,
.y_flip = false,
#else
.x_flip = false,
.y_flip = true,
#endif
.regulator_en = true,
};
static struct av8100_platform_data av8100_plat_data = {
.irq = GPIO_TO_IRQ(223),
.reset = 225,
else
wlan_static_skb[i] = dev_alloc_skb(8192);
}
for (i = 0; (i < PREALLOC_WLAN_NUMBER_OF_SECTIONS); i++) {
wifi_mem_array[i].mem_ptr = kmalloc(wifi_mem_array[i].size,
GFP_KERNEL);
if (wifi_mem_array[i].mem_ptr == NULL)
return -ENOMEM;
}
return 0;
}
static struct resource mot_wifi_resources[] = {
[0] = {
.name = "bcm4329_wlan_irq",
.start = GPIO_TO_IRQ(WLAN_IRQ_GPIO),
.end = GPIO_TO_IRQ(WLAN_IRQ_GPIO),
.flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL
| IORESOURCE_IRQ_SHAREABLE,
},
};
static int mot_wifi_cd; /* WIFI virtual 'card detect' status */
static void (*wifi_status_cb)(int card_present, void *dev_id);
static void *wifi_status_cb_devid;
int mot_wifi_set_carddetect(int val)
{
pr_debug("%s: %d\n", __func__, val);
mot_wifi_cd = val;
sdhci_tegra_wlan_detect();
int __flash_gpio_to_irq(int gpio)
{
return GPIO_TO_IRQ(gpio);
}
int size = ARRAY_SIZE(brcm_wlan_translate_custom_table);
int i;
if (!ccode)
return NULL;
for (i = 0; i < size; i++)
if (strcmp(ccode, brcm_wlan_translate_custom_table[i].iso_abbrev) == 0)
return &brcm_wlan_translate_custom_table[i];
return &brcm_wlan_translate_custom_table[0];
}
static struct resource brcm_wlan_resources[] = {
[0] = {
.name = "bcmdhd_wlan_irq",
.start = GPIO_TO_IRQ(WL_HOST_WAKE_CODINA_R0_0),
.end = GPIO_TO_IRQ(WL_HOST_WAKE_CODINA_R0_0),
//chanyun 12.21 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWEDGE,
.flags = IORESOURCE_IRQ | IRQF_TRIGGER_FALLING /*IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL | IORESOURCE_IRQ_SHAREABLE*/,
},
};
static struct wifi_platform_data brcm_wlan_control = {
.set_power = brcm_wlan_power,
.set_reset = brcm_wlan_reset,
.set_carddetect = brcm_set_carddetect,
#ifdef CONFIG_BROADCOM_WIFI_RESERVED_MEM
.mem_prealloc = brcm_wlan_mem_prealloc,
#endif
.get_country_code = brcm_wlan_get_country_code,
};
/**
* db5500_keypad_probe() - Initialze the the keypad driver
* @pdev: pointer to platform device structure
*
* This function will allocate and initialize the instance
* data and request the irq and register to input subsystem driver.
*/
static int __devinit db5500_keypad_probe(struct platform_device *pdev)
{
struct db5500_keypad_platform_data *plat;
struct db5500_keypad *keypad;
struct resource *res;
struct input_dev *input;
void __iomem *base;
struct clk *clk;
int ret;
int irq;
int i;
plat = pdev->dev.platform_data;
if (!plat) {
dev_err(&pdev->dev, "invalid keypad platform data\n");
ret = -EINVAL;
goto out_ret;
}
irq = platform_get_irq(pdev, 0);
if (irq < 0) {
dev_err(&pdev->dev, "failed to get keypad irq\n");
ret = -EINVAL;
goto out_ret;
}
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
dev_err(&pdev->dev, "missing platform resources\n");
ret = -EINVAL;
goto out_ret;
}
res = request_mem_region(res->start, resource_size(res), pdev->name);
if (!res) {
dev_err(&pdev->dev, "failed to request I/O memory\n");
ret = -EBUSY;
goto out_ret;
}
base = ioremap(res->start, resource_size(res));
if (!base) {
dev_err(&pdev->dev, "failed to remap I/O memory\n");
ret = -ENXIO;
goto out_freerequest_memregions;
}
clk = clk_get(&pdev->dev, NULL);
if (IS_ERR(clk)) {
dev_err(&pdev->dev, "failed to clk_get\n");
ret = PTR_ERR(clk);
goto out_iounmap;
}
keypad = kzalloc(sizeof(struct db5500_keypad), GFP_KERNEL);
if (!keypad) {
dev_err(&pdev->dev, "failed to allocate keypad memory\n");
ret = -ENOMEM;
goto out_freeclk;
}
input = input_allocate_device();
if (!input) {
dev_err(&pdev->dev, "failed to input_allocate_device\n");
ret = -ENOMEM;
goto out_freekeypad;
}
keypad->regulator = regulator_get(&pdev->dev, "v-ape");
if (IS_ERR(keypad->regulator)) {
dev_err(&pdev->dev, "regulator_get failed\n");
keypad->regulator = NULL;
ret = -EINVAL;
goto out_regulator_get;
} else {
ret = regulator_enable(keypad->regulator);
if (ret < 0) {
dev_err(&pdev->dev, "regulator_enable failed\n");
goto out_regulator_enable;
}
}
input->id.bustype = BUS_HOST;
input->name = "db5500-keypad";
input->dev.parent = &pdev->dev;
input->keycode = keypad->keymap;
input->keycodesize = sizeof(keypad->keymap[0]);
input->keycodemax = ARRAY_SIZE(keypad->keymap);
input_set_capability(input, EV_MSC, MSC_SCAN);
__set_bit(EV_KEY, input->evbit);
if (!plat->no_autorepeat)
__set_bit(EV_REP, input->evbit);
matrix_keypad_build_keymap(plat->keymap_data, KEYPAD_ROW_SHIFT,
input->keycode, input->keybit);
ret = input_register_device(input);
if (ret) {
dev_err(&pdev->dev,
"unable to register input device: %d\n", ret);
goto out_freeinput;
}
keypad->irq = irq;
keypad->board = plat;
keypad->input = input;
keypad->base = base;
keypad->clk = clk;
INIT_DELAYED_WORK(&keypad->switch_work, db5500_gpio_switch_work);
INIT_DELAYED_WORK(&keypad->gpio_work, db5500_gpio_release_work);
clk_enable(keypad->clk);
if (!keypad->board->init) {
dev_err(&pdev->dev, "init funtion not defined\n");
ret = -EINVAL;
goto out_unregisterinput;
}
if (keypad->board->init() < 0) {
dev_err(&pdev->dev, "keyboard init config failed\n");
ret = -EINVAL;
goto out_unregisterinput;
}
if (!keypad->board->exit) {
dev_err(&pdev->dev, "exit funtion not defined\n");
ret = -EINVAL;
goto out_unregisterinput;
}
if (keypad->board->exit() < 0) {
dev_err(&pdev->dev, "keyboard exit config failed\n");
ret = -EINVAL;
goto out_unregisterinput;
}
for (i = 0; i < keypad->board->krow; i++) {
keypad->db5500_rows[i] = *plat->gpio_input_pins;
keypad->gpio_input_irq[i] =
GPIO_TO_IRQ(keypad->db5500_rows[i]);
plat->gpio_input_pins++;
}
for (i = 0; i < keypad->board->kcol; i++) {
keypad->db5500_cols[i] = *plat->gpio_output_pins;
plat->gpio_output_pins++;
}
for (i = 0; i < keypad->board->krow; i++) {
ret = request_threaded_irq(keypad->gpio_input_irq[i],
NULL, db5500_keypad_gpio_irq,
IRQF_TRIGGER_FALLING | IRQF_NO_SUSPEND,
"db5500-keypad-gpio", keypad);
if (ret) {
dev_err(&pdev->dev, "allocate gpio irq %d failed\n",
keypad->gpio_input_irq[i]);
goto out_unregisterinput;
}
enable_irq_wake(keypad->gpio_input_irq[i]);
}
ret = request_threaded_irq(keypad->irq, NULL, db5500_keypad_irq,
IRQF_ONESHOT, "db5500-keypad", keypad);
if (ret) {
dev_err(&pdev->dev, "allocate irq %d failed\n", keypad->irq);
goto out_unregisterinput;
}
platform_set_drvdata(pdev, keypad);
clk_disable(keypad->clk);
regulator_disable(keypad->regulator);
return 0;
out_unregisterinput:
input_unregister_device(input);
input = NULL;
clk_disable(keypad->clk);
out_freeinput:
input_free_device(input);
out_regulator_enable:
regulator_put(keypad->regulator);
out_regulator_get:
input_free_device(input);
out_freekeypad:
kfree(keypad);
out_freeclk:
clk_put(clk);
out_iounmap:
iounmap(base);
out_freerequest_memregions:
release_mem_region(res->start, resource_size(res));
out_ret:
return ret;
}
.init = ske_kp_init,
.exit = ske_kp_exit,
.gpio_input_pins = ske_kp_rows,
.gpio_output_pins = ske_kp_cols,
.keymap_data = &ux500_keymap_data,
.no_autorepeat = true,
.krow = SKE_KPD_MAX_ROWS, /* 8x8 matrix */
.kcol = SKE_KPD_MAX_COLS,
.debounce_ms = 20, /* in timeout period */
.switch_delay = 200, /* in jiffies */
};
static struct av8100_platform_data av8100_plat_data = {
.init = av8100_plat_init,
.exit = av8100_plat_exit,
.irq = GPIO_TO_IRQ(192),
.reset = 196,
.inputclk_id = "sysclk2",
.regulator_pwr_id = "hdmi_1v8",
.alt_powerupseq = false,
.mclk_freq = 3, /* MCLK_RNG_31_38 */
};
/*
* TC35892 Expander
*/
static struct tc35892_gpio_platform_data tc35892_gpio_platform_data = {
.gpio_base = U8500_NR_GPIO,
};
int size = ARRAY_SIZE(brcm_wlan_translate_custom_table);
int i;
if (!ccode)
return NULL;
for (i = 0; i < size; i++)
if (strcmp(ccode, brcm_wlan_translate_custom_table[i].iso_abbrev) == 0)
return &brcm_wlan_translate_custom_table[i];
return &brcm_wlan_translate_custom_table[0];
}
static struct resource brcm_wlan_resources[] = {
[0] = {
.name = "bcmdhd_wlan_irq",
.start = GPIO_TO_IRQ(WL_HOST_WAKE_SKOMER_BRINGUP),
.end = GPIO_TO_IRQ(WL_HOST_WAKE_SKOMER_BRINGUP),
//chanyun 12.21 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWEDGE,
.flags = IORESOURCE_IRQ | IRQF_TRIGGER_FALLING /*IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL | IORESOURCE_IRQ_SHAREABLE*/,
},
};
static struct wifi_platform_data brcm_wlan_control = {
.set_power = brcm_wlan_power,
.set_reset = brcm_wlan_reset,
.set_carddetect = brcm_set_carddetect,
#ifdef CONFIG_BROADCOM_WIFI_RESERVED_MEM
.mem_prealloc = brcm_wlan_mem_prealloc,
#endif
.get_country_code = brcm_wlan_get_country_code,
};
#include <mach/cw1200_plat.h>
#include <linux/clk.h>
static void cw1200_release(struct device *dev);
static int cw1200_clk_ctrl(const struct cw1200_platform_data *pdata,
bool enable);
static struct resource cw1200_pdp_resources[] = {
{
.start = 20,
.end = 20,
.flags = IORESOURCE_IO,
.name = "cw1200_reset",
},
{
.start = GPIO_TO_IRQ(169),
.end = GPIO_TO_IRQ(169),
.flags = IORESOURCE_IRQ,
.name = "cw1200_irq",
},
};
static struct cw1200_platform_data cw1200_platform_data = {
.clk_ctrl = cw1200_clk_ctrl,
};
static struct platform_device cw1200_device = {
.name = "cw1200_wlan",
.dev = {
.platform_data = &cw1200_platform_data,
static int __init ws2401_dpi_spi_probe(struct spi_device *spi)
{
int ret = 0;
struct ws2401_dpi *lcd = container_of(spi->dev.driver,
struct ws2401_dpi, spi_drv.driver);
dev_dbg(&spi->dev, "panel ws2401_dpi spi being probed\n");
dev_set_drvdata(&spi->dev, lcd);
/* ws2401_dpi lcd panel uses 3-wire 9bits SPI Mode. */
spi->bits_per_word = 9;
ret = spi_setup(spi);
if (ret < 0) {
dev_err(&spi->dev, "spi setup failed.\n");
goto out;
}
lcd->spi = spi;
/*
* if lcd panel was on from bootloader like u-boot then
* do not lcd on.
*/
if (!lcd->pd->platform_enabled) {
/*
* if lcd panel was off from bootloader then
* current lcd status is powerdown and then
* it enables lcd panel.
*/
lcd->power = FB_BLANK_POWERDOWN;
ws2401_dpi_power(lcd, FB_BLANK_UNBLANK);
} else {
lcd->power = FB_BLANK_UNBLANK;
lcd->ldi_state = LDI_STATE_ON;
}
#ifdef ESD_OPERATION
lcd->esd_workqueue = create_singlethread_workqueue("esd_workqueue");
if (!lcd->esd_workqueue) {
dev_info(lcd->dev, "esd_workqueue create fail\n");
return -ENOMEM;
}
INIT_WORK(&(lcd->esd_work), esd_work_func);
lcd->esd_port = ESD_PORT_NUM;
if (request_threaded_irq(GPIO_TO_IRQ(lcd->esd_port), NULL,
esd_interrupt_handler, IRQF_TRIGGER_RISING, "esd_interrupt", lcd)) {
dev_info(lcd->dev, "esd irq request fail\n");
free_irq(GPIO_TO_IRQ(lcd->esd_port), NULL);
lcd->lcd_connected = 0;
} else {
/* low is normal. On PBA esd_port coule be HIGH */
if (!gpio_get_value(lcd->esd_port)) {
dev_info(lcd->dev, "esd irq enabled on booting\n");
lcd->esd_enable = 1;
lcd->lcd_connected = 1;
} else {
dev_info(lcd->dev, "esd irq disabled on booting\n");
disable_irq(GPIO_TO_IRQ(lcd->esd_port));
lcd->esd_enable = 0;
lcd->lcd_connected = 0;
}
}
dev_info(lcd->dev, "%s esd work success\n");
#ifdef ESD_TEST
pdpi = lcd;
setup_timer(&lcd->esd_test_timer, est_test_timer_func, 0);
mod_timer(&lcd->esd_test_timer, jiffies + (3*HZ));
#endif
#endif
dev_dbg(&spi->dev, "ws2401_dpi spi has been probed.\n");
out:
return ret;
}
