static int __init mapphone_touch_gpio_init(struct i2c_board_info *i2c_info)
{
int err = 0;
int pin = 0;
pin = get_gpio_by_name("touch_panel_rst");
if (pin >= 0) {
err = gpio_request(pin, "touch_reset");
if (err >= 0) {
err = gpio_direction_output(pin, 0);
if (err < 0) {
printk(KERN_ERR "%s: Unable to config reset.\n",
__func__);
goto touch_gpio_init_fail;
}
} else {
printk(KERN_ERR "%s: Reset GPIO request failed.\n",
__func__);
goto touch_gpio_init_fail;
}
} else {
printk(KERN_ERR "%s: Cannot acquire reset pin.\n", __func__);
err = pin;
goto touch_gpio_init_fail;
}
pin = get_gpio_by_name("touch_panel_int");
if (pin >= 0) {
err = gpio_request(pin, "touch_irq");
if (err >= 0) {
err = gpio_direction_input(pin);
if (err < 0) {
printk(KERN_ERR "%s: Unable to config irq.\n",
__func__);
goto touch_gpio_init_fail;
}
} else {
printk(KERN_ERR "%s: IRQ GPIO request failed.\n",
__func__);
goto touch_gpio_init_fail;
}
} else {
printk(KERN_ERR "%s: Cannot acquire irq pin.\n", __func__);
err = pin;
goto touch_gpio_init_fail;
}
i2c_info->irq = gpio_to_irq(pin);
touch_gpio_init_fail:
return err;
}
void *ektf3k_platform_data(void *info)
{
static struct elan_ktf3k_i2c_platform_data elan_pdata;
elan_pdata.abs_x_max = ELAN_X_MAX - 1;
elan_pdata.abs_y_max = ELAN_Y_MAX - 1;
elan_pdata.abs_x_min = 0;
elan_pdata.abs_y_min = 0;
elan_pdata.rst_gpio = get_gpio_by_name("Touch_RST_N");
elan_pdata.intr_gpio = get_gpio_by_name("TP_INT_N");
elan_pdata.pwr_en_gpio = get_gpio_by_name("TP_PWR_EN");
return &elan_pdata;
}
void __init *xmm2230_platform_data(void *info)
{
static struct ifx_modem_platform_data xmm2230_pdata;
struct spi_board_info *spi_info = (struct spi_board_info *)info;
if(spi_info != NULL)
spi_bus_num = spi_info->bus_num;
xmm2230_pdata.srdy = get_gpio_by_name("xmm2230_srdy");
xmm2230_pdata.mrdy = get_gpio_by_name("xmm2230_mrdy");
xmm2230_pdata.max_hz = XMM2330_SPI_SPEED_HZ;
xmm2230_pdata.use_dma = true;
return &xmm2230_pdata;
}
void *gt927_platform_data(void *info)
{
static struct goodix_gt927_i2c_platform_data goodix_pdata;
//goodix_pdata.abs_x_max = ELAN_X_MAX - 1;
//goodix_pdata.abs_y_max = ELAN_Y_MAX - 1;
//goodix_pdata.abs_x_min = 0;
//goodix_pdata.abs_y_min = 0;
goodix_pdata.rst_gpio = get_gpio_by_name("Touch_RST_N");
goodix_pdata.intr_gpio = get_gpio_by_name("TP_INT_N");
goodix_pdata.pwr_en_gpio = get_gpio_by_name("TP_PWR_EN");
printk("intr_gpio=%d, rst_gpio=%d\n",goodix_pdata.intr_gpio,goodix_pdata.rst_gpio);
return &goodix_pdata;
}
static void omap4_mapphone_wifi_init(void)
{
int ret;
mapphone_wifi_pmena_gpio = get_gpio_by_name("wlan_pmena");
mapphone_wifi_irq_gpio = get_gpio_by_name("wlan_irqena");
ret = gpio_request(mapphone_wifi_pmena_gpio, "wifi_pmena");
if (ret < 0)
goto out;
gpio_direction_output(mapphone_wifi_pmena_gpio, 0);
omap4_mapphone_wlan_data.irq = OMAP_GPIO_IRQ(mapphone_wifi_irq_gpio);
if (wl12xx_set_platform_data(&omap4_mapphone_wlan_data))
pr_err("Error setting wl12xx data\n");
out:
return;
}
void __init *emc1403_platform_data(void *info)
{
static short intr2nd_pdata;
struct i2c_board_info *i2c_info = info;
int intr = get_gpio_by_name("thermal_int");
int intr2nd = get_gpio_by_name("thermal_alert");
if (intr == -1 || intr2nd == -1)
return NULL;
i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET;
intr2nd_pdata = intr2nd + INTEL_MID_IRQ_OFFSET;
return &intr2nd_pdata;
}
static void __init *lis331dl_platform_data(void *info)
{
static short intr2nd_pdata;
struct i2c_board_info *i2c_info = info;
int intr = get_gpio_by_name("accel_int");
int intr2nd = get_gpio_by_name("accel_2");
if (intr == -1 || intr2nd == -1)
return NULL;
i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET;
intr2nd_pdata = intr2nd + INTEL_MID_IRQ_OFFSET;
return &intr2nd_pdata;
}
/**
* Retrieves GPIO configuration.
*
* @return -1 if at least one GPIO value is missing
* @return 0 if successful
*/
int mcd_register_finalize(struct mcd_base_info const *info)
{
int ret = 0;
if (!info) {
pr_err("%s - oops: info is NULL\n", __func__);
ret = 0;
goto out;
}
switch (info->cpu_ver) {
case CPU_PWELL:
case CPU_CLVIEW:
case CPU_TANGIER:
case CPU_ANNIEDALE:
{
struct mdm_ctrl_cpu_data *cpu_data =
info->cpu_data;
cpu_data->gpio_rst_out =
get_gpio_by_name(cpu_data->gpio_rst_out_name);
cpu_data->gpio_pwr_on =
get_gpio_by_name(cpu_data->gpio_pwr_on_name);
cpu_data->gpio_rst_bbn =
get_gpio_by_name(cpu_data->gpio_rst_bbn_name);
cpu_data->gpio_cdump =
get_gpio_by_name(cpu_data->gpio_cdump_name);
if ((cpu_data->gpio_rst_out == -1) ||
(cpu_data->gpio_pwr_on == -1) ||
(cpu_data->gpio_rst_bbn == -1) ||
(cpu_data->gpio_cdump == -1))
ret = -1;
/* gpio on_key is only used by Modem 2230 */
if (!cpu_data->gpio_on_key_name) {
cpu_data->gpio_on_key = -1;
break;
}
cpu_data->gpio_on_key =
get_gpio_by_name(cpu_data->gpio_on_key_name);
break;
}
}
out:
return ret;
}
void *px3212c_platform_data(void *info)
{
static struct px3212c_platform_data platform_data;
platform_data.gpio=get_gpio_by_name("PROXM_INT#");
return &platform_data;
}
const struct camera_af_platform_data *camera_get_af_platform_data(void)
{
static const int GP_CORE = 96;
static const int GPIO_DEFAULT = GP_CORE + 76;
static const char gpio_name[] = "CAM_0_AF_EN";
static const struct camera_af_platform_data platform_data = {
.power_ctrl = camera_af_power_ctrl
};
#if 0
int gpio, r;
if (!INTEL_MID_BOARD(1, TABLET, BYT) && camera_af_power_gpio == -1) {
gpio = get_gpio_by_name(gpio_name);
if (gpio < 0) {
pr_err("%s: can't find gpio `%s',default\n",
__func__, gpio_name);
gpio = GPIO_DEFAULT;
}
pr_info("camera pdata: af gpio: %d\n", gpio);
r = gpio_request(gpio, gpio_name);
if (r)
return NULL;
r = gpio_direction_output(gpio, 0);
if (r)
return NULL;
camera_af_power_gpio = gpio;
}
return &platform_data;
#else
return &platform_data;
#endif
}
static int mdfld_dsi_sharp25x16_panel_reset(struct mdfld_dsi_config *dsi_config)
{
int ret = 0;
PSB_DEBUG_ENTRY("\n");
msleep(10);
if (mipi_reset_gpio == 0) {
ret = get_gpio_by_name("disp0_rst");
if (ret < 0) {
DRM_ERROR("Faild to get panel reset gpio, " \
"use default reset pin\n");
return 0;
}
mipi_reset_gpio = ret;
ret = gpio_request(mipi_reset_gpio, "mipi_display");
if (ret) {
DRM_ERROR("Faild to request panel reset gpio\n");
return 0;
}
}
gpio_direction_output(mipi_reset_gpio, 0);
usleep_range(1000, 1500);
gpio_set_value_cansleep(mipi_reset_gpio, 1);
return 0;
}
const struct camera_af_platform_data *camera_get_af_platform_data(void)
{
static const int GP_CORE = 96;
static const int GPIO_DEFAULT = GP_CORE + 76;
static const char gpio_name[] = "CAM_0_AF_EN";
static const struct camera_af_platform_data platform_data = {
.power_ctrl = camera_af_power_ctrl
};
int gpio, r;
if (camera_af_power_gpio == -1) {
gpio = get_gpio_by_name(gpio_name);
if (gpio < 0) {
pr_err("%s: can not find gpio `%s', using default\n",
__func__, gpio_name);
gpio = GPIO_DEFAULT;
}
r = gpio_request(gpio, gpio_name);
if (r)
return NULL;
r = gpio_direction_output(gpio, 0);
if (r)
return NULL;
pr_info("%s: using gpio %i\n", __func__, gpio);
camera_af_power_gpio = gpio;
}
return &platform_data;
}
void *apds990x_platform_data(void *info)
{
static struct apds990x_platform_data platform_data = {
.cf = {
.cf1 = 7782,
.irf1 = 2456,
.cf2 = 1228,
.irf2 = 1638,
.df = 52,
.ga = 15728,
},
.pdrive = 0,
.ppcount = 1,
};
if (spid.product_line_id == INTEL_MFLDP_LEX_ENG) {
platform_data.cf.cf1 = 8602;
platform_data.cf.irf1 = 6552;
platform_data.cf.cf2 = 1064;
platform_data.cf.irf2 = 860;
if (spid.hardware_id < MFLDP_LEX_PR21)
platform_data.cf.ga = 1474;
else
platform_data.cf.ga = 11796;
}
platform_data.gpio_number = get_gpio_by_name("AL-intr");
return &platform_data;
}
void *apds990x_platform_data(void *info)
{
static struct apds990x_platform_data platform_data = {
.cf = {
.cf1 = 4096,
.irf1 = 9134,
.cf2 = 2867,
.irf2 = 5816,
.df = 52,
.ga = 1966 * 9 / 2,
},
.pdrive = 0,
.ppcount = 1,
};
if (spid.product_line_id == INTEL_MFLDP_LEX_ENG) {
if (spid.hardware_id < MFLDP_LEX_PR21)
platform_data.cf.ga = 1966 / 2;
else
platform_data.cf.ga = 1966 * 4;
}
platform_data.gpio_number = get_gpio_by_name("AL-intr");
return &platform_data;
}
static int __init bq27541_platform_init(void)
{
int soc_int_gpio, soc_int_irq;
int res;
soc_int_gpio = get_gpio_by_name("max_fg_alert");
printk("<AXS> %s: fuegauge interrupt gpio = %d\n", __func__, soc_int_gpio);
if(soc_int_gpio != -ENODEV)
{
printk("<AXS> %s:gpio is OK fuegauge interrupt gpio = %d\n", __func__, soc_int_gpio);
if (!INTEL_MID_BOARD(1, TABLET, BYT))
soc_int_gpio = soc_int_gpio + INTEL_MID_IRQ_OFFSET;
res = irq_set_irq_wake(soc_int_irq, 1);
if (res) {
pr_err("%s: Failed to set irq wake for soc_int: %d\n", __func__, res);
return 0;
}
}
bq27541_platform_data.soc_int_irq = soc_int_irq;
//bq27541_platform_data.translate_temp = bq27541_translate_temp;
res = i2c_register_board_info(BQ27541_I2C_MASTER,
&bq27541_i2c_boardinfo, ARRAY_SIZE(bq27541_i2c_boardinfo));
if(res < 0){
pr_err("%s: fail register bq27541 i2c device\n");
}
return 0;
}
void *px3003b_platform_data(void *info)
{
static struct px3003b_i2c_platform_data platform_data;
platform_data.int_gpio=get_gpio_by_name("ALS_INT#");
return &platform_data;
}
void mapphone_init_modem_interface(void)
{
struct device_node *node;
const void *prop;
int rwkup_gpio = get_gpio_by_name("bp2ap_usb_rwkup");
if (rwkup_gpio < 0)
dummy_usb_config.usb_remote_wake_gpio =
MAPPHONE_BP_READY2_AP_GPIO;
else
dummy_usb_config.usb_remote_wake_gpio = rwkup_gpio;
node = of_find_node_by_path(DT_PATH_CHOSEN);
if (node == NULL) {
pr_err("Unable to read node %s from device tree!\n",
DT_PATH_CHOSEN);
return;
}
prop = of_get_property(node, DT_PROP_CHOSEN_MODEM_IFACE_NUM, NULL);
if (prop) {
pr_err("Setting the Modem Interface num to %d\n", *(u8 *)prop);
set_cdma_modem_interface(*(u8 *)prop);
} else
set_cdma_modem_interface(0);
of_node_put(node);
return;
}
static void adp5588_reset(void)
{
int reset_gpio;
reset_gpio = get_gpio_by_name("adp5588_reset_b");
/* If RESET GPIO is not configured in device_tree, assume default */
if (reset_gpio < 0) {
printk(KERN_INFO "%s: ADP5588: RESET_GPIO not in device_tree\n",
__func__);
reset_gpio = ADP5588_RESET_GPIO;
}
printk(KERN_INFO "%s: ADP5588: RESET asserted\n", __func__);
/* Assert ADP5588 RESET */
gpio_set_value(reset_gpio, 0);
/* This will keep RESET asserted for ~15 msec. */
msleep_interruptible(1);
/* Deassert ADP5588 RESET */
gpio_set_value(reset_gpio, 1);
/* Allow ADP5588 to come out of reset */
msleep_interruptible(1);
printk(KERN_INFO "%s: ADP5588: RESET deasserted\n", __func__);
}
/*
* One-time gpio initialization.
* @name: gpio name: coded in SFI table
* @gpio: gpio pin number (bypass @name)
* @dir: GPIOF_DIR_IN or GPIOF_DIR_OUT
* @value: if dir = GPIOF_DIR_OUT, this is the init value for output pin
* if dir = GPIOF_DIR_IN, this argument is ignored
* return: a positive pin number if succeeds, otherwise a negative value
*/
int camera_sensor_gpio(int gpio, char *name, int dir, int value)
{
int ret, pin;
if (gpio == -1) {
pin = get_gpio_by_name(name);
if (pin == -1) {
pr_err("%s: failed to get gpio(name: %s)\n",
__func__, name);
return -EINVAL;
}
pr_info("camera pdata: gpio: %s: %d\n", name, pin);
} else {
pin = gpio;
}
ret = gpio_request(pin, name);
if (ret) {
pr_err("%s: failed to request gpio(pin %d)\n", __func__, pin);
return -EINVAL;
}
if (dir == GPIOF_DIR_OUT)
ret = gpio_direction_output(pin, value);
else
ret = gpio_direction_input(pin);
if (ret) {
pr_err("%s: failed to set gpio(pin %d) direction\n",
__func__, pin);
gpio_free(pin);
}
return ret ? ret : pin;
}
/* Init HSIC AUX2 GPIO as side band remote wakeup source */
static int hsic_wakeup_gpio_init(void)
{
int retval = 0;
dev_dbg(&pci_dev->dev,
"%s---->\n", __func__);
hsic.wakeup_gpio = get_gpio_by_name(HSIC_WAKEUP_GPIO_NAME);
if (gpio_is_valid(hsic.wakeup_gpio)) {
retval = gpio_request(hsic.wakeup_gpio, "hsic_wakeup");
if (retval < 0) {
dev_err(&pci_dev->dev,
"Request GPIO %d with error %d\n",
hsic.wakeup_gpio, retval);
retval = -ENODEV;
goto err;
}
} else {
retval = -ENODEV;
goto err;
}
gpio_direction_input(hsic.wakeup_gpio);
dev_dbg(&pci_dev->dev,
"%s<----\n", __func__);
return retval;
err:
gpio_free(hsic.wakeup_gpio);
return retval;
}
void *ap3212c_platform_data(void *info)
{
static struct ap3212c_platform_data platform_data;
platform_data.gpio=get_gpio_by_name("ALS_INT#");
return &platform_data;
}
static
int mdfld_dsi_h8c7_cmd_panel_reset(struct mdfld_dsi_config *dsi_config)
{
static int mipi_reset_gpio;
int ret = 0;
PSB_DEBUG_ENTRY("\n");
if (mipi_reset_gpio == 0) {
ret = get_gpio_by_name("mipi-reset");
if (ret < 0) {
DRM_ERROR("Faild to get panel reset gpio, " \
"use default reset pin\n");
ret = 128;
}
mipi_reset_gpio = ret;
ret = gpio_request(mipi_reset_gpio, "mipi_display");
if (ret) {
DRM_ERROR("Faild to request panel reset gpio\n");
return -EINVAL;
}
gpio_direction_output(mipi_reset_gpio, 0);
}
gpio_set_value_cansleep(mipi_reset_gpio, 0);
mdelay(11);
gpio_set_value_cansleep(mipi_reset_gpio, 1);
mdelay(5);
return 0;
}
static int mapphone_bpwake_probe(struct platform_device *pdev)
{
int rc;
int apwake_trigger_gpio;
apwake_trigger_gpio = get_gpio_by_name("ipc_apwake_trigger");
if (apwake_trigger_gpio < 0)
apwake_trigger_gpio = MAPPHONE_APWAKE_TRIGGER_GPIO;
gpio_request(apwake_trigger_gpio, "BP -> AP IPC trigger");
gpio_direction_input(apwake_trigger_gpio);
wake_lock_init(&baseband_wakeup_wakelock, WAKE_LOCK_SUSPEND, "bpwake");
rc = request_irq(gpio_to_irq(apwake_trigger_gpio),
mapphone_bpwake_irqhandler,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"Remote Wakeup", NULL);
if (rc) {
wake_lock_destroy(&baseband_wakeup_wakelock);
printk(KERN_ERR
"Failed requesting APWAKE_TRIGGER irq (%d)\n", rc);
return rc;
}
enable_irq_wake(gpio_to_irq(apwake_trigger_gpio));
return 0;
}
/* Initialization function for thermal probe; success or failure does not
impact the rest of the system (except right channel audio if
tp_en_gpio is invalid).So return type is void
*/
void mfld_therm_probe_init(struct mfld_mc_private *ctx, int adc_ch_id)
{
int ret_val;
struct mfld_therm_probe_data *tp_data_ptr;
tp_data_ptr = &ctx->tp_data;
tp_data_ptr->tp_status = false;
tp_data_ptr->tp_adc_ch_id = adc_ch_id;
/* Init therm probe enable GPIO */
tp_data_ptr->tp_en_gpio = get_gpio_by_name("thermal_probe_en");
if (tp_data_ptr->tp_en_gpio >= 0) {
pr_info("GPIO for therm probe %d\n", tp_data_ptr->tp_en_gpio);
} else {
/* Workaround if the GPIO not defined in SFI table */
tp_data_ptr->tp_en_gpio = 114;
}
ret_val = gpio_request(tp_data_ptr->tp_en_gpio, "thermal_probe_en");
if (ret_val) {
pr_err("Therm probe Enable GPIO alloc fail:%d\n", ret_val);
/* Set gpio to -1 to indicate that gpio request had failed*/
tp_data_ptr->tp_en_gpio = -1;
return;
}
/* Default Ground HSL and HSR of MSIC. Grounding HSL is needed for
getting PlugDet interrupt in case thermal probe is connected.
This does not impact HS insertion interrupt*/
snd_soc_update_bits(ctx->mfld_jack.codec, SN95031_BTNCTRL2, BIT(1), BIT(1));
gpio_direction_output(tp_data_ptr->tp_en_gpio, 0);
}
void __init wifi_platform_data_init_sfi(void)
{
int err;
int wifi_irq_gpio = -1;
pr_err("wifi_platform_data_init_sfi\n");
/*Get GPIO numbers from the SFI table*/
wifi_irq_gpio = get_gpio_by_name(WIFI_SFI_GPIO_IRQ_NAME);
if (wifi_irq_gpio < 0) {
pr_err("%s: Unable to find" WIFI_SFI_GPIO_IRQ_NAME
"WLAN-interrupt GPIO in the SFI table\n",
__func__);
return;
}
wifi_res[0].start = wifi_res[0].end = wifi_irq_gpio;
/* For SFI compliant platforms, we need to manually register
a platform device */
err = platform_device_register(&wifi_device);
if (err < 0)
pr_err("platform_device_register failed for wifi_device\n");
}
void *compass_platform_data(void *info)
{
static struct akm8963_platform_data akm8963_pdata;
akm8963_pdata.gpio_DRDY = get_gpio_by_name("COMP_DRDY");
// akm8963_pdata.gpio_RSTN = get_gpio_by_name("RSTN");
return &akm8963_pdata;
}
void __init *msic_gpio_platform_data(void *info)
{
struct platform_device *pdev = NULL;
struct sfi_device_table_entry *entry = info;
static struct intel_msic_gpio_pdata msic_gpio_pdata;
int ret;
int gpio;
struct resource res;
pdev = platform_device_alloc(MSIC_GPIO_DEVICE_NAME, -1);
if (!pdev) {
pr_err("out of memory for SFI platform dev %s\n",
MSIC_GPIO_DEVICE_NAME);
return NULL;
}
gpio = get_gpio_by_name("msic_gpio_base");
if (gpio < 0)
return NULL;
/* Basincove PMIC GPIO has total 8 GPIO pins,
* GPIO[5:2,0] support 1.8V, GPIO[7:6,1] support 1.8V and 3.3V,
* We group GPIO[5:2] to low voltage and GPIO[7:6] to
* high voltage. Because the CTL registers are contiguous,
* this grouping method doesn't affect the driver usage but
* easy for the driver sharing among multiple platforms.
*/
msic_gpio_pdata.ngpio_lv = 6;
msic_gpio_pdata.ngpio_hv = 2;
msic_gpio_pdata.gpio0_lv_ctlo = 0x7E;
msic_gpio_pdata.gpio0_lv_ctli = 0x8E;
msic_gpio_pdata.gpio0_hv_ctlo = 0x84;
msic_gpio_pdata.gpio0_hv_ctli = 0x94;
msic_gpio_pdata.can_sleep = 1;
msic_gpio_pdata.gpio_base = gpio;
pdev->dev.platform_data = &msic_gpio_pdata;
ret = platform_device_add(pdev);
if (ret) {
pr_err("failed to add msic gpio platform device\n");
platform_device_put(pdev);
return NULL;
}
res.name = "IRQ",
res.flags = IORESOURCE_IRQ,
res.start = entry->irq;
platform_device_add_resources(pdev, &res, 1);
register_rpmsg_service("rpmsg_msic_gpio", RPROC_SCU, RP_MSIC_GPIO);
return &msic_gpio_pdata;
}
void *lsm303dlhc_accel_platform_data(void *info)
{
static struct lis3dh_acc_platform_data accel;
accel.poll_interval = 200;
accel.g_range = 2;
accel.negate_x = 1;
accel.negate_y = 0;
accel.negate_z = 0;
accel.axis_map_x = 0;
accel.axis_map_y = 1;
accel.axis_map_z = 2;
accel.gpio_int1 = get_gpio_by_name("accel_int");
accel.gpio_int2 = get_gpio_by_name("accel_2");
accel.model = MODEL_LSM303DLHC;
return &accel;
}
static void __init *max7315_platform_data(void *info)
{
static struct pca953x_platform_data max7315_pdata[MAX7315_NUM];
static int nr;
struct pca953x_platform_data *max7315 = &max7315_pdata[nr];
struct i2c_board_info *i2c_info = info;
int gpio_base, intr;
char base_pin_name[SFI_NAME_LEN + 1];
char intr_pin_name[SFI_NAME_LEN + 1];
if (nr == MAX7315_NUM) {
pr_err("too many max7315s, we only support %d\n",
MAX7315_NUM);
return NULL;
}
/* we have several max7315 on the board, we only need load several
* instances of the same pca953x driver to cover them
*/
strcpy(i2c_info->type, "max7315");
if (nr++) {
sprintf(base_pin_name, "max7315_%d_base", nr);
sprintf(intr_pin_name, "max7315_%d_int", nr);
} else {
strcpy(base_pin_name, "max7315_base");
strcpy(intr_pin_name, "max7315_int");
}
gpio_base = get_gpio_by_name(base_pin_name);
intr = get_gpio_by_name(intr_pin_name);
if (gpio_base == -1)
return NULL;
max7315->gpio_base = gpio_base;
if (intr != -1) {
i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET;
max7315->irq_base = gpio_base + INTEL_MID_IRQ_OFFSET;
} else {
i2c_info->irq = -1;
max7315->irq_base = -1;
}
return max7315;
}
static int mapphone_bpwake_remove(struct platform_device *pdev)
{
int apwake_trigger_gpio ;
wake_lock_destroy(&baseband_wakeup_wakelock);
apwake_trigger_gpio = get_gpio_by_name("ipc_apwake_trigger");
if (apwake_trigger_gpio < 0)
apwake_trigger_gpio = MAPPHONE_APWAKE_TRIGGER_GPIO;
free_irq(gpio_to_irq(apwake_trigger_gpio), NULL);
return 0;
}
