diff --git a/res/values-mcc311-mnc480/config.xml b/res/values-mcc311-mnc480/config.xml
new file mode 100644
index 0000000..7c269e0
--- /dev/null
+++ b/res/values-mcc311-mnc480/config.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2014 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.
+-->
+
+<!-- Phone app resources that may need to be customized
+     for different hardware or product builds. -->
+<resources>
+    <!-- Flag indicating if dtmf tone type is enabled -->
+    <bool name="dtmf_type_enabled">true</bool>
+</resources>
diff --git a/src/com/android/services/telephony/CdmaConnection.java b/src/com/android/services/telephony/CdmaConnection.java
index 12ccbce..cb99b55 100644
--- a/src/com/android/services/telephony/CdmaConnection.java
+++ b/src/com/android/services/telephony/CdmaConnection.java
@@ -18,13 +18,18 @@
 
 import android.os.Handler;
 import android.os.Message;
-import android.telecomm.PhoneCapabilities;
 
+import android.provider.Settings;
+import android.telecomm.PhoneCapabilities;
 import android.telephony.DisconnectCause;
 
 import com.android.internal.telephony.Call;
 import com.android.internal.telephony.CallStateException;
 import com.android.internal.telephony.Connection;
+import com.android.phone.Constants;
+
+import java.util.LinkedList;
+import java.util.Queue;
 
 /**
  * Manages a single phone call handled by CDMA.
@@ -32,6 +37,7 @@
 final class CdmaConnection extends TelephonyConnection {
 
     private static final int MSG_CALL_WAITING_MISSED = 1;
+    private static final int MSG_DTMF_SEND_CONFIRMATION = 2;
     private static final int TIMEOUT_CALL_WAITING_MILLIS = 20 * 1000;
 
     private final Handler mHandler = new Handler() {
@@ -43,6 +49,9 @@
                 case MSG_CALL_WAITING_MISSED:
                     hangupCallWaiting(DisconnectCause.INCOMING_MISSED);
                     break;
+                case MSG_DTMF_SEND_CONFIRMATION:
+                    handleBurstDtmfConfirmation();
+                    break;
                 default:
                     break;
             }
@@ -55,7 +64,11 @@
      */
     private final boolean mAllowMute;
     private final boolean mIsOutgoing;
+    // Queue of pending short-DTMF characters.
+    private final Queue<Character> mDtmfQueue = new LinkedList<>();
 
+    // Indicates that the DTMF confirmation from telephony is pending.
+    private boolean mDtmfBurstConfirmationPending = false;
     private boolean mIsCallWaiting;
 
     CdmaConnection(Connection connection, boolean allowMute, boolean isOutgoing) {
@@ -71,20 +84,21 @@
     /** {@inheritDoc} */
     @Override
     public void onPlayDtmfTone(char digit) {
-        // TODO: There are conditions where we should play dtmf tones with different
-        // timeouts.
-        // TODO: We get explicit response from the phone via a Message when the burst
-        // tone has completed. During this time we can get subsequent requests. We need to stop
-        // passing in null as the message and start handling it to implement a queue.
-        if (getPhone() != null) {
-            getPhone().sendBurstDtmf(Character.toString(digit), 0, 0, null);
+        if (useBurstDtmf()) {
+            Log.i(this, "sending dtmf digit as burst");
+            sendShortDtmfToNetwork(digit);
+        } else {
+            Log.i(this, "sending dtmf digit directly");
+            getPhone().startDtmf(digit);
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void onStopDtmfTone() {
-        // no-op, we only play timed dtmf tones for cdma.
+        if (!useBurstDtmf()) {
+            getPhone().stopDtmf();
+        }
     }
 
     @Override
@@ -168,4 +182,53 @@
             setDisconnected(disconnectCause, null);
         }
     }
+
+    /**
+     * Read the settings to determine which type of DTMF method this CDMA phone calls.
+     */
+    private boolean useBurstDtmf() {
+        int dtmfTypeSetting = Settings.System.getInt(
+                getPhone().getContext().getContentResolver(),
+                Settings.System.DTMF_TONE_TYPE_WHEN_DIALING,
+                Constants.DTMF_TONE_TYPE_NORMAL);
+        return dtmfTypeSetting == Constants.DTMF_TONE_TYPE_NORMAL;
+    }
+
+    private void sendShortDtmfToNetwork(char digit) {
+        synchronized(mDtmfQueue) {
+            if (mDtmfBurstConfirmationPending) {
+                mDtmfQueue.add(new Character(digit));
+            } else {
+                sendBurstDtmfStringLocked(Character.toString(digit));
+            }
+        }
+    }
+
+    private void sendBurstDtmfStringLocked(String dtmfString) {
+        getPhone().sendBurstDtmf(
+                dtmfString, 0, 0, mHandler.obtainMessage(MSG_DTMF_SEND_CONFIRMATION));
+        mDtmfBurstConfirmationPending = true;
+    }
+
+    private void handleBurstDtmfConfirmation() {
+        String dtmfDigits = null;
+        synchronized(mDtmfQueue) {
+            mDtmfBurstConfirmationPending = false;
+            if (!mDtmfQueue.isEmpty()) {
+                StringBuilder builder = new StringBuilder(mDtmfQueue.size());
+                while (!mDtmfQueue.isEmpty()) {
+                    builder.append(mDtmfQueue.poll());
+                }
+                dtmfDigits = builder.toString();
+
+                // It would be nice to log the digit, but since DTMF digits can be passwords
+                // to things, or other secure account numbers, we want to keep it away from
+                // the logs.
+                Log.i(this, "%d dtmf character[s] removed from the queue", dtmfDigits.length());
+            }
+            if (dtmfDigits != null) {
+                sendBurstDtmfStringLocked(dtmfDigits);
+            }
+        }
+    }
 }