diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/btn_code_lock_default.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/btn_code_lock_default.png
new file mode 100644
index 0000000..149da9b
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/btn_code_lock_default.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/btn_code_lock_touched.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/btn_code_lock_touched.png
new file mode 100644
index 0000000..ad9a313
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/btn_code_lock_touched.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/expander_ic_maximized.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/expander_ic_maximized.9.png
new file mode 100644
index 0000000..732a6f5
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/expander_ic_maximized.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/expander_ic_minimized.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/expander_ic_minimized.9.png
new file mode 100644
index 0000000..054e3a4
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/expander_ic_minimized.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/indicator_code_lock_point_area_default.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/indicator_code_lock_point_area_default.png
new file mode 100644
index 0000000..5b77b9f
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/indicator_code_lock_point_area_default.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/indicator_code_lock_point_area_green.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/indicator_code_lock_point_area_green.png
new file mode 100644
index 0000000..c7c0b9a
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/indicator_code_lock_point_area_green.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/indicator_code_lock_point_area_red.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/indicator_code_lock_point_area_red.png
new file mode 100644
index 0000000..ac02dc4
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/indicator_code_lock_point_area_red.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_disabled.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_disabled.9.png
new file mode 100644
index 0000000..a4c2aba
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_disabled.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_disabled_focused.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_disabled_focused.9.png
new file mode 100644
index 0000000..fdbc9d5
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_disabled_focused.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_normal.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_normal.9.png
new file mode 100644
index 0000000..c7e8018
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_normal.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_pressed.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_pressed.9.png
new file mode 100644
index 0000000..4dd82ae
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_pressed.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_selected.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_selected.9.png
new file mode 100644
index 0000000..ebb701e
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_down_selected.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_disabled.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_disabled.9.png
new file mode 100644
index 0000000..39cc3d4
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_disabled.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_normal.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_normal.9.png
new file mode 100644
index 0000000..6ffabe6
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_normal.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_pressed.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_pressed.9.png
new file mode 100644
index 0000000..9cfaaab
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_pressed.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_selected.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_selected.9.png
new file mode 100644
index 0000000..e819e9b
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_input_selected.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_disabled.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_disabled.9.png
new file mode 100644
index 0000000..005a5ae
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_disabled.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_disabled_focused.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_disabled_focused.9.png
new file mode 100644
index 0000000..f1c9465
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_disabled_focused.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_normal.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_normal.9.png
new file mode 100644
index 0000000..9927539
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_normal.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_pressed.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_pressed.9.png
new file mode 100644
index 0000000..7946450
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_pressed.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_selected.9.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_selected.9.png
new file mode 100644
index 0000000..8c8136a
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/timepicker_up_selected.9.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/usb_android.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/usb_android.png
new file mode 100644
index 0000000..d7b1d93
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/usb_android.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/usb_android_connected.png b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/usb_android_connected.png
new file mode 100644
index 0000000..c9d8439
--- /dev/null
+++ b/overlay/ldpi/frameworks/base/core/res/res/drawable-mdpi/usb_android_connected.png
Binary files differ
diff --git a/overlay/ldpi/frameworks/base/core/res/res/layout/keyguard_screen_tab_unlock.xml b/overlay/ldpi/frameworks/base/core/res/res/layout/keyguard_screen_tab_unlock.xml
index beb3010..2c49fc4 100644
--- a/overlay/ldpi/frameworks/base/core/res/res/layout/keyguard_screen_tab_unlock.xml
+++ b/overlay/ldpi/frameworks/base/core/res/res/layout/keyguard_screen_tab_unlock.xml
@@ -70,7 +70,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_below="@id/carrier"
-            android:layout_marginTop="20dip"
+            android:layout_marginTop="22dip"
             android:layout_marginLeft="20dip"
             android:paddingBottom="2dip"
             >
@@ -80,7 +80,7 @@
                 android:layout_height="wrap_content"
                 android:singleLine="true"
                 android:ellipsize="none"
-                android:textSize="70sp"
+                android:textSize="68sp"
                 android:textAppearance="?android:attr/textAppearanceMedium"
                 android:shadowColor="#C0000000"
                 android:shadowDx="0"
diff --git a/overlay/ldpi/frameworks/base/core/res/res/layout/usb_storage_activity.xml b/overlay/ldpi/frameworks/base/core/res/res/layout/usb_storage_activity.xml
deleted file mode 100644
index 587b660..0000000
--- a/overlay/ldpi/frameworks/base/core/res/res/layout/usb_storage_activity.xml
+++ /dev/null
@@ -1,68 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/main"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:gravity="center"
-    android:padding="8dip"
-    >
-
-    <ImageView android:id="@+id/icon"
-        android:layout_centerHorizontal="true"
-        android:layout_alignParentTop="true"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:src="@drawable/usb_android" />
-
-    <TextView android:id="@+id/banner"
-        android:layout_centerHorizontal="true"
-        android:layout_below="@id/icon"
-        android:layout_marginTop="10dip"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:textSize="24sp"
-        android:gravity="center"
-        android:text="@string/usb_storage_title" />
-
-    <TextView android:id="@+id/message"
-        android:layout_below="@id/banner"
-        android:layout_marginTop="10dip"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:textSize="14sp"
-        android:gravity="center"
-        android:text="@string/usb_storage_message" />
-
-    <RelativeLayout
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_centerHorizontal="true"
-        android:layout_alignParentBottom="true"
-        android:layout_marginBottom="6dip"
-        >
-
-        <Button android:id="@+id/mount_button" 
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:paddingLeft="18dip"
-            android:paddingRight="18dip"
-            android:text="@string/usb_storage_button_mount"
-            />
-        <Button android:id="@+id/unmount_button"
-            android:visibility="gone"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:paddingLeft="18dip"
-            android:paddingRight="18dip"
-            android:text="@string/usb_storage_stop_button_mount"
-            />
-        <ProgressBar android:id="@+id/progress"
-            android:visibility="gone"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:indeterminate="true"
-            style="?android:attr/progressBarStyle"
-            />
-
-    </RelativeLayout>
-</RelativeLayout>
diff --git a/overlay/ldpi/frameworks/base/packages/SystemUI/res/layout/status_bar_expanded.xml b/overlay/ldpi/frameworks/base/packages/SystemUI/res/layout/status_bar_expanded.xml
index 08d9bad..85c50ba 100644
--- a/overlay/ldpi/frameworks/base/packages/SystemUI/res/layout/status_bar_expanded.xml
+++ b/overlay/ldpi/frameworks/base/packages/SystemUI/res/layout/status_bar_expanded.xml
@@ -35,7 +35,7 @@
         >
         <com.android.systemui.statusbar.powerwidget.PowerWidget android:id="@+id/exp_power_stat"
             android:layout_width="match_parent"
-            android:layout_height="42dip"
+            android:layout_height="45dip"
             />
 
         <LinearLayout
diff --git a/overlay/ldpi/packages/apps/AndroidTerm/res/values/strings.xml b/overlay/ldpi/packages/apps/AndroidTerm/res/values/strings.xml
deleted file mode 100644
index 9aad74d..0000000
--- a/overlay/ldpi/packages/apps/AndroidTerm/res/values/strings.xml
+++ /dev/null
@@ -1,84 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
--->
-<resources>
-   <string name="application_terminal">Terminal Emulator</string>
-   <string name="preferences">Preferences</string>
-   <string name="reset">Reset term</string>
-   <string name="send_email">Email to</string>
-   <string name="special_keys">Special keys</string>
-   <string name="toggle_soft_keyboard">Toggle soft keyboard</string>
-
-   <string name="edit_text">Edit text</string>
-   <string name="select_text">Select text</string>
-   <string name="copy_all">Copy all</string>
-   <string name="paste">Paste</string>
-
-   <!-- Preference dialog -->
-   <string name="screen_preferences">Screen</string>
-
-   <string name="title_statusbar_preference">Status bar</string>
-   <string name="summary_statusbar_preference">Show/hide status bar.</string>
-   <string name="dialog_title_statusbar_preference">Status bar</string>
-
-   <string name="title_cursorstyle_preference">Cursor style</string>
-   <string name="summary_cursorstyle_preference">Choose cursor style.</string>
-   <string name="dialog_title_cursorstyle_preference">Cursor style</string>
-
-   <string name="title_cursorblink_preference">Cursor blink</string>
-   <string name="summary_cursorblink_preference">Choose cursor blink.</string>
-   <string name="dialog_title_cursorblink_preference">Cursor blink</string>
-
-   <string name="text_preferences">Text</string>
-
-   <string name="title_fontsize_preference">Font size</string>
-   <string name="summary_fontsize_preference">Choose character height in points.</string>
-   <string name="dialog_title_fontsize_preference">Font size</string>
-
-   <string name="title_color_preference">Colors</string>
-   <string name="summary_color_preference">Choose text color.</string>
-   <string name="dialog_title_color_preference">Text color</string>
-
-   <string name="keyboard_preferences">Keyboard</string>
-
-   <string name="title_controlkey_preference">Control key</string>
-   <string name="summary_controlkey_preference">Choose control key.</string>
-   <string name="dialog_title_controlkey_preference">Control key</string>
-
-   <string name="title_ime_preference">Input method</string>
-   <string name="summary_ime_preference">Choose input method for soft keyboard.</string>
-   <string name="dialog_title_ime_preference">Input method</string>
-
-   <string name="shell_preferences">Shell</string>
-   <string name="title_shell_preference">Command line</string>
-   <string name="summary_shell_preference">Specify the shell command line.</string>
-   <string name="dialog_title_shell_preference">Shell</string>
-
-   <string name="title_initialcommand_preference">Initial command</string>
-   <string name="summary_initialcommand_preference">Sent to the shell when it starts.</string>
-   <string name="dialog_title_initialcommand_preference">Initial Command</string>
-
-   <!-- Don't localize these default values -->
-   <string name="default_value_statusbar_preference">0</string>
-   <string name="default_value_cursorstyle_preference">0</string>
-   <string name="default_value_cursorblink_preference">0</string>
-   <string name="default_value_fontsize_preference">12</string>
-   <string name="default_value_color_preference">1</string>
-   <string name="default_value_controlkey_preference">0</string>
-   <string name="default_value_ime_preference">0</string>
-   <string name="default_value_shell_preference">/system/bin/sh -</string>
-   <string name="default_value_initialcommand_preference">export PATH=/data/local/bin:$PATH</string>
-</resources>
diff --git a/overlay/ldpi/packages/apps/FM/res/layout/fmradio.xml b/overlay/ldpi/packages/apps/FM/res/layout/fmradio.xml
new file mode 100644
index 0000000..451a620
--- /dev/null
+++ b/overlay/ldpi/packages/apps/FM/res/layout/fmradio.xml
@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/fmradio"
+    android:background="@drawable/fmradio_background"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    >
+
+    <!-- This LinearLayout contains favorite Station Information display and the function buttons -->
+    <LinearLayout android:id="@+id/presets_layout"
+        android:background="@drawable/favorite_bg"
+        android:layout_width="match_parent"
+        android:layout_height="48dip"
+        android:orientation="horizontal"
+        android:layout_marginTop="170dip"
+        android:layout_marginLeft="14px"
+        android:layout_marginRight="13px"
+        >
+        <Button android:id="@+id/presets_button_1"
+            style="@style/favoriteButtonStyle"
+            />
+        <View
+            android:background="@drawable/favorite_line"
+            android:layout_width="2px"
+            android:layout_height="match_parent"
+            />
+        <Button android:id="@+id/presets_button_2"
+            style="@style/favoriteButtonStyle"
+            />
+        <View
+            android:background="@drawable/favorite_line"
+            android:layout_width="2px"
+            android:layout_height="match_parent"
+            />
+        <Button android:id="@+id/presets_button_3"
+            style="@style/favoriteButtonStyle"
+            />
+        <View
+            android:background="@drawable/favorite_line"
+            android:layout_width="2px"
+            android:layout_height="match_parent"
+            />
+        <Button android:id="@+id/presets_button_4"
+            style="@style/favoriteButtonStyle"
+            />
+        <View
+            android:background="@drawable/favorite_line"
+            android:layout_width="2px"
+            android:layout_height="match_parent"
+            />
+        <Button android:id="@+id/presets_button_5"
+            style="@style/favoriteButtonStyle"
+            />
+
+    </LinearLayout>
+
+    <!-- This LinearLayout contains Station Information display and the function buttons -->
+    <LinearLayout android:id="@+id/stationinfo_layout"
+        android:background="@null"
+        android:layout_width="match_parent"
+        android:layout_height="48dip"
+        android:orientation="horizontal"
+        android:layout_marginTop="5dip"
+        android:paddingLeft="10dip"
+        android:paddingRight="10dip"
+        >
+        <ImageButton android:id="@+id/btn_speaker"
+            android:src="@drawable/button_loudspeaker_off"
+            android:background="@null"
+            android:layout_marginLeft="5dip"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            />
+
+        <LinearLayout
+            android:background="@drawable/station_freq_bg"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginLeft="40dip"
+            >
+            <TextView android:id="@+id/prog_frequency_tv"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:paddingLeft="40dip"
+                android:gravity="center"
+                android:textColor="#FFC3E7AA"
+                android:textSize="30sp"
+                android:text="@string/frequency_string"
+                />
+        </LinearLayout>
+
+        <ImageButton android:id="@+id/btn_onoff"
+            android:src="@drawable/button_power_off"
+            android:background="@null"
+            android:layout_marginLeft="45dip"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            />
+
+    </LinearLayout>
+
+    <!-- This is frequency indicator: a red needle -->
+    <com.android.fm.radio.FreqIndicator
+        android:id="@+id/freq_indicator_view"
+        android:progressDrawable="@drawable/freq_indicator_seek"
+        android:thumb="@drawable/freq_indicator"
+        android:thumbOffset="0dip"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginLeft="11dip"
+        android:layout_marginRight="6dip"
+        android:layout_marginTop="5dip"
+        />
+
+    <!-- This is horizontal FM tuner -->
+    <com.android.fm.radio.TunerView
+        android:id="@+id/fm_tuner_view"
+        android:src="@drawable/tuner_view_0"
+        android:layout_width="240px"
+        android:layout_height="40px"
+        android:paddingTop="0px"
+        android:paddingBottom="23px"
+        android:paddingLeft="20px"
+        android:paddingRight="20px"
+        android:layout_marginTop="0dip"
+        android:layout_gravity="center_horizontal"
+        />
+
+</LinearLayout>
diff --git a/overlay/vega/packages/apps/ADWLauncher/res/values/config.xml b/overlay/vega/packages/apps/ADWLauncher/res/values/config.xml
new file mode 100644
index 0000000..d2606e9
--- /dev/null
+++ b/overlay/vega/packages/apps/ADWLauncher/res/values/config.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- config_desktopColumns/Rows min value is 3, so it will add 3 to whatever value you set here -->
+    <integer name="config_desktopColumns">5</integer>
+    <integer name="config_desktopRows">4</integer>
+</resources>
diff --git a/overlay/vega/packages/apps/CMParts/res/values/config.xml b/overlay/vega/packages/apps/CMParts/res/values/config.xml
new file mode 100644
index 0000000..4cab749
--- /dev/null
+++ b/overlay/vega/packages/apps/CMParts/res/values/config.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Whether or not to display the trackball settings -->
+    <bool name="has_trackball">false</bool>
+
+    <bool name="has_led_flash">false</bool>
+</resources>
diff --git a/prebuilt/common/bin/modelid_cfg.sh b/prebuilt/common/bin/modelid_cfg.sh
index b4e9252..8a94592 100644
--- a/prebuilt/common/bin/modelid_cfg.sh
+++ b/prebuilt/common/bin/modelid_cfg.sh
@@ -13,25 +13,7 @@
 kineto=/system/app/MS-HTCVISION-KNT20-02.apk
 rm_kineto=y
 
-cat /proc/cmdline|grep -q androidboot.mid=PC1010000
-if [ $? = 0 ];
-    then
-       rm_kineto=n
-fi
-
-cat /proc/cmdline|grep -q androidboot.mid=PB9910000
-if [ $? = 0 ];
-    then
-       rm_kineto=n
-fi
-
-cat /proc/cmdline|grep -q androidboot.mid=PD1510000
-if [ $? = 0 ];
-    then
-       rm_kineto=n
-fi
-
-cat /proc/cmdline|grep -q androidboot.mid=PB6510000
+cat /proc/cmdline|egrep -q '(PC1010000)|(PB9910000)|(PD1510000)|(PB6510000)'
 if [ $? = 0 ];
     then
        rm_kineto=n
@@ -55,11 +37,15 @@
 #
 # Check for spade; if NAM model update DSP and GPS config
 #
+# NAM Models:
+# DHD AT&T  MODELID PD9812000
+# DHD TELUS MODELID PD9814000
+#
 
 cat /proc/cmdline | grep -q spade
 if [ $? = 0 ];
    then 
-cat /proc/cmdline | grep -q androidboot.mid=PD9812000
+cat /proc/cmdline | egrep -q '(PD9812000)|(PD9814000)'
       if [ $? = 0 ];
          then
             mv /system/etc/nam/*MCLK.txt /system/etc/soundimage/
diff --git a/products/AndroidProducts.mk b/products/AndroidProducts.mk
index a79c70e..0c905d5 100644
--- a/products/AndroidProducts.mk
+++ b/products/AndroidProducts.mk
@@ -22,5 +22,6 @@
     $(LOCAL_DIR)/cyanogen_passion.mk \
     $(LOCAL_DIR)/cyanogen_sholes.mk \
     $(LOCAL_DIR)/cyanogen_supersonic.mk \
+    $(LOCAL_DIR)/cyanogen_vega.mk \
     $(LOCAL_DIR)/cyanogen_vision.mk \
     $(LOCAL_DIR)/cyanogen_z71.mk
diff --git a/products/cyanogen_buzz.mk b/products/cyanogen_buzz.mk
index 187249c..61032e7 100644
--- a/products/cyanogen_buzz.mk
+++ b/products/cyanogen_buzz.mk
@@ -32,6 +32,9 @@
 # Add the Torch app
 PRODUCT_PACKAGES += Torch
 
+# Broadcom FM radio
+$(call inherit-product, vendor/cyanogen/products/bcm_fm_radio.mk)
+
 # Enable Windows Media
 WITH_WINDOWS_MEDIA := true
 
diff --git a/products/cyanogen_legend.mk b/products/cyanogen_legend.mk
index 776dc48..5d16874 100644
--- a/products/cyanogen_legend.mk
+++ b/products/cyanogen_legend.mk
@@ -19,6 +19,9 @@
 
 PRODUCT_PACKAGES += Torch
 
+# TI FM radio
+$(call inherit-product, vendor/cyanogen/products/ti_fm_radio.mk)
+
 PRODUCT_PACKAGE_OVERLAYS += vendor/cyanogen/overlay/legend
 
 ifdef CYANOGEN_NIGHTLY
diff --git a/products/cyanogen_liberty.mk b/products/cyanogen_liberty.mk
index 1b7e184..9f08bdf 100644
--- a/products/cyanogen_liberty.mk
+++ b/products/cyanogen_liberty.mk
@@ -19,6 +19,8 @@
 
 PRODUCT_SPECIFIC_DEFINES += TARGET_PRELINKER_MAP=$(TOP)/vendor/cyanogen/prelink-linux-arm-msm722x.map
 
+# Broadcom FM radio
+$(call inherit-product, vendor/cyanogen/products/bcm_fm_radio.mk)
 
 ifdef CYANOGEN_NIGHTLY
     PRODUCT_PROPERTY_OVERRIDES += \
diff --git a/products/cyanogen_vega.mk b/products/cyanogen_vega.mk
new file mode 100644
index 0000000..ad81a2a
--- /dev/null
+++ b/products/cyanogen_vega.mk
@@ -0,0 +1,39 @@
+$(call inherit-product, device/advent/vega/vega.mk)
+
+# Inherit some common cyanogenmod stuff.
+$(call inherit-product, vendor/cyanogen/products/common_full.mk)
+
+#
+# Setup device specific product configuration.
+#
+PRODUCT_NAME := cyanogen_vega
+PRODUCT_BRAND := advent
+PRODUCT_DEVICE := vega
+PRODUCT_MODEL := Vega
+PRODUCT_MANUFACTURER := Advent
+PRODUCT_BUILD_PROP_OVERRIDES += PRODUCT_NAME=Vega BUILD_ID=GRI40 BUILD_DISPLAY_ID=GRI40 BUILD_FINGERPRINT=google/passion/passion:2.3.3/GRI40/102588:user/release-keys PRIVATE_BUILD_DESC="passion-user 2.3.3 GRI40 102588 release-keys"
+
+# Extra overlay
+PRODUCT_PACKAGE_OVERLAYS += vendor/cyanogen/overlay/vega
+
+#
+# Set ro.modversion
+#
+ifdef CYANOGEN_NIGHTLY
+    PRODUCT_PROPERTY_OVERRIDES += \
+        ro.modversion=CyanogenMod-7-$(shell date +%m%d%Y)-NIGHTLY-Vega
+else
+    ifdef CYANOGEN_RELEASE
+        PRODUCT_PROPERTY_OVERRIDES += \
+            ro.modversion=CyanogenMod-7.0.0-RC1-Vega
+    else
+        PRODUCT_PROPERTY_OVERRIDES += \
+            ro.modversion=CyanogenMod-7.0.0-RC1-Vega-KANG
+    endif
+endif
+
+#
+# Copy passion specific prebuilt files
+#
+PRODUCT_COPY_FILES +=  \
+    vendor/cyanogen/prebuilt/mdpi/media/bootanimation.zip:system/media/bootanimation.zip
diff --git a/products/ti_fm_radio.mk b/products/ti_fm_radio.mk
new file mode 100644
index 0000000..7f91740
--- /dev/null
+++ b/products/ti_fm_radio.mk
@@ -0,0 +1,4 @@
+# TI FM Radio
+PRODUCT_PACKAGES += \
+    FM \
+    hcitool
diff --git a/vendorsetup.sh b/vendorsetup.sh
index 5b6103f..73e4f9b 100644
--- a/vendorsetup.sh
+++ b/vendorsetup.sh
@@ -21,6 +21,7 @@
 add_lunch_combo cyanogen_passion-eng
 add_lunch_combo cyanogen_sholes-eng
 add_lunch_combo cyanogen_supersonic-eng
+add_lunch_combo cyanogen_vega-eng
 add_lunch_combo cyanogen_vision-eng
 add_lunch_combo cyanogen_z71-eng
 
