static void __init tegra_ardbeg_init_early(void)
{
	tegra_get_board_info(&board_info);
	if (board_info.board_id == BOARD_E2548 ||
			board_info.board_id == BOARD_P2530)
		loki_rail_alignment_init();
	else
		ardbeg_rail_alignment_init();
	tegra12x_init_early();
}
static void cardhu_modem_init(void)
{
	struct board_info board_info;
	int w_disable_gpio, ret;

	int modem_id = tegra_get_modem_id();

	tegra_get_board_info(&board_info);
	switch (board_info.board_id) {
	case BOARD_E1291:
	case BOARD_E1198:
		if (((board_info.board_id == BOARD_E1291) &&
				(board_info.fab < BOARD_FAB_A03)) ||
			((board_info.board_id == BOARD_E1198) &&
					(board_info.fab < BOARD_FAB_A02))) {
			w_disable_gpio = TEGRA_GPIO_PH5;
		} else {
			w_disable_gpio = TEGRA_GPIO_PDD5;
		}

		ret = gpio_request(w_disable_gpio, "w_disable_gpio");
		if (ret < 0)
			pr_err("%s: gpio_request failed for gpio %d\n",
				__func__, w_disable_gpio);
		else
			gpio_direction_input(w_disable_gpio);

		/* E1291-A04 & E1198:A02: Set PERST signal to high */
		if (((board_info.board_id == BOARD_E1291) &&
				(board_info.fab >= BOARD_FAB_A04)) ||
			((board_info.board_id == BOARD_E1198) &&
					(board_info.fab >= BOARD_FAB_A02))) {
			ret = gpio_request(TEGRA_GPIO_PH7, "modem_perst");
			if (ret < 0) {
				pr_err("%s(): Error in allocating gpio "
					"TEGRA_GPIO_PH7\n", __func__);
				break;
			}
			gpio_direction_output(TEGRA_GPIO_PH7, 1);
		}
		break;
	case BOARD_E1186:
		platform_device_register(&tegra_baseband_power_device);
		platform_device_register(&tegra_baseband_power2_device);
		break;
	default:
		break;
	}

	if (modem_id == TEGRA_BB_TANGO) {
		tegra_ehci2_device.dev.platform_data = &tegra_ehci2_utmi_pdata;
		platform_device_register(&tegra_ehci2_device);
	}

}
示例#3
0
static void cardhu_usb_init(void)
{
	struct board_info bi;

	tegra_get_board_info(&bi);

	/* OTG should be the first to be registered */
	tegra_otg_device.dev.platform_data = &tegra_otg_pdata;
	platform_device_register(&tegra_otg_device);

	/* setup the udc platform data */
	tegra_udc_device.dev.platform_data = &tegra_udc_pdata;

	if (bi.board_id == BOARD_PM267) {
		hsic_enable_gpio = EN_HSIC_GPIO;
		hsic_reset_gpio = PM267_SMSC4640_HSIC_HUB_RESET_GPIO;
		tegra_ehci2_device.dev.platform_data = &tegra_ehci2_hsic_pdata;
		platform_device_register(&tegra_ehci2_device);
	} else if (bi.board_id == BOARD_E1256) {
		hsic_enable_gpio = EN_HSIC_GPIO;
		tegra_ehci2_device.dev.platform_data = &tegra_ehci2_hsic_pdata;
		platform_device_register(&tegra_ehci2_device);
	} else if (bi.board_id == BOARD_E1186) {
		tegra_ehci2_device.dev.platform_data =
						&tegra_ehci2_hsic_xmm_pdata;
		/* ehci2 registration happens in baseband-xmm-power  */
	} else {
		u32 project_info = tegra3_get_project_id();
		if (project_info == TEGRA3_PROJECT_TF300TL) {
			printk("[TF300TL] register tegra_ehci2_device\n");
			tegra_ehci2_utmi_pdata.u_data.host.power_off_on_suspend = false;
			tegra_ehci2_device.dev.platform_data = &tegra_ehci2_utmi_pdata;
			platform_device_register(&tegra_ehci2_device);
		} else if (project_info == TEGRA3_PROJECT_P1801) {
			printk("[P1801] register tegra_ehci2_device\n");
			tegra_ehci2_utmi_pdata.u_data.host.hot_plug = true;
			tegra_ehci2_device.dev.platform_data = &tegra_ehci2_utmi_pdata;
			platform_device_register(&tegra_ehci2_device);
		}else if (project_info == TEGRA3_PROJECT_TF300TG) {
			printk("[TF300TG] register tegra_ehci2_device\n");
			tegra_ehci2_utmi_pdata.u_data.host.power_off_on_suspend = false;
			tegra_ehci2_device.dev.platform_data =
					 &tegra_ehci2_hsic_xmm_pdata;
                /* ehci2 registration happens in baseband-xmm-power  */
		}
		/*
		tegra_ehci2_device.dev.platform_data = &tegra_ehci2_utmi_pdata;
		platform_device_register(&tegra_ehci2_device);
		*/
	}

	tegra_ehci3_device.dev.platform_data = &tegra_ehci3_utmi_pdata;
	platform_device_register(&tegra_ehci3_device);

}
static int enterprise_dsi_panel_enable(struct device *dev)
{
	int ret;
	struct board_info board_info;

	tegra_get_board_info(&board_info);

	ret = avdd_dsi_csi_rail_enable();
	if (ret)
		return ret;


#if DSI_PANEL_RESET
	if ((board_info.fab >= BOARD_FAB_A03) ||
		(board_info.board_id == BOARD_E1239)) {
		if (enterprise_lcd_reg == NULL) {
			enterprise_lcd_reg = regulator_get(dev, "lcd_vddio_en");
			if (IS_ERR_OR_NULL(enterprise_lcd_reg)) {
				pr_err("Could not get regulator lcd_vddio_en\n");
				ret = PTR_ERR(enterprise_lcd_reg);
				enterprise_lcd_reg = NULL;
				return ret;
			}
		}
		if (enterprise_lcd_reg != NULL) {
			ret = regulator_enable(enterprise_lcd_reg);
			if (ret < 0) {
				pr_err("Could not enable lcd_vddio_en\n");
				return ret;
			}
		}
	}

	if (kernel_1st_panel_init == true) {
		ret = gpio_request(enterprise_dsi_panel_reset, "panel reset");
		if (ret < 0)
			return ret;
		kernel_1st_panel_init = false;
	} else {
		ret = gpio_direction_output(enterprise_dsi_panel_reset, 0);
		if (ret < 0) {
			pr_err("%s: gpio_direction_ouput failed %d\n",
				__func__, ret);
			gpio_free(enterprise_dsi_panel_reset);
			return ret;
		}
		gpio_set_value(enterprise_dsi_panel_reset, 0);
		udelay(2000);
		gpio_set_value(enterprise_dsi_panel_reset, 1);
		mdelay(20);
	}
#endif

	return ret;
}
示例#5
0
int __init evitareul_pinmux_init(void)
{
	struct board_info board_info;
	tegra_get_board_info(&board_info);
	tegra_pinmux_config_table(evitareul_pinmux_common, ARRAY_SIZE(evitareul_pinmux_common));
	/* all pins should correctly configured in bootloader,
	 * remove all pin config but drive config here
	 */
	tegra_drive_pinmux_config_table(evitareul_drive_pinmux,ARRAY_SIZE(evitareul_drive_pinmux));
	return 0;
}
static int __init roth_revision_init(void)
{
	struct board_info board_info;
	tegra_get_board_info(&board_info);
	system_rev = 0;
	if (board_info.board_id == BOARD_P2560)
		system_rev = P2560;
	else if (board_info.board_id == BOARD_P2454)
		system_rev = P2454;
	return 0;
}
static void x3_init_deep_sleep_mode(void)
{
#if defined(CONFIG_MACH_X3)
	x3_suspend_data.suspend_mode = TEGRA_SUSPEND_LP0;
#else
	struct board_info bi;
	tegra_get_board_info(&bi);
	if (bi.board_id == BOARD_1205 && bi.fab == X3_FAB_A01)
		x3_suspend_data.suspend_mode = TEGRA_SUSPEND_LP1;
#endif
}
void tegra_set_usb_wake_source(void)
{
	struct board_info board_info;

	tegra_get_board_info(&board_info);
	/* For Dalmore */
	if (board_info.board_id == BOARD_E1611) {
		tegra_wake_event_irq[41] = INT_USB3;
		tegra_wake_event_irq[43] = -EINVAL;
	}
}
int __init atlantis_fixed_regulator_init(void)
{
	struct board_info board_info;
	int num_fixed_regulators = ARRAY_SIZE(fixed_reg_devs_e1670);

	tegra_get_board_info(&board_info);
	if ((board_info.fab == BOARD_FAB_A00) &&
		 (board_info.board_id != BOARD_E1740))
		num_fixed_regulators--;
	return platform_add_devices(fixed_reg_devs_e1670,
					num_fixed_regulators);
}
static void enterprise_nfc_init(void)
{
	struct board_info bi;

	/* Enable firmware GPIO PX7 for board E1205 */
	tegra_get_board_info(&bi);
	if (bi.board_id == BOARD_E1205 && bi.fab >= BOARD_FAB_A03) {
		nfc_pdata.firm_gpio = TEGRA_GPIO_PX7;
	} else if (bi.board_id == BOARD_E1239) {
		nfc_pdata.firm_gpio = TEGRA_GPIO_PD2;
	}
}
示例#11
0
int __init loki_kbc_init(void)
{
	struct board_info board_info;
	int ret;

	tegra_get_board_info(&board_info);
	pr_info("Boardid:SKU = 0x%04x:0x%04x\n",
			board_info.board_id, board_info.sku);

	ret = platform_device_register(&loki_int_keys_device);
	return ret;
}
int __init ventana_sensors_init(void)
{
	struct board_info BoardInfo;

	ventana_isl29018_init();
#ifdef CONFIG_SENSORS_AK8975
	ventana_akm8975_init();
#endif
#ifdef CONFIG_MPU_SENSORS_MPU3050
	mpuirq_init();
#endif
//	ventana_camera_init();
	ventana_nct1008_init();

	i2c_register_board_info(0, ventana_i2c0_board_info,
		ARRAY_SIZE(ventana_i2c0_board_info));

	tegra_get_board_info(&BoardInfo);

	/*
	 * battery driver is supported on FAB.D boards and above only,
	 * since they have the necessary hardware rework
	 */

	i2c_register_board_info(2, ventana_i2c2_board_info,
		ARRAY_SIZE(ventana_i2c2_board_info));

    /* Compal K1 - Carl begin */
	//i2c_register_board_info(3, ventana_i2c3_board_info_ssl3250a,
	//	ARRAY_SIZE(ventana_i2c3_board_info_ssl3250a));

	i2c_register_board_info(3, ventana_i2c3_board_info,
		ARRAY_SIZE(ventana_i2c3_board_info));
    /* Compal K1 - Carl end */

	i2c_register_board_info(4, ventana_i2c4_board_info,
		ARRAY_SIZE(ventana_i2c4_board_info));

    /* Compal K1 - Carl begin */
	/*
	i2c_register_board_info(6, ventana_i2c6_board_info,
		ARRAY_SIZE(ventana_i2c6_board_info));

	i2c_register_board_info(7, ventana_i2c7_board_info,
		ARRAY_SIZE(ventana_i2c7_board_info));

	i2c_register_board_info(8, ventana_i2c8_board_info,
		ARRAY_SIZE(ventana_i2c8_board_info));
	*/
    /* Compal K1 - Carl end */

	return 0;
}
static void enterprise_init_deep_sleep_mode(void)
{
	struct board_info bi;
	tegra_get_board_info(&bi);

	if (bi.board_id == BOARD_E1205 && bi.fab == BOARD_FAB_A01)
		enterprise_suspend_data.suspend_mode = TEGRA_SUSPEND_LP1;

	if ((bi.board_id == BOARD_E1205 && (bi.sku & BOARD_SKU_VF_BIT) == 0) ||
	    (bi.board_id == BOARD_E1197 && (bi.sku & BOARD_SKU_VF_BIT)))
		enterprise_suspend_data.cpu_timer = 8000;
}
示例#14
0
static void enterprise_audio_init(void)
{
	struct board_info board_info;

	tegra_get_board_info(&board_info);

	if (board_info.board_id == BOARD_E1197)
		enterprise_audio_pdata.audio_port_id[HIFI_CODEC] = 1;

	platform_add_devices(enterprise_audio_devices,
			ARRAY_SIZE(enterprise_audio_devices));
}
int enterprise_emc_init(void)
{
	struct board_info board_info;

	tegra_get_board_info(&board_info);

	if (board_info.fab <= BOARD_FAB_A02)
		tegra_init_emc(enterprise_emc_tables_h5tc2g,
			       ARRAY_SIZE(enterprise_emc_tables_h5tc2g));

	return 0;
}
static int enterprise_dsi_panel_enable(void)
{
	int ret;
	struct board_info board_info;

	tegra_get_board_info(&board_info);

	ret = avdd_dsi_csi_rail_enable();
	if (ret)
		return ret;

#if DSI_PANEL_RESET

	if (board_info.fab >= BOARD_FAB_A03) {
		if (enterprise_lcd_reg == NULL) {
			enterprise_lcd_reg = regulator_get(NULL, "lcd_vddio_en");
			if (IS_ERR_OR_NULL(enterprise_lcd_reg)) {
				pr_err("Could not get regulator lcd_vddio_en\n");
				ret = PTR_ERR(enterprise_lcd_reg);
				enterprise_lcd_reg = NULL;
				return ret;
			}
		}
		if (enterprise_lcd_reg != NULL) {
			ret = regulator_enable(enterprise_lcd_reg);
			if (ret < 0) {
				pr_err("Could not enable lcd_vddio_en\n");
				return ret;
			}
		}
	}

	if (kernel_1st_panel_init != true) {
		ret = gpio_request(enterprise_dsi_panel_reset, "panel reset");
		if (ret < 0)
			return ret;

		ret = gpio_direction_output(enterprise_dsi_panel_reset, 0);
		if (ret < 0) {
			gpio_free(enterprise_dsi_panel_reset);
			return ret;
		}
		tegra_gpio_enable(enterprise_dsi_panel_reset);

		gpio_set_value(enterprise_dsi_panel_reset, 0);
		udelay(2000);
		gpio_set_value(enterprise_dsi_panel_reset, 1);
		mdelay(20);
	}
#endif

	return ret;
}
static void __init tegra_enterprise_init(void)
{
	struct board_info board_info;
	tegra_get_board_info(&board_info);
	if (board_info.fab == BOARD_FAB_A04)
		tegra_clk_init_from_table(enterprise_clk_i2s4_table);
	else
		tegra_clk_init_from_table(enterprise_clk_i2s2_table);

	tegra_thermal_init(&thermal_data,
				throttle_list,
				ARRAY_SIZE(throttle_list));
	tegra_clk_init_from_table(enterprise_clk_init_table);
	tegra_soc_device_init("tegra_enterprise");
	enterprise_pinmux_init();
	enterprise_i2c_init();
	enterprise_uart_init();
	enterprise_usb_init();
#ifdef CONFIG_BT_BLUESLEEP
	if (board_info.board_id == BOARD_E1239)
		enterprise_bt_rfkill_pdata[0].reset_gpio = TEGRA_GPIO_PF4;
#endif
	platform_add_devices(enterprise_devices, ARRAY_SIZE(enterprise_devices));
	tegra_ram_console_debug_init();
	enterprise_regulator_init();
	tegra_io_dpd_init();
	enterprise_sdhci_init();
#ifdef CONFIG_TEGRA_EDP_LIMITS
	enterprise_edp_init();
#endif
	enterprise_kbc_init();
	enterprise_nfc_init();
	enterprise_touch_init();
	enterprise_audio_init();
	enterprise_baseband_init();
	enterprise_panel_init();
	if (tegra_get_commchip_id() == COMMCHIP_TI_WL18XX)
		enterprise_bt_st();
	else
#ifdef CONFIG_BT_BLUESLEEP
		enterprise_bt_rfkill();
	enterprise_setup_bluesleep();
#elif defined CONFIG_BLUEDROID_PM
		enterprise_bluedroid_pm();
#endif
	enterprise_emc_init();
	enterprise_sensors_init();
	enterprise_suspend_init();
	enterprise_bpc_mgmt_init();
	tegra_release_bootloader_fb();
	enterprise_vibrator_init();
}
static void __init cardhu_gpio_init_configure(void)
{
	struct board_info board_info;
	int len;
	int i;
	struct gpio_init_pin_info *pins_info;
	u32 project_info = tegra3_get_project_id();

	tegra_get_board_info(&board_info);

	switch (board_info.board_id) {
	case BOARD_E1198:
		if (board_info.fab < BOARD_FAB_A02) {
			len = ARRAY_SIZE(init_gpio_mode_e1291_a02);
			pins_info = init_gpio_mode_e1291_a02;
		} else {
			len = ARRAY_SIZE(init_gpio_mode_e1291_a03);
			pins_info = init_gpio_mode_e1291_a03;
		}
		break;
	case BOARD_E1291:
		if (board_info.fab < BOARD_FAB_A03) {
			len = ARRAY_SIZE(init_gpio_mode_e1291_a02);
			pins_info = init_gpio_mode_e1291_a02;
		} else if (board_info.fab == BOARD_FAB_A03) {
			len = ARRAY_SIZE(init_gpio_mode_e1291_a03);
			pins_info = init_gpio_mode_e1291_a03;
		} else {
			len = ARRAY_SIZE(init_gpio_mode_e1291_a04);
			pins_info = init_gpio_mode_e1291_a04;
		}
		break;
	case BOARD_PM269:
		if (project_info == TEGRA3_PROJECT_TF300TL) {
			len = ARRAY_SIZE(init_gpio_mode_pm269_TF300TL);
			pins_info = init_gpio_mode_pm269_TF300TL;
		} else if (project_info == TEGRA3_PROJECT_TF300T) {
			len = ARRAY_SIZE(init_gpio_mode_pm269_TF300T);
			pins_info = init_gpio_mode_pm269_TF300T;
			printk("PBB5 is set to low with PM269\n");
		}
		break;
	default:
		return;
	}

	for (i = 0; i < len; ++i) {
		tegra_gpio_init_configure(pins_info->gpio_nr,
			pins_info->is_input, pins_info->value);
		pins_info++;
	}
}
static void __init tegra_ventana_init(void)
{
	struct board_info BoardInfo;
	tegra_booting_info();
	ventana_setup_misc();
	tegra_clk_init_from_table(ventana_clk_init_table);
	ventana_pinmux_init();
	ventana_i2c_init();
        snprintf(ventana_chipid, sizeof(ventana_chipid), "%016llx", tegra_chip_uid());
	ventana_uart_init();

	if(ASUS3GAvailable()) {
		tegra_ehci2_device.dev.platform_data
			= &ventana_ehci2_ulpi_platform_data;
	}

	platform_add_devices(ventana_devices, ARRAY_SIZE(ventana_devices));

	ventana_sdhci_init();
	//ventana_charge_init();
	ventana_regulator_init();
	//ventana_charger_init();

	tegra_get_board_info(&BoardInfo);

#if defined(CONFIG_TOUCHSCREEN_ATMEL_MT_T9) || defined(CONFIG_TOUCHSCREEN_ATMEL_MT_T9_EP102)
       pr_info("Initializing Atmel touch driver\n");
       ventana_touch_init_atmel();
#elif defined(CONFIG_TOUCHSCREEN_PANJIT_I2C)
       pr_info("Initializing Panjit touch driver\n");
       ventana_touch_init_panjit();
#endif


#ifdef CONFIG_KEYBOARD_GPIO
	ventana_keys_init();
#endif

#ifdef CONFIG_DSP_FM34
	ventana_dsp_init();
#endif
	ventana_usb_init();
	ventana_gps_init();
	ventana_panel_init();
	ventana_sensors_init();
	//ventana_bt_rfkill();
	ventana_power_off_init();
	ventana_emc_init();

	ventana_setup_bluesleep();
//	tegra_release_bootloader_fb();
}
示例#20
0
int __init ventana_sensors_init(void)
{
	struct board_info BoardInfo;

	ventana_isl29018_init();
#ifdef CONFIG_SENSORS_AK8975
	ventana_akm8975_init();
#endif
#ifdef CONFIG_MPU_SENSORS_MPU3050
	ventana_mpuirq_init();
#endif
	ventana_camera_init();
	ventana_nct1008_init();

	i2c_register_board_info(0, ventana_i2c0_board_info,
		ARRAY_SIZE(ventana_i2c0_board_info));

	tegra_get_board_info(&BoardInfo);

	/*
	 * battery driver is supported on FAB.D boards and above only,
	 * since they have the necessary hardware rework
	 */
	if (BoardInfo.sku > 0) {
		ventana_bq20z75_init();
		i2c_register_board_info(2, ventana_i2c2_board_info,
			ARRAY_SIZE(ventana_i2c2_board_info));
	}

	i2c_register_board_info(3, ventana_i2c3_board_info_ssl3250a,
		ARRAY_SIZE(ventana_i2c3_board_info_ssl3250a));

	i2c_register_board_info(4, ventana_i2c4_board_info,
		ARRAY_SIZE(ventana_i2c4_board_info));

	i2c_register_board_info(6, ventana_i2c6_board_info,
		ARRAY_SIZE(ventana_i2c6_board_info));

	i2c_register_board_info(7, ventana_i2c7_board_info,
		ARRAY_SIZE(ventana_i2c7_board_info));

	i2c_register_board_info(8, ventana_i2c8_board_info,
		ARRAY_SIZE(ventana_i2c8_board_info));


#ifdef CONFIG_MPU_SENSORS_MPU3050
	i2c_register_board_info(0, mpu3050_i2c0_boardinfo,
		ARRAY_SIZE(mpu3050_i2c0_boardinfo));
#endif

	return 0;
}
static void __init tegra_dalmore_dt_init(void)
{
	tegra_get_board_info(&board_info);
	tegra_get_display_board_info(&display_board_info);

	tegra_dalmore_early_init();

	of_platform_populate(NULL,
		of_default_bus_match_table, dalmore_auxdata_lookup,
		&platform_bus);

	tegra_dalmore_late_init();
}
int __init scorpio_sensors_init(void)
{
	struct board_info BoardInfo;

	scorpio_isl29018_init();
#ifdef CONFIG_SENSORS_AK8975
	scorpio_akm8975_init();
#endif
#ifdef CONFIG_MPU_SENSORS_MPU3050
	scorpio_mpuirq_init();
#endif
	scorpio_nct1008_init();

	i2c_register_board_info(0, scorpio_i2c0_board_info,
		ARRAY_SIZE(scorpio_i2c0_board_info));

	tegra_get_board_info(&BoardInfo);

	/*
	 * battery driver is supported on FAB.D boards and above only,
	 * since they have the necessary hardware rework
	 */
	if (BoardInfo.sku > 0) {
		i2c_register_board_info(2, scorpio_i2c2_board_info,
			ARRAY_SIZE(scorpio_i2c2_board_info));
	}

	i2c_register_board_info(3, scorpio_i2c3_board_info_ssl3250a,
		ARRAY_SIZE(scorpio_i2c3_board_info_ssl3250a));

	i2c_register_board_info(4, scorpio_i2c4_board_info,
		ARRAY_SIZE(scorpio_i2c4_board_info));

#ifdef CONFIG_VIDEO_MT9P111_SCORPIO
	i2c_register_board_info(3, antares_i2c6_board_info,
		ARRAY_SIZE(antares_i2c6_board_info));
#endif

#ifdef CONFIG_VIDEO_MT9D115_SCORPIO
	i2c_register_board_info(3, antares_i2c7_board_info,
		ARRAY_SIZE(antares_i2c7_board_info));
#endif

#ifdef CONFIG_MPU_SENSORS_MPU3050
	i2c_register_board_info(0, mpu3050_i2c0_boardinfo,
		ARRAY_SIZE(mpu3050_i2c0_boardinfo));
#endif

	return 0;
}
static void __init tegra_loki_dt_init(void)
{
	tegra_get_board_info(&board_info);
	tegra_get_display_board_info(&display_board_info);

	tegra_loki_early_init();
#ifdef CONFIG_USE_OF
	of_platform_populate(NULL,
		of_default_bus_match_table, loki_auxdata_lookup,
		&platform_bus);
#endif

	tegra_loki_late_init();
}
示例#24
0
int __init ardbeg_sata_init(void)
{
#ifdef CONFIG_SATA_AHCI_TEGRA
	struct board_info board_info;
	tegra_get_board_info(&board_info);
	if ((board_info.board_id != BOARD_PM358) &&
	    (board_info.board_id != BOARD_PM359))
		tegra_ahci_platform_data0.pexp_gpio = -1;

	tegra_sata_device.dev.platform_data = &tegra_ahci_platform_data0;
	platform_device_register(&tegra_sata_device);
#endif
	return 0;
}
示例#25
0
static void kai_audio_init(void)
{
	struct board_info board_info;

	tegra_get_board_info(&board_info);

	if (board_info.fab == BOARD_FAB_A01) {
		kai_audio_pdata.codec_name = "rt5639.4-001c";
		kai_audio_pdata.codec_dai_name = "rt5639-aif1";
	} else if (board_info.fab == BOARD_FAB_A00) {
		kai_audio_pdata.codec_name = "rt5640.4-001c";
		kai_audio_pdata.codec_dai_name = "rt5640-aif1";
	}
}
示例#26
0
int  Qseven_rev(void)
{
	struct board_info board_info;
	
	tegra_get_board_info(&board_info);
	if ( strncmp((char*)(&board_info.Q7board_id),"22",2) == 0 && strncmp((char*)(&board_info.Q7board_rev),"3B",2) == 0 && ((char)(board_info.Q7board_conf & 0xFF)) == 'B')
		return Q7_REVB3;
	if ( strncmp((char*)(&board_info.Q7board_id),"22",2) == 0 && strncmp((char*)(&board_info.Q7board_rev),"4B",2) == 0 && ((char)(board_info.Q7board_conf & 0xFF)) == 'B')
		return Q7_REVB4;
	else if ( strncmp((char*)(&board_info.Q7board_id),"22",2) == 0 && ((strncmp((char*)(&board_info.Q7board_rev)+1,"C",1) == 0) && strncmp((char*)(&board_info.Q7board_rev),"3",1) >= 0))
		return Q7_REVC;
	else 
		return 0;
}
示例#27
0
static void __init cardhu_uart_init(void)
{
	struct clk *c;
	int i;
	struct board_info board_info;

	tegra_get_board_info(&board_info);

	for (i = 0; i < ARRAY_SIZE(uart_parent_clk); ++i) {
		c = tegra_get_clock_by_name(uart_parent_clk[i].name);
		if (IS_ERR_OR_NULL(c)) {
			pr_err("Not able to get the clock for %s\n",
						uart_parent_clk[i].name);
			continue;
		}
		uart_parent_clk[i].parent_clk = c;
		uart_parent_clk[i].fixed_clk_rate = clk_get_rate(c);
	}
	cardhu_uart_pdata.parent_clk_list = uart_parent_clk;
	cardhu_uart_pdata.parent_clk_count = ARRAY_SIZE(uart_parent_clk);
	cardhu_loopback_uart_pdata.parent_clk_list = uart_parent_clk;
	cardhu_loopback_uart_pdata.parent_clk_count =
						ARRAY_SIZE(uart_parent_clk);
	cardhu_loopback_uart_pdata.is_loopback = true;
	tegra_uarta_device.dev.platform_data = &cardhu_uart_pdata;
	tegra_uartb_device.dev.platform_data = &cardhu_uart_pdata;
	tegra_uartc_device.dev.platform_data = &cardhu_uart_pdata;
	tegra_uartd_device.dev.platform_data = &cardhu_uart_pdata;
	/* UARTE is used for loopback test purpose */
	tegra_uarte_device.dev.platform_data = &cardhu_loopback_uart_pdata;

	/* Register low speed only if it is selected */
	if (!is_tegra_debug_uartport_hs())
		uart_debug_init();

#ifdef CONFIG_TEGRA_IRDA
	if (((board_info.board_id == BOARD_E1186) ||
		(board_info.board_id == BOARD_E1198)) &&
			cardhu_irda_pdata.is_irda) {
		cardhu_irda_pdata.parent_clk_list = uart_parent_clk;
		cardhu_irda_pdata.parent_clk_count =
					ARRAY_SIZE(uart_parent_clk);

		tegra_uartb_device.dev.platform_data = &cardhu_irda_pdata;
	}
#endif

	platform_add_devices(cardhu_uart_devices,
				ARRAY_SIZE(cardhu_uart_devices));
}
示例#28
0
static void cardhu_usb_init(void)
{
	struct board_info bi;

	tegra_get_board_info(&bi);

	tegra_usb_phy_init(tegra_usb_phy_pdata,
			ARRAY_SIZE(tegra_usb_phy_pdata));

	tegra_otg_device.dev.platform_data = &tegra_otg_pdata;
	platform_device_register(&tegra_otg_device);
	if (bi.board_id == BOARD_PM267) {
		uhsic_phy_config.reset_gpio =
			PM267_SMSC4640_HSIC_HUB_RESET_GPIO;
		tegra_ehci2_device.dev.platform_data = &tegra_ehci_uhsic_pdata;
		platform_device_register(&tegra_ehci2_device);
	} else if (bi.board_id == BOARD_E1256) {
		tegra_ehci2_device.dev.platform_data = &tegra_ehci_uhsic_pdata;
		platform_device_register(&tegra_ehci2_device);
	} else if (bi.board_id == BOARD_E1186) {
		/* for baseband devices do not switch off phy during suspend */
		tegra_ehci_uhsic_pdata.power_down_on_bus_suspend = 0;
		uhsic_phy_config.postsuspend = cardhu_usb_hsic_postsupend;
		uhsic_phy_config.preresume = cardhu_usb_hsic_preresume;
		uhsic_phy_config.usb_phy_ready = cardhu_usb_hsic_phy_ready;
		uhsic_phy_config.post_phy_off = cardhu_usb_hsic_phy_off;
		tegra_ehci2_device.dev.platform_data = &tegra_ehci_uhsic_pdata;
		/* baseband registration happens in baseband-xmm-power  */
	} else {
		u32 project_info = tegra3_get_project_id();
		if (project_info == TEGRA3_PROJECT_TF300TG) {
			/* for baseband devices do not switch off phy during suspend */
			tegra_ehci_uhsic_pdata.power_down_on_bus_suspend = 0;
			uhsic_phy_config.postsuspend = cardhu_usb_hsic_postsupend;
			uhsic_phy_config.preresume = cardhu_usb_hsic_preresume;
			uhsic_phy_config.usb_phy_ready = cardhu_usb_hsic_phy_ready;
			uhsic_phy_config.post_phy_off = cardhu_usb_hsic_phy_off;
			tegra_ehci2_device.dev.platform_data = &tegra_ehci_uhsic_pdata;
			/* baseband registration happens in baseband-xmm-power  */
		} else if (project_info == TEGRA3_PROJECT_TF300TL) {
			printk("[TF300TL] register tegra_ehci2_device\n");
			tegra_ehci2_device.dev.platform_data = &tegra_ehci_pdata[1];
			platform_device_register(&tegra_ehci2_device);
		}
	}

	tegra_ehci3_device.dev.platform_data = &tegra_ehci_pdata[2];
	platform_device_register(&tegra_ehci3_device);
}
示例#29
0
static void pluto_modem_init(void)
{
	int modem_id = tegra_get_modem_id();
	struct board_info board_info;
	int usb_port_owner_info = tegra_get_usb_port_owner_info();

	tegra_get_board_info(&board_info);
	pr_info("%s: modem_id = %d\n", __func__, modem_id);

	switch (modem_id) {
	case TEGRA_BB_I500: /* on board i500 HSIC */
		if (!(usb_port_owner_info & HSIC1_PORT_OWNER_XUSB)) {
			platform_device_register(&icera_baseband_device);
		}
		break;
	case TEGRA_BB_I500SWD: /* i500 SWD HSIC */
		if (!(usb_port_owner_info & HSIC2_PORT_OWNER_XUSB)) {
			platform_device_register(&icera_baseband2_device);
		}
		break;
#ifdef CONFIG_TEGRA_BB_OEM1
	case TEGRA_BB_OEM1:	/* OEM1 HSIC */
		if ((board_info.board_id == BOARD_E1575) ||
			((board_info.board_id == BOARD_E1580) &&
				(board_info.fab >= BOARD_FAB_A03))) {
			tegra_pinmux_set_tristate(TEGRA_PINGROUP_GPIO_X1_AUD,
							TEGRA_TRI_NORMAL);
			bb_gpio_oem1.oem1.pwron = BB_OEM1_GPIO_ON_V;
		}
		if (!(usb_port_owner_info & HSIC2_PORT_OWNER_XUSB)) {
			tegra_hsic_pdata.ops = &oem1_hsic_pops;
			tegra_ehci3_device.dev.platform_data
				= &tegra_hsic_pdata;
			platform_device_register(&tegra_bb_oem1);
		}
		break;
#endif
	case TEGRA_BB_HSIC_HUB: /* i500 SWD HSIC */
		if (!(usb_port_owner_info & HSIC2_PORT_OWNER_XUSB)) {
			tegra_ehci3_device.dev.platform_data =
				&tegra_ehci3_hsic_smsc_hub_pdata;
			platform_device_register(&tegra_ehci3_device);
		}
		break;

	default:
		return;
	}
}
static void __init enterprise_bluedroid_pm(void)
{
	struct board_info board_info;
	tegra_get_board_info(&board_info);

	enterprise_bluedroid_pm_resources[1].start =
		enterprise_bluedroid_pm_resources[1].end =
				gpio_to_irq(TEGRA_GPIO_PS2);
	if (board_info.board_id == BOARD_E1239)
		enterprise_bluedroid_pm_resources[1].start =
			enterprise_bluedroid_pm_resources[1].end =
							TEGRA_GPIO_PF4;
	platform_device_register(&enterprise_bluedroid_pm_device);
	return;
}