arm: tegra: enterprise: Renamed tegra_enterprise to enterprise

Renamed tegra_enterprise board name to enterprise

Original-Change-Id: If4bfe61ef086f980b81ca4fedd30d760e89befad
Reviewed-on: http://git-master/r/28324
Reviewed-by: Varun Colbert <vcolbert@nvidia.com>
Tested-by: Varun Colbert <vcolbert@nvidia.com>
Change-Id: I27173743eedba2d964b33d17136318f93f1e3afc

Rebase-Id: Rbc65b62d51cb7249bcf2d07291c93c223c231369

7 files changed, 197 insertions, 200 deletions

diff --git a/arch/arm/mach-tegra/Kconfig b/arch/arm/mach-tegra/Kconfig
index 26d4610f274c..2d0edc05208a 100644
--- a/arch/arm/mach-tegra/Kconfig
+++ b/arch/arm/mach-tegra/Kconfig
@@ -99,10 +99,10 @@ config MACH_WARIO
 
 # Enterprise
 config MACH_TEGRA_ENTERPRISE
-       bool "Tegra_enterprise board"
+       bool "Enterprise board"
        depends on ARCH_TEGRA_3x_SOC
        help
-         Support for NVIDIA Tegra_enterprise development platform
+         Support for NVIDIA Enterprise development platform
 
 config TEGRA_FPGA_PLATFORM
        bool "Support for NVIDIA Tegra FPGA platform"
diff --git a/arch/arm/mach-tegra/board-enterprise-memory.c b/arch/arm/mach-tegra/board-enterprise-memory.c
index 65d0932387e3..b3d9bc645f1a 100644
--- a/arch/arm/mach-tegra/board-enterprise-memory.c
+++ b/arch/arm/mach-tegra/board-enterprise-memory.c
@@ -23,7 +23,7 @@
 #include "tegra3_emc.h"
 
 
-static const struct tegra_emc_table tegra_enterprise_emc_tables_h5tc2g[] = {
+static const struct tegra_emc_table enterprise_emc_tables_h5tc2g[] = {
 	{
 		0x30,   	/* Rev 3.0 */
 		27000,   	/* SDRAM frquency */
@@ -722,9 +722,9 @@ static const struct tegra_emc_table tegra_enterprise_emc_tables_h5tc2g[] = {
 	}
 };
 
-int tegra_enterprise_emc_init(void)
+int enterprise_emc_init(void)
 {
-	tegra_init_emc(tegra_enterprise_emc_tables_h5tc2g,
-		ARRAY_SIZE(tegra_enterprise_emc_tables_h5tc2g));
+	tegra_init_emc(enterprise_emc_tables_h5tc2g,
+		ARRAY_SIZE(enterprise_emc_tables_h5tc2g));
 	return 0;
 }
diff --git a/arch/arm/mach-tegra/board-enterprise-panel.c b/arch/arm/mach-tegra/board-enterprise-panel.c
index 4bb40f7ebb3b..cf5ac2f5fb26 100644
--- a/arch/arm/mach-tegra/board-enterprise-panel.c
+++ b/arch/arm/mach-tegra/board-enterprise-panel.c
@@ -42,58 +42,58 @@
 #define AVDD_LCD PMU_TCA6416_GPIO_PORT17
 #define DSI_PANEL_RESET 0
 
-#define tegra_enterprise_lvds_shutdown	TEGRA_GPIO_PL2
-#define tegra_enterprise_bl_enb		TEGRA_GPIO_PH2
-#define tegra_enterprise_bl_pwm		TEGRA_GPIO_PH0
-#define tegra_enterprise_hdmi_hpd		TEGRA_GPIO_PN7
+#define enterprise_lvds_shutdown	TEGRA_GPIO_PL2
+#define enterprise_bl_enb		TEGRA_GPIO_PH2
+#define enterprise_bl_pwm		TEGRA_GPIO_PH0
+#define enterprise_hdmi_hpd		TEGRA_GPIO_PN7
 
-#define tegra_enterprise_dsia_bl_enb	TEGRA_GPIO_PW1
-#define tegra_enterprise_dsi_panel_reset	TEGRA_GPIO_PW0
+#define enterprise_dsia_bl_enb	TEGRA_GPIO_PW1
+#define enterprise_dsi_panel_reset	TEGRA_GPIO_PW0
 
-static struct regulator *tegra_enterprise_hdmi_reg = NULL;
-static struct regulator *tegra_enterprise_hdmi_pll = NULL;
-static struct regulator *tegra_enterprise_hdmi_vddio = NULL;
+static struct regulator *enterprise_hdmi_reg = NULL;
+static struct regulator *enterprise_hdmi_pll = NULL;
+static struct regulator *enterprise_hdmi_vddio = NULL;
 
 static atomic_t sd_brightness = ATOMIC_INIT(255);
 
-static int tegra_enterprise_backlight_init(struct device *dev)
+static int enterprise_backlight_init(struct device *dev)
 {
 	int ret;
 
 	/* Enable back light for DSIa panel */
-	printk("tegra_enterprise_dsi_backlight_init\n");
+	printk("enterprise_dsi_backlight_init\n");
 
-	ret = gpio_request(tegra_enterprise_dsia_bl_enb, "dsia_bl_enable");
+	ret = gpio_request(enterprise_dsia_bl_enb, "dsia_bl_enable");
 	if (ret < 0)
 		return ret;
 
-	ret = gpio_direction_output(tegra_enterprise_dsia_bl_enb, 1);
+	ret = gpio_direction_output(enterprise_dsia_bl_enb, 1);
 	if (ret < 0)
-		gpio_free(tegra_enterprise_dsia_bl_enb);
+		gpio_free(enterprise_dsia_bl_enb);
 	else
-		tegra_gpio_enable(tegra_enterprise_dsia_bl_enb);
+		tegra_gpio_enable(enterprise_dsia_bl_enb);
 
 	return ret;
 }
 
-static void tegra_enterprise_backlight_exit(struct device *dev)
+static void enterprise_backlight_exit(struct device *dev)
 {
 	/* Disable back light for DSIa panel */
-	gpio_set_value(tegra_enterprise_dsia_bl_enb, 0);
-	gpio_free(tegra_enterprise_dsia_bl_enb);
-	tegra_gpio_disable(tegra_enterprise_dsia_bl_enb);
+	gpio_set_value(enterprise_dsia_bl_enb, 0);
+	gpio_free(enterprise_dsia_bl_enb);
+	tegra_gpio_disable(enterprise_dsia_bl_enb);
 
 	gpio_set_value(TEGRA_GPIO_PL2, 1);
 	mdelay(20);
 }
 
-static int tegra_enterprise_backlight_notify(struct device *unused, int brightness)
+static int enterprise_backlight_notify(struct device *unused, int brightness)
 {
 	int cur_sd_brightness = atomic_read(&sd_brightness);
 	int orig_brightness = brightness;
 
 	/* DSIa */
-	gpio_set_value(tegra_enterprise_dsia_bl_enb, !!brightness);
+	gpio_set_value(enterprise_dsia_bl_enb, !!brightness);
 
 	/* SD brightness is a percentage, 8-bit value. */
 	brightness = (brightness * cur_sd_brightness) / 255;
@@ -105,69 +105,69 @@ static int tegra_enterprise_backlight_notify(struct device *unused, int brightne
 	return brightness;
 }
 
-static struct platform_pwm_backlight_data tegra_enterprise_backlight_data = {
+static struct platform_pwm_backlight_data enterprise_backlight_data = {
 	.pwm_id		= 0,
 	.max_brightness	= 255,
 	.dft_brightness	= 224,
 	.pwm_period_ns	= 5000000,
-	.init		= tegra_enterprise_backlight_init,
-	.exit		= tegra_enterprise_backlight_exit,
-	.notify		= tegra_enterprise_backlight_notify,
+	.init		= enterprise_backlight_init,
+	.exit		= enterprise_backlight_exit,
+	.notify		= enterprise_backlight_notify,
 };
 
-static struct platform_device tegra_enterprise_backlight_device = {
+static struct platform_device enterprise_backlight_device = {
 	.name	= "pwm-backlight",
 	.id	= -1,
 	.dev	= {
-		.platform_data = &tegra_enterprise_backlight_data,
+		.platform_data = &enterprise_backlight_data,
 	},
 };
 
-static int tegra_enterprise_hdmi_enable(void)
+static int enterprise_hdmi_enable(void)
 {
 	int ret;
-	if (!tegra_enterprise_hdmi_reg) {
-		tegra_enterprise_hdmi_reg = regulator_get(NULL, "avdd_hdmi");
-		if (IS_ERR_OR_NULL(tegra_enterprise_hdmi_reg)) {
+	if (!enterprise_hdmi_reg) {
+		enterprise_hdmi_reg = regulator_get(NULL, "avdd_hdmi");
+		if (IS_ERR_OR_NULL(enterprise_hdmi_reg)) {
 			pr_err("hdmi: couldn't get regulator avdd_hdmi\n");
-			tegra_enterprise_hdmi_reg = NULL;
-			return PTR_ERR(tegra_enterprise_hdmi_reg);
+			enterprise_hdmi_reg = NULL;
+			return PTR_ERR(enterprise_hdmi_reg);
 		}
 	}
-	ret = regulator_enable(tegra_enterprise_hdmi_reg);
+	ret = regulator_enable(enterprise_hdmi_reg);
 	if (ret < 0) {
 		pr_err("hdmi: couldn't enable regulator avdd_hdmi\n");
 		return ret;
 	}
-	if (!tegra_enterprise_hdmi_pll) {
-		tegra_enterprise_hdmi_pll = regulator_get(NULL, "avdd_hdmi_pll");
-		if (IS_ERR_OR_NULL(tegra_enterprise_hdmi_pll)) {
+	if (!enterprise_hdmi_pll) {
+		enterprise_hdmi_pll = regulator_get(NULL, "avdd_hdmi_pll");
+		if (IS_ERR_OR_NULL(enterprise_hdmi_pll)) {
 			pr_err("hdmi: couldn't get regulator avdd_hdmi_pll\n");
-			tegra_enterprise_hdmi_pll = NULL;
-			regulator_put(tegra_enterprise_hdmi_reg);
-			tegra_enterprise_hdmi_reg = NULL;
-			return PTR_ERR(tegra_enterprise_hdmi_pll);
+			enterprise_hdmi_pll = NULL;
+			regulator_put(enterprise_hdmi_reg);
+			enterprise_hdmi_reg = NULL;
+			return PTR_ERR(enterprise_hdmi_pll);
 		}
 	}
-	ret = regulator_enable(tegra_enterprise_hdmi_pll);
+	ret = regulator_enable(enterprise_hdmi_pll);
 	if (ret < 0) {
 		pr_err("hdmi: couldn't enable regulator avdd_hdmi_pll\n");
 		return ret;
 	}
-	if (!tegra_enterprise_hdmi_vddio) {
-		tegra_enterprise_hdmi_vddio = regulator_get(NULL, "vdd_hdmi_con");
-		if (IS_ERR_OR_NULL(tegra_enterprise_hdmi_vddio)) {
+	if (!enterprise_hdmi_vddio) {
+		enterprise_hdmi_vddio = regulator_get(NULL, "vdd_hdmi_con");
+		if (IS_ERR_OR_NULL(enterprise_hdmi_vddio)) {
 			pr_err("hdmi: couldn't get regulator vdd_hdmi_con\n");
-			tegra_enterprise_hdmi_vddio = NULL;
-			regulator_put(tegra_enterprise_hdmi_pll);
-			tegra_enterprise_hdmi_pll = NULL;
-			regulator_put(tegra_enterprise_hdmi_reg);
-			tegra_enterprise_hdmi_reg = NULL;
+			enterprise_hdmi_vddio = NULL;
+			regulator_put(enterprise_hdmi_pll);
+			enterprise_hdmi_pll = NULL;
+			regulator_put(enterprise_hdmi_reg);
+			enterprise_hdmi_reg = NULL;
 
-			return PTR_ERR(tegra_enterprise_hdmi_vddio);
+			return PTR_ERR(enterprise_hdmi_vddio);
 		}
 	}
-	ret = regulator_enable(tegra_enterprise_hdmi_vddio);
+	ret = regulator_enable(enterprise_hdmi_vddio);
 	if (ret < 0) {
 		pr_err("hdmi: couldn't enable regulator vdd_hdmi_con\n");
 		return ret;
@@ -175,23 +175,23 @@ static int tegra_enterprise_hdmi_enable(void)
 	return 0;
 }
 
-static int tegra_enterprise_hdmi_disable(void)
+static int enterprise_hdmi_disable(void)
 {
 
-	regulator_disable(tegra_enterprise_hdmi_reg);
-	regulator_put(tegra_enterprise_hdmi_reg);
-	tegra_enterprise_hdmi_reg = NULL;
+	regulator_disable(enterprise_hdmi_reg);
+	regulator_put(enterprise_hdmi_reg);
+	enterprise_hdmi_reg = NULL;
 
-	regulator_disable(tegra_enterprise_hdmi_pll);
-	regulator_put(tegra_enterprise_hdmi_pll);
-	tegra_enterprise_hdmi_pll = NULL;
+	regulator_disable(enterprise_hdmi_pll);
+	regulator_put(enterprise_hdmi_pll);
+	enterprise_hdmi_pll = NULL;
 
-	regulator_disable(tegra_enterprise_hdmi_vddio);
-	regulator_put(tegra_enterprise_hdmi_vddio);
-	tegra_enterprise_hdmi_vddio = NULL;
+	regulator_disable(enterprise_hdmi_vddio);
+	regulator_put(enterprise_hdmi_vddio);
+	enterprise_hdmi_vddio = NULL;
 	return 0;
 }
-static struct resource tegra_enterprise_disp1_resources[] = {
+static struct resource enterprise_disp1_resources[] = {
 	{
 		.name	= "irq",
 		.start	= INT_DISPLAY_GENERAL,
@@ -206,8 +206,8 @@ static struct resource tegra_enterprise_disp1_resources[] = {
 	},
 	{
 		.name	= "fbmem",
-		.start	= 0,	/* Filled in by tegra_enterprise_panel_init() */
-		.end	= 0,	/* Filled in by tegra_enterprise_panel_init() */
+		.start	= 0,	/* Filled in by enterprise_panel_init() */
+		.end	= 0,	/* Filled in by enterprise_panel_init() */
 		.flags	= IORESOURCE_MEM,
 	},
 	{
@@ -218,7 +218,7 @@ static struct resource tegra_enterprise_disp1_resources[] = {
 	},
 };
 
-static struct resource tegra_enterprise_disp2_resources[] = {
+static struct resource enterprise_disp2_resources[] = {
 	{
 		.name	= "irq",
 		.start	= INT_DISPLAY_B_GENERAL,
@@ -245,7 +245,7 @@ static struct resource tegra_enterprise_disp2_resources[] = {
 	},
 };
 
-static struct tegra_dc_sd_settings tegra_enterprise_sd_settings = {
+static struct tegra_dc_sd_settings enterprise_sd_settings = {
 	.enable = 1, /* Normal mode operation */
 	.use_auto_pwm = false,
 	.hw_update_delay = 0,
@@ -277,38 +277,38 @@ static struct tegra_dc_sd_settings tegra_enterprise_sd_settings = {
 			{0, 0, 0}
 		},
 	.sd_brightness = &sd_brightness,
-	.bl_device = &tegra_enterprise_backlight_device,
+	.bl_device = &enterprise_backlight_device,
 };
 
-static struct tegra_fb_data tegra_enterprise_hdmi_fb_data = {
+static struct tegra_fb_data enterprise_hdmi_fb_data = {
 	.win		= 0,
 	.xres		= 1366,
 	.yres		= 768,
 	.bits_per_pixel	= 16,
 };
 
-static struct tegra_dc_out tegra_enterprise_disp2_out = {
+static struct tegra_dc_out enterprise_disp2_out = {
 	.type		= TEGRA_DC_OUT_HDMI,
 	.flags		= TEGRA_DC_OUT_HOTPLUG_HIGH,
 
 	.dcc_bus	= 3,
-	.hotplug_gpio	= tegra_enterprise_hdmi_hpd,
+	.hotplug_gpio	= enterprise_hdmi_hpd,
 
 	.align		= TEGRA_DC_ALIGN_MSB,
 	.order		= TEGRA_DC_ORDER_RED_BLUE,
 
-	.enable		= tegra_enterprise_hdmi_enable,
-	.disable	= tegra_enterprise_hdmi_disable,
+	.enable		= enterprise_hdmi_enable,
+	.disable	= enterprise_hdmi_disable,
 };
 
-static struct tegra_dc_platform_data tegra_enterprise_disp2_pdata = {
+static struct tegra_dc_platform_data enterprise_disp2_pdata = {
 	.flags		= 0,
-	.default_out	= &tegra_enterprise_disp2_out,
-	.fb		= &tegra_enterprise_hdmi_fb_data,
+	.default_out	= &enterprise_disp2_out,
+	.fb		= &enterprise_hdmi_fb_data,
 	.emc_clk_rate	= 300000000,
 };
 
-static int tegra_enterprise_dsi_panel_enable(void)
+static int enterprise_dsi_panel_enable(void)
 {
 	static struct regulator *reg = NULL;
 
@@ -325,7 +325,7 @@ static int tegra_enterprise_dsi_panel_enable(void)
 	return 0;
 }
 
-static int tegra_enterprise_dsi_panel_disable(void)
+static int enterprise_dsi_panel_disable(void)
 {
 	return 0;
 }
@@ -337,7 +337,7 @@ static struct tegra_dsi_cmd dsi_init_cmd[]= {
 	DSI_DLY_MS(20),
 };
 
-struct tegra_dsi_out tegra_enterprise_dsi = {
+struct tegra_dsi_out enterprise_dsi = {
 	.n_data_lanes = 2,
 	.pixel_format = TEGRA_DSI_PIXEL_FORMAT_24BIT_P,
 	.refresh_rate = 60,
@@ -351,7 +351,7 @@ struct tegra_dsi_out tegra_enterprise_dsi = {
 	.video_data_type = TEGRA_DSI_VIDEO_TYPE_COMMAND_MODE,
 };
 
-static struct tegra_dc_mode tegra_enterprise_dsi_modes[] = {
+static struct tegra_dc_mode enterprise_dsi_modes[] = {
 	{
 		.pclk = 10000000,
 		.h_ref_to_sync = 4,
@@ -368,7 +368,7 @@ static struct tegra_dc_mode tegra_enterprise_dsi_modes[] = {
 };
 
 
-static struct tegra_fb_data tegra_enterprise_dsi_fb_data = {
+static struct tegra_fb_data enterprise_dsi_fb_data = {
 	.win		= 0,
 	.xres		= 540,
 	.yres		= 960,
@@ -376,48 +376,48 @@ static struct tegra_fb_data tegra_enterprise_dsi_fb_data = {
 };
 
 
-static struct tegra_dc_out tegra_enterprise_disp1_out = {
+static struct tegra_dc_out enterprise_disp1_out = {
 	.align		= TEGRA_DC_ALIGN_MSB,
 	.order		= TEGRA_DC_ORDER_RED_BLUE,
-	.sd_settings	= &tegra_enterprise_sd_settings,
+	.sd_settings	= &enterprise_sd_settings,
 
 	.type		= TEGRA_DC_OUT_DSI,
 
-	.modes	 	= tegra_enterprise_dsi_modes,
-	.n_modes 	= ARRAY_SIZE(tegra_enterprise_dsi_modes),
+	.modes	 	= enterprise_dsi_modes,
+	.n_modes 	= ARRAY_SIZE(enterprise_dsi_modes),
 
-	.dsi		= &tegra_enterprise_dsi,
+	.dsi		= &enterprise_dsi,
 
-	.enable		= tegra_enterprise_dsi_panel_enable,
-	.disable	= tegra_enterprise_dsi_panel_disable,
+	.enable		= enterprise_dsi_panel_enable,
+	.disable	= enterprise_dsi_panel_disable,
 };
-static struct tegra_dc_platform_data tegra_enterprise_disp1_pdata = {
+static struct tegra_dc_platform_data enterprise_disp1_pdata = {
 	.flags		= TEGRA_DC_FLAG_ENABLED,
-	.default_out	= &tegra_enterprise_disp1_out,
+	.default_out	= &enterprise_disp1_out,
 	.emc_clk_rate	= 300000000,
-	.fb		= &tegra_enterprise_dsi_fb_data,
+	.fb		= &enterprise_dsi_fb_data,
 };
-static struct nvhost_device tegra_enterprise_disp1_device = {
+static struct nvhost_device enterprise_disp1_device = {
 	.name		= "tegradc",
 	.id		= 0,
-	.resource	= tegra_enterprise_disp1_resources,
-	.num_resources	= ARRAY_SIZE(tegra_enterprise_disp1_resources),
+	.resource	= enterprise_disp1_resources,
+	.num_resources	= ARRAY_SIZE(enterprise_disp1_resources),
 	.dev = {
-		.platform_data = &tegra_enterprise_disp1_pdata,
+		.platform_data = &enterprise_disp1_pdata,
 	},
 };
 
-static struct nvhost_device tegra_enterprise_disp2_device = {
+static struct nvhost_device enterprise_disp2_device = {
 	.name		= "tegradc",
 	.id		= 1,
-	.resource	= tegra_enterprise_disp2_resources,
-	.num_resources	= ARRAY_SIZE(tegra_enterprise_disp2_resources),
+	.resource	= enterprise_disp2_resources,
+	.num_resources	= ARRAY_SIZE(enterprise_disp2_resources),
 	.dev = {
-		.platform_data = &tegra_enterprise_disp2_pdata,
+		.platform_data = &enterprise_disp2_pdata,
 	},
 };
 
-static struct nvmap_platform_carveout tegra_enterprise_carveouts[] = {
+static struct nvmap_platform_carveout enterprise_carveouts[] = {
 	[0] = {
 		.name		= "iram",
 		.usage_mask	= NVMAP_HEAP_CARVEOUT_IRAM,
@@ -428,60 +428,60 @@ static struct nvmap_platform_carveout tegra_enterprise_carveouts[] = {
 	[1] = {
 		.name		= "generic-0",
 		.usage_mask	= NVMAP_HEAP_CARVEOUT_GENERIC,
-		.base		= 0,	/* Filled in by tegra_enterprise_panel_init() */
-		.size		= 0,	/* Filled in by tegra_enterprise_panel_init() */
+		.base		= 0,	/* Filled in by enterprise_panel_init() */
+		.size		= 0,	/* Filled in by enterprise_panel_init() */
 		.buddy_size	= SZ_32K,
 	},
 };
 
-static struct nvmap_platform_data tegra_enterprise_nvmap_data = {
-	.carveouts	= tegra_enterprise_carveouts,
-	.nr_carveouts	= ARRAY_SIZE(tegra_enterprise_carveouts),
+static struct nvmap_platform_data enterprise_nvmap_data = {
+	.carveouts	= enterprise_carveouts,
+	.nr_carveouts	= ARRAY_SIZE(enterprise_carveouts),
 };
 
-static struct platform_device tegra_enterprise_nvmap_device = {
+static struct platform_device enterprise_nvmap_device = {
 	.name	= "tegra-nvmap",
 	.id	= -1,
 	.dev	= {
-		.platform_data = &tegra_enterprise_nvmap_data,
+		.platform_data = &enterprise_nvmap_data,
 	},
 };
 
-static struct platform_device *tegra_enterprise_gfx_devices[] __initdata = {
-	&tegra_enterprise_nvmap_device,
+static struct platform_device *enterprise_gfx_devices[] __initdata = {
+	&enterprise_nvmap_device,
 	&tegra_grhost_device,
 	&tegra_pwfm0_device,
-	&tegra_enterprise_backlight_device,
+	&enterprise_backlight_device,
 };
 
-int __init tegra_enterprise_panel_init(void)
+int __init enterprise_panel_init(void)
 {
 	int err;
 	struct resource *res;
 
-	tegra_enterprise_carveouts[1].base = tegra_carveout_start;
-	tegra_enterprise_carveouts[1].size = tegra_carveout_size;
+	enterprise_carveouts[1].base = tegra_carveout_start;
+	enterprise_carveouts[1].size = tegra_carveout_size;
 
-	tegra_gpio_enable(tegra_enterprise_hdmi_hpd);
-	gpio_request(tegra_enterprise_hdmi_hpd, "hdmi_hpd");
-	gpio_direction_input(tegra_enterprise_hdmi_hpd);
+	tegra_gpio_enable(enterprise_hdmi_hpd);
+	gpio_request(enterprise_hdmi_hpd, "hdmi_hpd");
+	gpio_direction_input(enterprise_hdmi_hpd);
 
-	err = platform_add_devices(tegra_enterprise_gfx_devices,
-				ARRAY_SIZE(tegra_enterprise_gfx_devices));
+	err = platform_add_devices(enterprise_gfx_devices,
+				ARRAY_SIZE(enterprise_gfx_devices));
 
-	res = nvhost_get_resource_byname(&tegra_enterprise_disp1_device,
+	res = nvhost_get_resource_byname(&enterprise_disp1_device,
 					 IORESOURCE_MEM, "fbmem");
 	res->start = tegra_fb_start;
 	res->end = tegra_fb_start + tegra_fb_size - 1;
 
 	if (!err)
-		err = nvhost_device_register(&tegra_enterprise_disp1_device);
+		err = nvhost_device_register(&enterprise_disp1_device);
 
-	res = nvhost_get_resource_byname(&tegra_enterprise_disp2_device,
+	res = nvhost_get_resource_byname(&enterprise_disp2_device,
 					 IORESOURCE_MEM, "fbmem");
 	res->start = tegra_fb2_start;
 	res->end = tegra_fb2_start + tegra_fb2_size - 1;
 	if (!err)
-		err = nvhost_device_register(&tegra_enterprise_disp2_device);
+		err = nvhost_device_register(&enterprise_disp2_device);
 	return err;
 }
diff --git a/arch/arm/mach-tegra/board-enterprise-pinmux.c b/arch/arm/mach-tegra/board-enterprise-pinmux.c
index 6a0d1996346b..0e9afdd243e0 100644
--- a/arch/arm/mach-tegra/board-enterprise-pinmux.c
+++ b/arch/arm/mach-tegra/board-enterprise-pinmux.c
@@ -60,7 +60,7 @@
 	}
 
 /* !!!FIXME!!!! POPULATE THIS TABLE */
-static __initdata struct tegra_drive_pingroup_config tegra_enterprise_drive_pinmux[] = {
+static __initdata struct tegra_drive_pingroup_config enterprise_drive_pinmux[] = {
 	/* DEFAULT_DRIVE(<pin_group>), */
 	/* SET_DRIVE(ATA, DISABLE, DISABLE, DIV_1, 31, 31, FAST, FAST) */
 	SET_DRIVE(DAP2, 	DISABLE, ENABLE, DIV_1, 31, 31, FASTEST, FASTEST),
@@ -118,7 +118,7 @@ static __initdata struct tegra_drive_pingroup_config tegra_enterprise_drive_pinm
 		.ioreset	= TEGRA_PIN_IO_RESET_##_ioreset	\
 	}
 
-static __initdata struct tegra_pingroup_config tegra_enterprise_pinmux[] = {
+static __initdata struct tegra_pingroup_config enterprise_pinmux[] = {
 	/* SDMMC1 pinmux */
 	DEFAULT_PINMUX(SDMMC1_CLK,      SDMMC1,          NORMAL,    NORMAL,     INPUT),
 	DEFAULT_PINMUX(SDMMC1_CMD,      SDMMC1,          PULL_UP,    NORMAL,     INPUT),
@@ -365,10 +365,10 @@ static __initdata struct tegra_pingroup_config tegra_enterprise_pinmux[] = {
 	VI_PINMUX(VI_VSYNC,        RSVD1,           NORMAL,    NORMAL,     INPUT,  DISABLE, DISABLE),
 };
 
-int __init tegra_enterprise_pinmux_init(void)
+int __init enterprise_pinmux_init(void)
 {
-	tegra_pinmux_config_table(tegra_enterprise_pinmux, ARRAY_SIZE(tegra_enterprise_pinmux));
-	tegra_drive_pinmux_config_table(tegra_enterprise_drive_pinmux,
-					ARRAY_SIZE(tegra_enterprise_drive_pinmux));
+	tegra_pinmux_config_table(enterprise_pinmux, ARRAY_SIZE(enterprise_pinmux));
+	tegra_drive_pinmux_config_table(enterprise_drive_pinmux,
+					ARRAY_SIZE(enterprise_drive_pinmux));
 	return 0;
 }
diff --git a/arch/arm/mach-tegra/board-enterprise-sdhci.c b/arch/arm/mach-tegra/board-enterprise-sdhci.c
index 5596dbe91086..2dce79c27e93 100644
--- a/arch/arm/mach-tegra/board-enterprise-sdhci.c
+++ b/arch/arm/mach-tegra/board-enterprise-sdhci.c
@@ -31,8 +31,8 @@
 #include "board.h"
 
 
-#define TEGRA_ENTERPRISE_SD_CD TEGRA_GPIO_PI5
-#define TEGRA_ENTERPRISE_SD_WP TEGRA_GPIO_PT3
+#define ENTERPRISE_SD_CD TEGRA_GPIO_PI5
+#define ENTERPRISE_SD_WP TEGRA_GPIO_PT3
 
 static struct resource sdhci_resource0[] = {
 	[0] = {
@@ -109,19 +109,19 @@ static struct platform_device tegra_sdhci_device3 = {
 	},
 };
 
-static int tegra_enterprise_sd_cd_gpio_init(void)
+static int enterprise_sd_cd_gpio_init(void)
 {
 	unsigned int rc = 0;
 
-	rc = gpio_request(TEGRA_ENTERPRISE_SD_CD, "card_detect");
+	rc = gpio_request(ENTERPRISE_SD_CD, "card_detect");
 	if (rc) {
 		pr_err("Card detect gpio request failed:%d\n", rc);
 		return rc;
 	}
 
-	tegra_gpio_enable(TEGRA_ENTERPRISE_SD_CD);
+	tegra_gpio_enable(ENTERPRISE_SD_CD);
 
-	rc = gpio_direction_input(TEGRA_ENTERPRISE_SD_CD);
+	rc = gpio_direction_input(ENTERPRISE_SD_CD);
 	if (rc) {
 		pr_err("Unable to configure direction for card detect gpio:%d\n", rc);
 		return rc;
@@ -130,19 +130,19 @@ static int tegra_enterprise_sd_cd_gpio_init(void)
 	return 0;
 }
 
-static int tegra_enterprise_sd_wp_gpio_init(void)
+static int enterprise_sd_wp_gpio_init(void)
 {
 	unsigned int rc = 0;
 
-	rc = gpio_request(TEGRA_ENTERPRISE_SD_WP, "write_protect");
+	rc = gpio_request(ENTERPRISE_SD_WP, "write_protect");
 	if (rc) {
 		pr_err("Write protect gpio request failed:%d\n", rc);
 		return rc;
 	}
 
-	tegra_gpio_enable(TEGRA_ENTERPRISE_SD_WP);
+	tegra_gpio_enable(ENTERPRISE_SD_WP);
 
-	rc = gpio_direction_input(TEGRA_ENTERPRISE_SD_WP);
+	rc = gpio_direction_input(ENTERPRISE_SD_WP);
 	if (rc) {
 		pr_err("Unable to configure direction for write protect gpio:%d\n", rc);
 		return rc;
@@ -151,20 +151,20 @@ static int tegra_enterprise_sd_wp_gpio_init(void)
 	return 0;
 }
 
-int __init tegra_enterprise_sdhci_init(void)
+int __init enterprise_sdhci_init(void)
 {
 	unsigned int rc = 0;
 	platform_device_register(&tegra_sdhci_device3);
 
 	/* Fix ME: The gpios have to enabled for hot plug support */
-	rc = tegra_enterprise_sd_cd_gpio_init();
+	rc = enterprise_sd_cd_gpio_init();
 	if (!rc) {
-		tegra_sdhci_platform_data0.cd_gpio = TEGRA_ENTERPRISE_SD_CD;
+		tegra_sdhci_platform_data0.cd_gpio = ENTERPRISE_SD_CD;
 		tegra_sdhci_platform_data0.cd_gpio_polarity = 0;
 	}
-	rc = tegra_enterprise_sd_wp_gpio_init();
+	rc = enterprise_sd_wp_gpio_init();
 	if (!rc) {
-		tegra_sdhci_platform_data0.wp_gpio = TEGRA_ENTERPRISE_SD_WP;
+		tegra_sdhci_platform_data0.wp_gpio = ENTERPRISE_SD_WP;
 		tegra_sdhci_platform_data0.wp_gpio_polarity = 1;
 	}
 
diff --git a/arch/arm/mach-tegra/board-enterprise.c b/arch/arm/mach-tegra/board-enterprise.c
index c99e753e5f21..97a30f0a5e13 100644
--- a/arch/arm/mach-tegra/board-enterprise.c
+++ b/arch/arm/mach-tegra/board-enterprise.c
@@ -74,7 +74,7 @@ static struct platform_device debug_uart = {
 	},
 };
 
-/* !!!TODO: Change for tegra_enterprise (Taken from Cardhu) */
+/* !!!TODO: Change for enterprise (Taken from Cardhu) */
 static struct tegra_utmip_config utmi_phy_config[] = {
 	[0] = {
 			.hssync_start_delay = 0,
@@ -106,7 +106,7 @@ static struct tegra_utmip_config utmi_phy_config[] = {
 };
 
 #ifdef CONFIG_BCM4329_RFKILL
-static struct resource tegra_enterprise_bcm4329_rfkill_resources[] = {
+static struct resource enterprise_bcm4329_rfkill_resources[] = {
 	{
 		.name   = "bcm4329_nshutdown_gpio",
 		.start  = TEGRA_GPIO_PU0,
@@ -115,24 +115,24 @@ static struct resource tegra_enterprise_bcm4329_rfkill_resources[] = {
 	},
 };
 
-static struct platform_device tegra_enterprise_bcm4329_rfkill_device = {
+static struct platform_device enterprise_bcm4329_rfkill_device = {
 	.name = "bcm4329_rfkill",
 	.id             = -1,
-	.num_resources  = ARRAY_SIZE(tegra_enterprise_bcm4329_rfkill_resources),
-	.resource       = tegra_enterprise_bcm4329_rfkill_resources,
+	.num_resources  = ARRAY_SIZE(enterprise_bcm4329_rfkill_resources),
+	.resource       = enterprise_bcm4329_rfkill_resources,
 };
 
-static noinline void __init tegra_enterprise_bt_rfkill(void)
+static noinline void __init enterprise_bt_rfkill(void)
 {
-	platform_device_register(&tegra_enterprise_bcm4329_rfkill_device);
+	platform_device_register(&enterprise_bcm4329_rfkill_device);
 
 	return;
 }
 #else
-static inline void tegra_enterprise_bt_rfkill(void) { }
+static inline void enterprise_bt_rfkill(void) { }
 #endif
 
-static __initdata struct tegra_clk_init_table tegra_enterprise_clk_init_table[] = {
+static __initdata struct tegra_clk_init_table enterprise_clk_init_table[] = {
 	/* name		parent		rate		enabled */
 	{ "uarta",	"pll_p",	216000000,	true},
 	{ "uartb",	"pll_p",	216000000,	false},
@@ -142,58 +142,58 @@ static __initdata struct tegra_clk_init_table tegra_enterprise_clk_init_table[]
 	{ "pll_m",	NULL,		0,		true},
 	{ "hda",	"pll_p",	108000000,	false},
 	{ "hda2codec_2x","pll_p",	48000000,	false},
-	{ "pll_p_out4",	"pll_p",	24000000,	true },
+	{ "pll_p_out4",	"pll_p",	216000000,	true },
 	{ "pwm",	"clk_32k",	32768,		false},
 	{ "blink",	"clk_32k",	32768,		true},
-	{ "pll_a",	NULL,		56448000,	true},
-	{ "pll_a_out0",	NULL,		11289600,	true},
+	{ "pll_a",	NULL,		56448000,	false},
+	{ "pll_a_out0",	NULL,		11289600,	false},
 	{ NULL,		NULL,		0,		0},
 };
 
-static struct i2c_board_info __initdata tegra_enterprise_i2c_bus1_board_info[] = {
+static struct i2c_board_info __initdata enterprise_i2c_bus1_board_info[] = {
 	{
 		I2C_BOARD_INFO("wm8903", 0x1a),
 	},
 };
 
-static struct tegra_i2c_platform_data tegra_enterprise_i2c1_platform_data = {
+static struct tegra_i2c_platform_data enterprise_i2c1_platform_data = {
 	.adapter_nr	= 0,
 	.bus_count	= 1,
 	.bus_clk_rate	= { 100000, 0 },
 };
 
-static struct tegra_i2c_platform_data tegra_enterprise_i2c2_platform_data = {
+static struct tegra_i2c_platform_data enterprise_i2c2_platform_data = {
 	.adapter_nr	= 1,
 	.bus_count	= 1,
 	.bus_clk_rate	= { 100000, 0 },
 	.is_clkon_always = true,
 };
 
-static struct tegra_i2c_platform_data tegra_enterprise_i2c3_platform_data = {
+static struct tegra_i2c_platform_data enterprise_i2c3_platform_data = {
 	.adapter_nr	= 2,
 	.bus_count	= 1,
 	.bus_clk_rate	= { 100000, 0 },
 };
 
-static struct tegra_i2c_platform_data tegra_enterprise_i2c4_platform_data = {
+static struct tegra_i2c_platform_data enterprise_i2c4_platform_data = {
 	.adapter_nr	= 3,
 	.bus_count	= 1,
 	.bus_clk_rate	= { 100000, 0 },
 };
 
-static struct tegra_i2c_platform_data tegra_enterprise_i2c5_platform_data = {
+static struct tegra_i2c_platform_data enterprise_i2c5_platform_data = {
 	.adapter_nr	= 4,
 	.bus_count	= 1,
 	.bus_clk_rate	= { 100000, 0 },
 };
 
-static void tegra_enterprise_i2c_init(void)
+static void enterprise_i2c_init(void)
 {
-	tegra_i2c_device1.dev.platform_data = &tegra_enterprise_i2c1_platform_data;
-	tegra_i2c_device2.dev.platform_data = &tegra_enterprise_i2c2_platform_data;
-	tegra_i2c_device3.dev.platform_data = &tegra_enterprise_i2c3_platform_data;
-	tegra_i2c_device4.dev.platform_data = &tegra_enterprise_i2c4_platform_data;
-	tegra_i2c_device5.dev.platform_data = &tegra_enterprise_i2c5_platform_data;
+	tegra_i2c_device1.dev.platform_data = &enterprise_i2c1_platform_data;
+	tegra_i2c_device2.dev.platform_data = &enterprise_i2c2_platform_data;
+	tegra_i2c_device3.dev.platform_data = &enterprise_i2c3_platform_data;
+	tegra_i2c_device4.dev.platform_data = &enterprise_i2c4_platform_data;
+	tegra_i2c_device5.dev.platform_data = &enterprise_i2c5_platform_data;
 
 	platform_device_register(&tegra_i2c_device5);
 	platform_device_register(&tegra_i2c_device4);
@@ -227,7 +227,7 @@ static struct platform_device tegra_camera = {
 	.id = -1,
 };
 
-static struct platform_device *tegra_enterprise_devices[] __initdata = {
+static struct platform_device *enterprise_devices[] __initdata = {
 	&debug_uart,
 	&tegra_uartb_device,
 	&tegra_uartc_device,
@@ -271,19 +271,16 @@ static struct tegra_ehci_platform_data tegra_ehci_pdata[] = {
 			.phy_config = &utmi_phy_config[0],
 			.operating_mode = TEGRA_USB_HOST,
 			.power_down_on_bus_suspend = 1,
-			.usb_phy_type = TEGRA_USB_PHY_TYPE_UTMIP,
 	},
 	[1] = {
 			.phy_config = &utmi_phy_config[1],
 			.operating_mode = TEGRA_USB_HOST,
 			.power_down_on_bus_suspend = 1,
-			.usb_phy_type = TEGRA_USB_PHY_TYPE_UTMIP,
 	},
 	[2] = {
 			.phy_config = &utmi_phy_config[2],
 			.operating_mode = TEGRA_USB_HOST,
 			.power_down_on_bus_suspend = 1,
-			.usb_phy_type = TEGRA_USB_PHY_TYPE_UTMIP,
 	},
 };
 
@@ -339,7 +336,7 @@ static struct tegra_otg_platform_data tegra_otg_pdata = {
 	.host_unregister = &tegra_usb_otg_host_unregister,
 };
 
-static void tegra_enterprise_usb_init(void)
+static void enterprise_usb_init(void)
 {
 	tegra_usb_phy_init(tegra_usb_phy_pdata, ARRAY_SIZE(tegra_usb_phy_pdata));
 
@@ -355,34 +352,34 @@ static void tegra_enterprise_usb_init(void)
 
 }
 
-static void tegra_enterprise_gps_init(void)
+static void enterprise_gps_init(void)
 {
 	tegra_gpio_enable(TEGRA_GPIO_PU2);
 	tegra_gpio_enable(TEGRA_GPIO_PU3);
 }
 
-static void tegra_enterprise_modem_init(void)
+static void enterprise_modem_init(void)
 {
 	tegra_gpio_enable(TEGRA_GPIO_PH5);
 }
 
-static void __init tegra_tegra_enterprise_init(void)
+static void __init tegra_enterprise_init(void)
 {
 	tegra_common_init();
-	tegra_clk_init_from_table(tegra_enterprise_clk_init_table);
-	tegra_enterprise_pinmux_init();
-	tegra_enterprise_i2c_init();
-	platform_add_devices(tegra_enterprise_devices, ARRAY_SIZE(tegra_enterprise_devices));
-	tegra_enterprise_sdhci_init();
-	tegra_enterprise_usb_init();
-	tegra_enterprise_gps_init();
-	tegra_enterprise_modem_init();
-	tegra_enterprise_panel_init();
-	tegra_enterprise_bt_rfkill();
-	tegra_enterprise_emc_init();
+	tegra_clk_init_from_table(enterprise_clk_init_table);
+	enterprise_pinmux_init();
+	enterprise_i2c_init();
+	platform_add_devices(enterprise_devices, ARRAY_SIZE(enterprise_devices));
+	enterprise_sdhci_init();
+	enterprise_usb_init();
+	enterprise_gps_init();
+	enterprise_modem_init();
+	enterprise_panel_init();
+	enterprise_bt_rfkill();
+	enterprise_emc_init();
 }
 
-static void __init tegra_tegra_enterprise_reserve(void)
+static void __init tegra_enterprise_reserve(void)
 {
 	tegra_reserve(SZ_128M, SZ_4M, SZ_8M);
 }
@@ -392,8 +389,8 @@ MACHINE_START(TEGRA_ENTERPRISE, "tegra_enterprise")
 	.phys_io        = IO_APB_PHYS,
 	.io_pg_offst    = ((IO_APB_VIRT) >> 18) & 0xfffc,
 	.init_irq       = tegra_init_irq,
-	.init_machine   = tegra_tegra_enterprise_init,
+	.init_machine   = tegra_enterprise_init,
 	.map_io         = tegra_map_common_io,
-	.reserve        = tegra_tegra_enterprise_reserve,
+	.reserve        = tegra_enterprise_reserve,
 	.timer          = &tegra_timer,
 MACHINE_END
diff --git a/arch/arm/mach-tegra/board-enterprise.h b/arch/arm/mach-tegra/board-enterprise.h
index f4c1bf8fbad1..09118008f731 100644
--- a/arch/arm/mach-tegra/board-enterprise.h
+++ b/arch/arm/mach-tegra/board-enterprise.h
@@ -24,12 +24,12 @@
 #include <mach/gpio.h>
 #include <mach/irqs.h>
 
-int tegra_enterprise_charge_init(void);
-int tegra_enterprise_sdhci_init(void);
-int tegra_enterprise_pinmux_init(void);
-int tegra_enterprise_panel_init(void);
+int enterprise_charge_init(void);
+int enterprise_sdhci_init(void);
+int enterprise_pinmux_init(void);
+int enterprise_panel_init(void);
 int touch_init(void);
-int tegra_enterprise_emc_init(void);
+int enterprise_emc_init(void);
 
 /* Touchscreen GPIO addresses   */
 #ifdef CONFIG_TOUCHSCREEN_ATMEL_MT_T9