static int stm_ste_connection(enum stm_connection_type con_type)
{
int retval = -EINVAL;
/* Check if connection type has been changed */
if (con_type == stm_current_connection)
return 0;
if (con_type != STM_DISCONNECT) {
/* Always enable MIPI34 GPIO pins */
retval = nmk_config_pins(
ARRAY_AND_SIZE(mop500_stm_mipi34_pins));
if (retval) {
STM_ERR("Failed to enable MIPI34\n");
goto stm_ste_connection_error;
}
}
switch (con_type) {
case STM_DEFAULT_CONNECTION:
case STM_STE_MODEM_ON_MIPI34_NONE_ON_MIPI60:
/* Enable altC3 on GPIO70-74 (STMMOD) & GPIO75-76 (UARTMOD) */
prcmu_enable_stm_mod_uart();
retval = stm_ste_disable_ape_on_mipi60();
break;
case STM_STE_APE_ON_MIPI34_NONE_ON_MIPI60:
/* Disable altC3 on GPIO70-74 (STMMOD) & GPIO75-76 (UARTMOD) */
prcmu_disable_stm_mod_uart();
retval = stm_ste_disable_ape_on_mipi60();
break;
case STM_STE_MODEM_ON_MIPI34_APE_ON_MIPI60:
/* Enable altC3 on GPIO70-74 (STMMOD) and GPIO75-76 (UARTMOD) */
prcmu_enable_stm_mod_uart();
/* Enable APE on MIPI60 */
retval = nmk_config_pins_sleep(ARRAY_AND_SIZE(mop500_ske_pins));
if (retval)
STM_ERR("Failed to disable SKE GPIO\n");
else {
retval = nmk_config_pins(
ARRAY_AND_SIZE(mop500_stm_mipi60_pins));
if (retval)
STM_ERR("Failed to enable MIPI60\n");
}
break;
case STM_STE_MODEM_ON_MICROSD:
/* Disable APE on micro SD */
retval = stm_disable_ape_microsd();
/* Enable modem on micro SD */
if (!retval)
retval = stm_enable_modem_microsd();
/* Enable SD card buffer and regulator on href */
if (!retval && (stm_current_connection
!= STM_STE_APE_ON_MICROSD)) {
enable_level_shifter_for_microsd();
enable_vaux3_for_microsd_cable();
}
break;
case STM_STE_APE_ON_MICROSD:
/* Disable modem on micro SD */
retval = stm_disable_modem_microsd();
/* Enable ape on micro SD */
if (!retval)
retval = stm_enable_ape_microsd();
/* Enable SD card buffer and regulator on href */
if (!retval && (stm_current_connection
!= STM_STE_MODEM_ON_MICROSD)) {
enable_level_shifter_for_microsd();
enable_vaux3_for_microsd_cable();
}
break;
case STM_DISCONNECT:
retval = nmk_config_pins_sleep(
ARRAY_AND_SIZE(mop500_stm_mipi34_pins));
if (retval)
STM_ERR("Failed to disable MIPI34\n");
retval = stm_ste_disable_ape_on_mipi60();
if (retval)
STM_ERR("Failed to disable MIPI60\n");
retval = stm_disable_modem_microsd();
if (retval)
STM_ERR("Failed to disable modem on microsd\n");
retval = stm_disable_ape_microsd();
if (retval)
STM_ERR("Failed to disable ape on microsd\n");
break;
default:
STM_ERR("Bad connection type\n");
goto stm_ste_connection_error;
}
/* Disable power for microsd */
if ((stm_current_connection == STM_STE_MODEM_ON_MICROSD)
|| (stm_current_connection == STM_STE_APE_ON_MICROSD)) {
if ((con_type != STM_STE_MODEM_ON_MICROSD)
&& (con_type != STM_STE_APE_ON_MICROSD)) {
disable_vaux3_for_microsd_cable();
disable_level_shifter_for_microsd();
}
}
stm_current_connection = con_type;
stm_ste_connection_error:
return retval;
}
static int palmte2_backlight_init(struct device *dev)
{
return gpio_request_array(ARRAY_AND_SIZE(palmte_bl_gpios));
}
static void __init balloon3_mmc_init(void)
{
pxa2xx_mfp_config(ARRAY_AND_SIZE(balloon3_mmc_pin_config));
pxa_set_mci_info(&balloon3_mci_platform_data);
}
void __init colibri_pxa320_init_ohci(void)
{
pxa3xx_mfp_config(ARRAY_AND_SIZE(colibri_pxa320_usb_pin_config));
pxa_set_ohci_info(&colibri_pxa320_ohci_info);
}
static void __init balloon3_i2c_init(void)
{
pxa_set_i2c_info(NULL);
i2c_register_board_info(0, ARRAY_AND_SIZE(balloon3_i2c_devs));
}
static void __init cmx255_init_rtc(void)
{
pxa2xx_set_spi_info(1, &pxa_ssp_master_info);
spi_register_board_info(ARRAY_AND_SIZE(spi_board_info));
}
static void __init colibri_pxa320_init_uart(void)
{
pxa3xx_mfp_config(ARRAY_AND_SIZE(colibri_pxa320_uart_pin_config));
}
void __init palm27x_pmic_init(void)
{
i2c_register_board_info(1, ARRAY_AND_SIZE(palm27x_pi2c_board_info));
pxa27x_set_i2c_power_info(&palm27x_i2c_power_info);
}
static void __init colibri_pxa300_init_lcd(void)
{
pxa3xx_mfp_config(ARRAY_AND_SIZE(colibri_pxa300_lcd_pin_config));
}
static void __init saar_init_i2c(void)
{
pxa_set_i2c_info(NULL);
i2c_register_board_info(0, ARRAY_AND_SIZE(saar_i2c_info));
}
void s6d04d1_smd_lcd_power(int on)
{
#if defined(__LCD_DEBUG__)
printk("[LCD] s6d04d1_smd_lcd_power\n");
#endif
if (!ssp)
ssp = ssp_lcd_init();
//if(on != lcdPanelOnOff_status) //pps-a
{
lcdPanelOnOff_status = on;
if (on) {
#if defined(__LCD_DEBUG__)
printk("[LCD] LCD ON\n");
#endif
lcd_power_control(1);
s6d04d1_smd_lcd_panel_reset();
mdelay(10);
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_passwd1));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_passwd2));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_disctl));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_pwrctl));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_vcmctll));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_pixel_format));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_tearing_lineon));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_memory_data));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_column_addset));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_page_addset));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_srcctl));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_ifctl));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_panelctl));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_gammasel1));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_pgammactl1));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_gammasel2));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_pgammactl2));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_gammasel3));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_pgammactl3));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_slpout));
mdelay(120);
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_dison));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_wrctrld_on));
ssp_send_cmd_para(ARRAY_AND_SIZE(brightness01));
mdelay(40);
} else {
#if defined(__LCD_DEBUG__)
printk("[LCD] LCD OFF\n");
#endif
ssp_send_cmd_para(ARRAY_AND_SIZE(brightness_off));
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_disoff));
mdelay(40);
ssp_send_cmd_para(ARRAY_AND_SIZE(smd_slpin));
mdelay(120);
setgpio20(0);
mdelay(10);
lcd_power_control(0);
}
}
}
static void ltm022a97a_update(struct fb_info *info)
{
pxafb_smart_queue(info, ARRAY_AND_SIZE(update_framedata));
pxafb_smart_flush(info);
}
static void __init income_i2c_init(void)
{
pxa_set_i2c_info(NULL);
pxa27x_set_i2c_power_info(NULL);
i2c_register_board_info(0, ARRAY_AND_SIZE(income_i2c_devs));
}
"req1", "req2",
"req3", "req4"};
/* ase */
static const char * const ase_exin_grps[] = {"exin0", "exin1", "exin2"};
static const char * const ase_gpt_grps[] = {"gpt1", "gpt2", "gpt3"};
static const char * const ase_dfe_grps[] = {"dfe"};
static const char * const ase_ephy_grps[] = {"ephy"};
static const char * const ase_asc_grps[] = {"asc"};
static const char * const ase_jtag_grps[] = {"jtag"};
static const char * const ase_stp_grps[] = {"stp"};
static const char * const ase_spi_grps[] = {"spi", "spi_cs1",
"spi_cs2", "spi_cs3"};
static const struct ltq_pmx_func danube_funcs[] = {
{"spi", ARRAY_AND_SIZE(xway_spi_grps)},
{"asc", ARRAY_AND_SIZE(xway_asc_grps)},
{"cgu", ARRAY_AND_SIZE(xway_cgu_grps)},
{"jtag", ARRAY_AND_SIZE(xway_jtag_grps)},
{"exin", ARRAY_AND_SIZE(xway_exin_grps)},
{"stp", ARRAY_AND_SIZE(xway_stp_grps)},
{"gpt", ARRAY_AND_SIZE(xway_gpt_grps)},
{"nmi", ARRAY_AND_SIZE(xway_nmi_grps)},
{"pci", ARRAY_AND_SIZE(xway_pci_grps)},
{"ebu", ARRAY_AND_SIZE(xway_ebu_grps)},
};
static const struct ltq_pmx_func xrx_funcs[] = {
{"spi", ARRAY_AND_SIZE(xway_spi_grps)},
{"asc", ARRAY_AND_SIZE(xway_asc_grps)},
{"cgu", ARRAY_AND_SIZE(xway_cgu_grps)},
static void __init corgi_init_spi(void)
{
pxa2xx_set_spi_info(1, &corgi_spi_info);
spi_register_board_info(ARRAY_AND_SIZE(corgi_spi_devices));
}
static void __init e400_init(void)
{
pxa2xx_mfp_config(ARRAY_AND_SIZE(e400_pin_config));
set_pxa_fb_info(&e400_pxafb_mach_info);
pxa_set_udc_info(&e7xx_udc_mach_info);
}
int cyttsp4_hw_power(int on, int use_irq, int irq_gpio)
{
int ret = 0;
static u8 is_power_on = 0;
CAPRI_TSP_DEBUG(" %s set %d \n", __func__, on);
if (tsp_regulator_3_3 == NULL) {
tsp_regulator_3_3 = regulator_get(NULL, "v_tsp_3v3");
if(IS_ERR(tsp_regulator_3_3)) {
tsp_regulator_3_3 = NULL;
printk("get touch_regulator_3v3 regulator error\n");
goto exit;
}
}
#if defined(CONFIG_MACH_BAFFIN)
if (tsp_regulator_1_8 == NULL) {
tsp_regulator_1_8 = regulator_get(NULL, "v_tsp_1v8");
if(IS_ERR(tsp_regulator_1_8)) {
tsp_regulator_1_8 = NULL;
printk("get touch_regulator_1v8 regulator error\n");
goto exit;
}
}
#endif
if (on == 1) {
if (!is_power_on) {
is_power_on = 1;
#if defined(CONFIG_CS05_BD_02)
regulator_set_voltage(tsp_regulator_3_3, 2900000, 2900000);
#else
regulator_set_voltage(tsp_regulator_3_3, 2850000, 2850000);
#endif
ret = regulator_enable(tsp_regulator_3_3);
if (ret) {
is_power_on = 0;
pr_err("can not enable TSP AVDD 3.3V, ret=%d\n", ret);
goto exit;
}
#if defined(CONFIG_MACH_BAFFIN)
regulator_set_voltage(tsp_regulator_1_8, 1800000, 1800000);
ret = regulator_enable(tsp_regulator_1_8);
if (ret) {
is_power_on = 0;
pr_err("can not enable TSP AVDD 1.8V, ret=%d\n", ret);
goto exit;
}
#endif
mfp_config(ARRAY_AND_SIZE(tsp_int_wakeup_mfpr));
/* Delay for 10 msec */
msleep(10);
i2c1_pin_changed(0);
}
/* Enable the IRQ */
/* if (use_irq) {
enable_irq(gpio_to_irq(irq_gpio));
pr_debug("Enabled IRQ %d for TSP\n", gpio_to_irq(irq_gpio));
}*/
} else if (on == 0) {
/* Disable the IRQ */
/*if (use_irq) {
pr_debug("Disabling IRQ %d for TSP\n", gpio_to_irq(irq_gpio));
disable_irq_nosync(gpio_to_irq(irq_gpio));
}*/
if (is_power_on) {
is_power_on = 0;
i2c1_pin_changed(1);
ret = regulator_disable(tsp_regulator_3_3);
if (ret) {
is_power_on = 1;
pr_err("can not disable TSP AVDD 3.3V, ret=%d\n", ret);
goto exit;
}
#if defined(CONFIG_MACH_BAFFIN)
ret = regulator_disable(tsp_regulator_1_8);
if (ret) {
is_power_on = 1;
pr_err("can not disable TSP AVDD 1.8V, ret=%d\n", ret);
goto exit;
}
#endif
mfp_config(ARRAY_AND_SIZE(tsp_int_suspend_mfpr));
/* Delay for 100 msec */
msleep(100);
}
} else { /* on == 2 */
if (is_power_on) {
is_power_on = 0;
//i2c1_pin_changed(1); because, CS05 model' lcd and tsp use same i2c line.
ret = regulator_disable(tsp_regulator_3_3);
if (ret) {
is_power_on = 1;
pr_err("can not disable TSP AVDD 3.3V, ret=%d\n", ret);
goto exit;
}
#if defined(CONFIG_MACH_BAFFIN)
ret = regulator_disable(tsp_regulator_1_8);
if (ret) {
is_power_on = 1;
pr_err("can not disable TSP AVDD 1.8V, ret=%d\n", ret);
goto exit;
}
#endif
mfp_config(ARRAY_AND_SIZE(tsp_int_suspend_mfpr));
/* Delay for 100 msec */
msleep(100);
}
}
exit:
return ret;
}
static void __init cmx270_init_spi(void)
{
pxa2xx_set_spi_info(2, &cm_x270_spi_info);
spi_register_board_info(ARRAY_AND_SIZE(cm_x270_spi_devices));
}
static inline void __init colibri_pxa320_init_ac97(void)
{
pxa3xx_mfp_config(ARRAY_AND_SIZE(colibri_pxa320_ac97_pin_config));
pxa_set_ac97_info(NULL);
}
static void gsm_exit(void)
{
free_irq(gpio_to_irq(GPIO25_GSM_MOD_ON_STATE), NULL);
gpio_free_array(ARRAY_AND_SIZE(gsm_gpios));
}
static void __init colibri_pxa320_init_eth(void)
{
colibri_pxa3xx_init_eth(&colibri_asix_platdata);
pxa3xx_mfp_config(ARRAY_AND_SIZE(colibri_pxa320_eth_pin_config));
platform_device_register(&asix_device);
}
static void __init icontrol_can_init(void)
{
pxa3xx_mfp_config(ARRAY_AND_SIZE(mfp_can_cfg));
platform_add_devices(ARRAY_AND_SIZE(icontrol_spi_devices));
spi_register_board_info(ARRAY_AND_SIZE(mcp251x_board_info));
}
static const char * const p168_nand_grps[] = {"nand"};
static const char * const p168_smc_grps[] = {"smc"};
static const char * const p168_smccs0_grps[] = {"smc cs0"};
static const char * const p168_smccs1_grps[] = {"smc cs1"};
static const char * const p168_smcrdy_grps[] = {"smc rdy"};
static const char * const p168_ac97sysclk_grps[] = {"ac97 sysclk"};
static const char * const p168_ac97_grps[] = {"ac97"};
static const char * const p168_cf_grps[] = {"cf"};
static const char * const p168_kpmkin_grps[] = {"kp mkin 3p1"};
static const char * const p168_kpmkout_grps[] = {"kp mkout 2p1"};
static const char * const p168_gpio86_grps[] = {"gpio86-1", "gpio86-2"};
static const char * const p168_gpio87_grps[] = {"gpio87-1", "gpio87-2"};
static const char * const p168_gpio88_grps[] = {"gpio88-1", "gpio88-2"};
static struct pxa3xx_pmx_func pxa168_funcs[] = {
{"uart1 rx", ARRAY_AND_SIZE(p168_uart1rx_grps)},
{"uart1 tx", ARRAY_AND_SIZE(p168_uart1tx_grps)},
{"uart3 rx", ARRAY_AND_SIZE(p168_uart3rx_grps)},
{"uart3 tx", ARRAY_AND_SIZE(p168_uart3tx_grps)},
{"ssp1 rx", ARRAY_AND_SIZE(p168_ssp1rx_grps)},
{"ssp1 tx", ARRAY_AND_SIZE(p168_ssp1tx_grps)},
{"ssp4 rx", ARRAY_AND_SIZE(p168_ssp4rx_grps)},
{"ssp4 tx", ARRAY_AND_SIZE(p168_ssp4tx_grps)},
{"ssp5 rx", ARRAY_AND_SIZE(p168_ssp5rx_grps)},
{"ssp5 tx", ARRAY_AND_SIZE(p168_ssp5tx_grps)},
{"i2c", ARRAY_AND_SIZE(p168_i2c_grps)},
{"pwri2c", ARRAY_AND_SIZE(p168_pwri2c_grps)},
{"mmc1", ARRAY_AND_SIZE(p168_mmc1_grps)},
{"mmc2", ARRAY_AND_SIZE(p168_mmc2_data_grps)},
{"mmc2 cmd", ARRAY_AND_SIZE(p168_mmc2_cmd_grps)},
{"mmc2 clk", ARRAY_AND_SIZE(p168_mmc2_clk_grps)},
static void __init z2_i2c_init(void)
{
pxa_set_i2c_info(NULL);
i2c_register_board_info(0, ARRAY_AND_SIZE(z2_i2c_board_info));
}
static void __init balloon3_pmic_init(void)
{
pxa27x_set_i2c_power_info(NULL);
i2c_register_board_info(1, ARRAY_AND_SIZE(balloon3_pi2c_board_info));
}
static int config_set(uint32_t key, GVariant *data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
int ret, cg_type, idx, j;
char float_str[30];
struct dev_context *devc;
const struct scope_config *model;
struct scope_state *state;
double tmp_d;
gboolean update_sample_rate;
if (!sdi || !(devc = sdi->priv))
return SR_ERR_ARG;
if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID)
return SR_ERR;
model = devc->model_config;
state = devc->model_state;
update_sample_rate = FALSE;
ret = SR_ERR_NA;
switch (key) {
case SR_CONF_LIMIT_FRAMES:
devc->frame_limit = g_variant_get_uint64(data);
ret = SR_OK;
break;
case SR_CONF_TRIGGER_SOURCE:
if ((idx = std_str_idx(data, *model->trigger_sources, model->num_trigger_sources)) < 0)
return SR_ERR_ARG;
state->trigger_source = idx;
/* TODO: A and B trigger support possible? */
ret = dlm_trigger_source_set(sdi->conn, (*model->trigger_sources)[idx]);
break;
case SR_CONF_VDIV:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
if ((idx = std_u64_tuple_idx(data, ARRAY_AND_SIZE(dlm_vdivs))) < 0)
return SR_ERR_ARG;
if ((j = std_cg_idx(cg, devc->analog_groups, model->analog_channels)) < 0)
return SR_ERR_ARG;
state->analog_states[j].vdiv = idx;
g_ascii_formatd(float_str, sizeof(float_str),
"%E", (float) dlm_vdivs[idx][0] / dlm_vdivs[idx][1]);
if (dlm_analog_chan_vdiv_set(sdi->conn, j + 1, float_str) != SR_OK ||
sr_scpi_get_opc(sdi->conn) != SR_OK)
return SR_ERR;
ret = SR_OK;
break;
case SR_CONF_TIMEBASE:
if ((idx = std_u64_tuple_idx(data, ARRAY_AND_SIZE(dlm_timebases))) < 0)
return SR_ERR_ARG;
state->timebase = idx;
g_ascii_formatd(float_str, sizeof(float_str),
"%E", (float) dlm_timebases[idx][0] / dlm_timebases[idx][1]);
ret = dlm_timebase_set(sdi->conn, float_str);
update_sample_rate = TRUE;
break;
case SR_CONF_HORIZ_TRIGGERPOS:
tmp_d = g_variant_get_double(data);
/* TODO: Check if the calculation makes sense for the DLM. */
if (tmp_d < 0.0 || tmp_d > 1.0)
return SR_ERR;
state->horiz_triggerpos = tmp_d;
tmp_d = -(tmp_d - 0.5) *
((double) dlm_timebases[state->timebase][0] /
dlm_timebases[state->timebase][1])
* model->num_xdivs;
g_ascii_formatd(float_str, sizeof(float_str), "%E", tmp_d);
ret = dlm_horiz_trigger_pos_set(sdi->conn, float_str);
break;
case SR_CONF_TRIGGER_SLOPE:
if ((idx = std_str_idx(data, ARRAY_AND_SIZE(dlm_trigger_slopes))) < 0)
return SR_ERR_ARG;
/* Note: See dlm_trigger_slopes[] in protocol.c. */
state->trigger_slope = idx;
ret = dlm_trigger_slope_set(sdi->conn, state->trigger_slope);
break;
case SR_CONF_COUPLING:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
if ((idx = std_str_idx(data, *model->coupling_options, model->num_coupling_options)) < 0)
return SR_ERR_ARG;
if ((j = std_cg_idx(cg, devc->analog_groups, model->analog_channels)) < 0)
return SR_ERR_ARG;
state->analog_states[j].coupling = idx;
if (dlm_analog_chan_coupl_set(sdi->conn, j + 1, (*model->coupling_options)[idx]) != SR_OK ||
sr_scpi_get_opc(sdi->conn) != SR_OK)
return SR_ERR;
ret = SR_OK;
break;
default:
ret = SR_ERR_NA;
break;
}
if (ret == SR_OK)
ret = sr_scpi_get_opc(sdi->conn);
if (ret == SR_OK && update_sample_rate)
ret = dlm_sample_rate_query(sdi);
return ret;
}
static void palmte2_backlight_exit(struct device *dev)
{
gpio_free_array(ARRAY_AND_SIZE(palmte_bl_gpios));
}
static int config_list(uint32_t key, GVariant **data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
int cg_type = CG_NONE;
struct dev_context *devc;
const struct scope_config *model;
devc = (sdi) ? sdi->priv : NULL;
model = (devc) ? devc->model_config : NULL;
if (!cg) {
switch (key) {
case SR_CONF_SCAN_OPTIONS:
case SR_CONF_DEVICE_OPTIONS:
return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
case SR_CONF_TIMEBASE:
*data = std_gvar_tuple_array(ARRAY_AND_SIZE(dlm_timebases));
return SR_OK;
case SR_CONF_TRIGGER_SOURCE:
if (!model)
return SR_ERR_ARG;
*data = g_variant_new_strv(*model->trigger_sources, model->num_trigger_sources);
return SR_OK;
case SR_CONF_TRIGGER_SLOPE:
*data = g_variant_new_strv(ARRAY_AND_SIZE(dlm_trigger_slopes));
return SR_OK;
case SR_CONF_NUM_HDIV:
*data = g_variant_new_uint32(model->num_xdivs);
return SR_OK;
default:
return SR_ERR_NA;
}
}
if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID)
return SR_ERR;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
if (cg_type == CG_ANALOG)
*data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg_analog));
else if (cg_type == CG_DIGITAL)
*data = std_gvar_array_u32(ARRAY_AND_SIZE(devopts_cg_digital));
else
*data = std_gvar_array_u32(NULL, 0);
break;
case SR_CONF_COUPLING:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
*data = g_variant_new_strv(*model->coupling_options, model->num_coupling_options);
break;
case SR_CONF_VDIV:
if (!cg)
return SR_ERR_CHANNEL_GROUP;
*data = std_gvar_tuple_array(ARRAY_AND_SIZE(dlm_vdivs));
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static void __init balloon3_leds_init(void)
{
pxa2xx_mfp_config(ARRAY_AND_SIZE(balloon3_led_pin_config));
platform_device_register(&balloon3_leds);
platform_device_register(&balloon3_pcf_leds);
}
static void __init simcom_init_baseboard(void)
{
pxa_set_i2c_info(NULL);
i2c_register_board_info(0, ARRAY_AND_SIZE(simcom_bb_dev_i2c_info));
}
