diff --git a/hal/Android.bp b/hal/Android.bp
index f7559b2..1c52dcd 100644
--- a/hal/Android.bp
+++ b/hal/Android.bp
@@ -22,6 +22,7 @@
         "libhardware",
         "android.hardware.tetheroffload.config@1.0",
         "android.hardware.tetheroffload.control@1.0",
+        "android.hardware.tetheroffload.control@1.1",
     ],
     export_include_dirs: ["inc"],
     vendor: true,
diff --git a/hal/inc/CtUpdateAmbassador.h b/hal/inc/CtUpdateAmbassador.h
index d4890f3..ef4c5ee 100644
--- a/hal/inc/CtUpdateAmbassador.h
+++ b/hal/inc/CtUpdateAmbassador.h
@@ -32,13 +32,12 @@
 #include <hidl/HidlTransportSupport.h>
 
 /* HIDL Includes */
-#include <android/hardware/tetheroffload/control/1.0/ITetheringOffloadCallback.h>
+#include <android/hardware/tetheroffload/control/1.1/ITetheringOffloadCallback.h>
 
 /* Internal Includes */
 #include "IOffloadManager.h"
 
 /* Namespace pollution avoidance */
-using ::android::hardware::tetheroffload::control::V1_0::ITetheringOffloadCallback;
 using ::android::hardware::tetheroffload::control::V1_0::NetworkProtocol;
 using HALIpAddrPortPair = ::android::hardware::tetheroffload::control::V1_0::IPv4AddrPortPair;
 using HALNatTimeoutUpdate = ::android::hardware::tetheroffload::control::V1_0::NatTimeoutUpdate;
@@ -50,13 +49,13 @@
 
 class CtUpdateAmbassador : public IOffloadManager::ConntrackTimeoutUpdater {
 public:
-    CtUpdateAmbassador(const ::android::sp<ITetheringOffloadCallback>& /* cb */);
+    CtUpdateAmbassador(const ::android::sp<::android::hardware::tetheroffload::control::V1_0::ITetheringOffloadCallback>& /* cb */);
     /* ------------------- CONNTRACK TIMEOUT UPDATER ------------------------ */
     void updateTimeout(IpaNatTimeoutUpdate /* update */);
 private:
     static bool translate(IpaNatTimeoutUpdate /* in */, HALNatTimeoutUpdate& /* out */);
     static bool translate(IpaIpAddrPortPair /* in */, HALIpAddrPortPair& /* out */);
     static bool L4ToNetwork(IpaL4Protocol /* in */, NetworkProtocol& /* out */);
-    const ::android::sp<ITetheringOffloadCallback>& mFramework;
+    const ::android::sp<::android::hardware::tetheroffload::control::V1_0::ITetheringOffloadCallback>& mFramework;
 }; /* CtUpdateAmbassador */
 #endif /* _CT_UPDATE_AMBASSADOR_H_ */
\ No newline at end of file
diff --git a/hal/inc/HAL.h b/hal/inc/HAL.h
index 92ec135..cbabb1b 100644
--- a/hal/inc/HAL.h
+++ b/hal/inc/HAL.h
@@ -31,7 +31,7 @@
 
 /* HIDL Includes */
 #include <android/hardware/tetheroffload/config/1.0/IOffloadConfig.h>
-#include <android/hardware/tetheroffload/control/1.0/IOffloadControl.h>
+#include <android/hardware/tetheroffload/control/1.1/IOffloadControl.h>
 #include <hidl/HidlTransportSupport.h>
 
 /* External Includes */
@@ -59,10 +59,11 @@
 using ::std::string;
 using ::std::vector;
 
+using namespace android::hardware::tetheroffload::control;
+using ::android::sp;
 using ::android::hardware::tetheroffload::config::V1_0::IOffloadConfig;
-using ::android::hardware::tetheroffload::control::V1_0::IOffloadControl;
-
-using ::android::hardware::tetheroffload::control::V1_0::ITetheringOffloadCallback;
+using ::android::hardware::tetheroffload::control::V1_1::IOffloadControl;
+using ::android::hardware::tetheroffload::control::V1_1::ITetheringOffloadCallback;
 
 #define KERNEL_PAGE 4096
 
@@ -131,9 +132,9 @@
             const hidl_handle& /* fd2 */,
             setHandles_cb /* hidl_cb */);
 
-    /* IOffloadControl */
+    /* IOffloadControl 1.0 */
     Return<void> initOffload(
-            const ::android::sp<ITetheringOffloadCallback>& /* cb */,
+            const ::android::sp<::android::hardware::tetheroffload::control::V1_0::ITetheringOffloadCallback>& /* cb */,
             initOffload_cb /* hidl_cb */);
     Return<void> stopOffload(
             stopOffload_cb /* hidl_cb */);
@@ -161,6 +162,12 @@
             const hidl_string& /* iface */,
             const hidl_string& /* prefix */,
             removeDownstream_cb /* hidl_cb */);
+    /* IOffloadControl 1.1 */
+    Return<void> setDataWarningAndLimit(
+            const hidl_string& /* upstream */,
+            uint64_t /* warningBytes */,
+            uint64_t /* limitBytes */,
+            setDataWarningAndLimit_cb /* hidl_cb */);
 
 private:
     typedef struct BoolResult {
@@ -193,7 +200,8 @@
     hidl_handle mHandle1;
     hidl_handle mHandle2;
     LocalLogBuffer mLogs;
-    ::android::sp<ITetheringOffloadCallback> mCb;
+    android::sp<V1_0::ITetheringOffloadCallback> mCb;
+    android::sp<V1_1::ITetheringOffloadCallback> mCb_1_1;
     IpaEventRelay *mCbIpa;
     CtUpdateAmbassador *mCbCt;
 }; /* HAL */
diff --git a/hal/inc/IOffloadManager.h b/hal/inc/IOffloadManager.h
index 6a357b3..14edffd 100644
--- a/hal/inc/IOffloadManager.h
+++ b/hal/inc/IOffloadManager.h
@@ -120,6 +120,12 @@
          * tether interface pairs when this callback is called.
          */
         virtual void onLimitReached(){}
+        /**
+         * Called when the warning set via setQuota has expired. It is expected
+         * that limit has not been reached yet.
+         *
+         */
+        virtual void onWarningReached(){}
     }; /* IpaEventListener */
 
     /**
@@ -327,6 +333,34 @@
      */
     virtual RET setQuota(const char* /* upstream */, uint64_t /* limit */) = 0;
     /**
+     * This api replaces setQuota.
+     *
+     * Instruct hardware to stop forwarding traffic and send a callback after
+     * warning/limit bytes have been transferred in either direction on this upstream
+     * interface.
+     *
+     * Note that when one of the quota bytes is reached, the other one is still considered valid
+     * unless this method is called again with the same interface.
+     *
+     * @param upstream Upstream interface name that the limit should apply to
+     * @param warningBytes The quota of warning, defined as the number of bytes, starting from
+     *                     zero and counting from now.
+     * @param limitBytes The quota of limit, defined as the number of bytes, starting from zero
+     *                   and counting from now.
+     *
+     * @return SUCCESS If the limit was successfully applied
+     *         SUCCESS_OPTIMIZED If the limit was sufficiently high to be
+     *                           interpreted as "no quota".
+     *         FAIL_HARDWARE If the limit was rejected by the hardware
+     *         FAIL_UNSUPPORTED If metering is not supported on this interface
+     *         FAIL_TRY_AGAIN If this upstream has not been previously
+     *                        configured to allow offload
+     *                        (via setUpstreamParameters)
+     */
+    virtual RET setQuotaWarning(const char* /* upstream */,
+            uint64_t /* warningBytes */,
+            uint64_t /* limitBytes */) = 0;
+    /**
      * Query for statistics counters in hardware.
      *
      * This returns an aggregate of all hardware accelerated traffic which
diff --git a/hal/inc/IpaEventRelay.h b/hal/inc/IpaEventRelay.h
index 4541510..a426b79 100644
--- a/hal/inc/IpaEventRelay.h
+++ b/hal/inc/IpaEventRelay.h
@@ -32,24 +32,32 @@
 #include <hidl/HidlTransportSupport.h>
 
 /* HIDL Includes */
-#include <android/hardware/tetheroffload/control/1.0/ITetheringOffloadCallback.h>
+#include <android/hardware/tetheroffload/control/1.1/ITetheringOffloadCallback.h>
 
 /* Internal Includes */
 #include "IOffloadManager.h"
 
 /* Namespace pollution avoidance */
-using ::android::hardware::tetheroffload::control::V1_0::ITetheringOffloadCallback;
-
+using namespace android::hardware::tetheroffload::control;
+using ::android::hardware::tetheroffload::control::V1_1::OffloadCallbackEvent;
 
 class IpaEventRelay : public IOffloadManager::IpaEventListener {
 public:
-    IpaEventRelay(const ::android::sp<ITetheringOffloadCallback>& /* cb */);
+    IpaEventRelay(const ::android::sp<V1_0::ITetheringOffloadCallback>& /* 1.0 cb */,
+                  const ::android::sp<V1_1::ITetheringOffloadCallback>& /* 1.1 cb */);
     /* ----------------------- IPA EVENT LISTENER --------------------------- */
     void onOffloadStarted();
     void onOffloadStopped(StoppedReason /* reason */);
     void onOffloadSupportAvailable();
     void onLimitReached();
+    void onWarningReached();
 private:
-    const ::android::sp<ITetheringOffloadCallback>& mFramework;
+    const ::android::sp<V1_0::ITetheringOffloadCallback>& mFramework;
+    const ::android::sp<V1_1::ITetheringOffloadCallback>& mFramework_1_1;
+
+    static const int V1_0 = 0;
+    static const int V1_1 = 1;
+
+    void sendEvent(OffloadCallbackEvent, int /* version */);
 }; /* IpaEventRelay */
 #endif /* _IPA_EVENT_RELAY_H_ */
\ No newline at end of file
diff --git a/hal/src/CtUpdateAmbassador.cpp b/hal/src/CtUpdateAmbassador.cpp
index eba6b93..2ae10f8 100644
--- a/hal/src/CtUpdateAmbassador.cpp
+++ b/hal/src/CtUpdateAmbassador.cpp
@@ -36,7 +36,7 @@
 #include <cutils/log.h>
 
 /* HIDL Includes */
-#include <android/hardware/tetheroffload/control/1.0/ITetheringOffloadCallback.h>
+#include <android/hardware/tetheroffload/control/1.1/ITetheringOffloadCallback.h>
 
 /* Internal Includes */
 #include "CtUpdateAmbassador.h"
diff --git a/hal/src/HAL.cpp b/hal/src/HAL.cpp
index f18767a..a0f3120 100644
--- a/hal/src/HAL.cpp
+++ b/hal/src/HAL.cpp
@@ -60,7 +60,6 @@
 using ::std::map;
 using ::std::vector;
 
-
 /* ------------------------------ PUBLIC ------------------------------------ */
 Return<::android::sp<HAL>> HAL::makeIPAHAL(int version, IOffloadManager* mgr) {
     android::hardware::ProcessState::initWithMmapSize((size_t)(2 * KERNEL_PAGE));
@@ -82,6 +81,7 @@
 HAL::HAL(IOffloadManager* mgr) : mLogs("HAL Function Calls", 50) {
     mIPA = mgr;
     mCb.clear();
+    mCb_1_1.clear();
     mCbIpa = nullptr;
     mCbCt = nullptr;
 } /* HAL */
@@ -180,7 +180,7 @@
 void HAL::registerIpaCb() {
     if (isInitialized() && mCbIpa == nullptr) {
         LocalLogBuffer::FunctionLog fl("registerEventListener");
-        mCbIpa = new IpaEventRelay(mCb);
+        mCbIpa = new IpaEventRelay(mCb, mCb_1_1);
         mIPA->registerEventListener(mCbIpa);
         mLogs.addLog(fl);
     } else {
@@ -193,6 +193,8 @@
 void HAL::registerCtCb() {
     if (isInitialized() && mCbCt == nullptr) {
         LocalLogBuffer::FunctionLog fl("registerCtTimeoutUpdater");
+        // We can allways use the 1.0 callback here since it is always guarenteed to
+        // be non-nullptr if any version is created.
         mCbCt = new CtUpdateAmbassador(mCb);
         mIPA->registerCtTimeoutUpdater(mCbCt);
         mLogs.addLog(fl);
@@ -246,6 +248,7 @@
 } /* clearHandles */
 
 bool HAL::isInitialized() {
+    // Only have to check 1.0 Callback since it will always be created.
     return mCb.get() != nullptr;
 } /* isInitialized */
 
@@ -328,7 +331,7 @@
 /* -------------------------- IOffloadControl ------------------------------- */
 Return<void> HAL::initOffload
 (
-    const ::android::sp<ITetheringOffloadCallback>& cb,
+    const ::android::sp<V1_0::ITetheringOffloadCallback>& cb,
     initOffload_cb hidl_cb
 ) {
     LocalLogBuffer::FunctionLog fl(__func__);
@@ -341,12 +344,21 @@
     } else {
         /* Should storing the CB be a function? */
         mCb = cb;
+        mCb_1_1 = V1_1::ITetheringOffloadCallback::castFrom(cb).withDefault(nullptr);
+        // As long as 1 callback version is supported we are fine.
+        if (mCb == nullptr && mCb_1_1 == nullptr) {
+            BoolResult res = makeInputCheckFailure("callbacks are nullptr");
+            hidl_cb(res.success, res.errMsg);
+            fl.setResult(res.success, res.errMsg);
+            mLogs.addLog(fl);
+        } else {
         registerEventListeners();
         BoolResult res = ipaResultToBoolResult(RET::SUCCESS);
         hidl_cb(res.success, res.errMsg);
         fl.setResult(res.success, res.errMsg);
         mLogs.addLog(fl);
     }
+    }
 
     return Void();
 } /* initOffload */
@@ -365,6 +377,7 @@
     } else {
         /* Should removing the CB be a function? */
         mCb.clear();
+        mCb_1_1.clear();
         unregisterEventListeners();
 
         RET ipaReturn = mIPA->stopAllOffload();
@@ -412,7 +425,7 @@
     memset(&res,0,sizeof(BoolResult));
 
     if (!isInitialized()) {
-        BoolResult res = makeInputCheckFailure("Not initialized");
+        res = makeInputCheckFailure("Not initialized");
     } else if(prefixesStr.size() < 1) {
         res = ipaResultToBoolResult(RET::FAIL_INPUT_CHECK);
     } else if (!parser.add(prefixesStr)) {
@@ -561,7 +574,7 @@
     PrefixParser prefixParser;
 
     if (!isInitialized()) {
-        BoolResult res = makeInputCheckFailure("Not initialized (setUpstreamParameters)");
+        BoolResult res = makeInputCheckFailure("Not initialized (addDownstream)");
         hidl_cb(res.success, res.errMsg);
         fl.setResult(res.success, res.errMsg);
     }
@@ -595,7 +608,7 @@
     PrefixParser prefixParser;
 
     if (!isInitialized()) {
-        BoolResult res = makeInputCheckFailure("Not initialized (setUpstreamParameters)");
+        BoolResult res = makeInputCheckFailure("Not initialized (removeDownstream)");
         hidl_cb(res.success, res.errMsg);
         fl.setResult(res.success, res.errMsg);
     }
@@ -615,3 +628,34 @@
     mLogs.addLog(fl);
     return Void();
 } /* removeDownstream */
+
+Return<void> HAL::setDataWarningAndLimit
+(
+    const hidl_string& upstream,
+    uint64_t warningBytes,
+    uint64_t limitBytes,
+    setDataWarningAndLimit_cb hidl_cb
+) {
+    LocalLogBuffer::FunctionLog fl(__func__);
+    fl.addArg("upstream", upstream);
+    fl.addArg("warningBytes", warningBytes);
+    fl.addArg("limitBytes", limitBytes);
+
+    // Can only be called from HAL 1.1 so no check here is needed.
+    if (!isInitialized()) {
+        BoolResult res = makeInputCheckFailure("Not initialized (setDataWarningAndLimit)");
+        hidl_cb(res.success, res.errMsg);
+        fl.setResult(res.success, res.errMsg);
+    } else {
+        RET ipaReturn = mIPA->setQuotaWarning(upstream.c_str(), limitBytes, warningBytes);
+        if(ipaReturn == RET::FAIL_TRY_AGAIN) {
+            ipaReturn = RET::SUCCESS;
+        }
+        BoolResult res = ipaResultToBoolResult(ipaReturn);
+        hidl_cb(res.success, res.errMsg);
+        fl.setResult(res.success, res.errMsg);
+    }
+
+    mLogs.addLog(fl);
+    return Void();
+} /* setDataWarningAndLimit */
diff --git a/hal/src/IpaEventRelay.cpp b/hal/src/IpaEventRelay.cpp
index 137092f..f0cbd21 100644
--- a/hal/src/IpaEventRelay.cpp
+++ b/hal/src/IpaEventRelay.cpp
@@ -29,28 +29,48 @@
 #define LOG_TAG "IPAHALService/IpaEventRelay"
 /* External Includes */
 #include <cutils/log.h>
+//#include <hidl/Status.h> //TODO: Might be easier to return Status
 
 /* HIDL Includes */
-#include <android/hardware/tetheroffload/control/1.0/ITetheringOffloadCallback.h>
+#include <android/hardware/tetheroffload/control/1.1/ITetheringOffloadCallback.h>
 
 /* Internal Includes */
 #include "IpaEventRelay.h"
 
 /* Namespace pollution avoidance */
-using ::android::hardware::tetheroffload::control::V1_0::ITetheringOffloadCallback;
-using ::android::hardware::tetheroffload::control::V1_0::OffloadCallbackEvent;
+using ::android::hardware::Return;
+// using ::android::hardware::Status;
+using ::android::hardware::tetheroffload::control::V1_1::ITetheringOffloadCallback;
 
 
 IpaEventRelay::IpaEventRelay(
-        const ::android::sp<ITetheringOffloadCallback>& cb) : mFramework(cb) {
+        const ::android::sp<V1_0::ITetheringOffloadCallback>& cb,
+        const ::android::sp<V1_1::ITetheringOffloadCallback>& cb_1_1) : mFramework(cb), mFramework_1_1(cb_1_1) {
 } /* IpaEventRelay */
 
+using OnEventVersion = std::function<Return<void>()>;
+void IpaEventRelay::sendEvent(OffloadCallbackEvent event, int version) {
+    // Events need to be sent for the version passed in and all versions defined after that.
+    // This ensures all new versions get the correct events, but vrsion where events where not
+    // defined do not.
+    std::vector<OnEventVersion> getVersion = {
+        { [&]() -> Return<void> { return mFramework->onEvent(
+            (::android::hardware::tetheroffload::control::V1_0::OffloadCallbackEvent) event); }},
+        { [&]() -> Return<void> { return mFramework_1_1->onEvent_1_1(event); }}
+    };
+
+    for (int i = version; i < getVersion.size(); i++) {
+        OnEventVersion func = getVersion[i];
+        auto ret = func();
+    if (!ret.isOk()) {
+            ALOGE("Triggering onEvent CallbackV1_%d failed.", i);
+    }
+    }
+}
+
 void IpaEventRelay::onOffloadStarted() {
     ALOGI("onOffloadStarted()");
-    auto ret = mFramework->onEvent(OffloadCallbackEvent::OFFLOAD_STARTED);
-    if (!ret.isOk()) {
-        ALOGE("Triggering OffloadStarted Callback failed.");
-    }
+    sendEvent(OffloadCallbackEvent::OFFLOAD_STARTED, V1_0);
 } /* onOffloadStarted */
 
 void IpaEventRelay::onOffloadStopped(StoppedReason reason) {
@@ -63,16 +83,10 @@
          */
     }
     else if ( reason == StoppedReason::ERROR ) {
-        auto ret = mFramework->onEvent(OffloadCallbackEvent::OFFLOAD_STOPPED_ERROR);
-        if (!ret.isOk()) {
-            ALOGE("Triggering OffloadStopped Callback failed.");
-        }
+        sendEvent(OffloadCallbackEvent::OFFLOAD_STOPPED_ERROR, V1_0);
     }
     else if ( reason == StoppedReason::UNSUPPORTED ) {
-        auto ret = mFramework->onEvent(OffloadCallbackEvent::OFFLOAD_STOPPED_UNSUPPORTED);
-        if (!ret.isOk()) {
-            ALOGE("Triggering OffloadStopped Callback failed.");
-        }
+        sendEvent(OffloadCallbackEvent::OFFLOAD_STOPPED_UNSUPPORTED, V1_0);
     }
     else {
         ALOGE("Unknown stopped reason(%d)", reason);
@@ -81,16 +95,16 @@
 
 void IpaEventRelay::onOffloadSupportAvailable() {
     ALOGI("onOffloadSupportAvailable()");
-    auto ret = mFramework->onEvent(OffloadCallbackEvent::OFFLOAD_SUPPORT_AVAILABLE);
-    if (!ret.isOk()) {
-        ALOGE("Triggering OffloadSupportAvailable Callback failed.");
-    }
+    sendEvent(OffloadCallbackEvent::OFFLOAD_SUPPORT_AVAILABLE, V1_0);
 } /* onOffloadSupportAvailable */
 
 void IpaEventRelay::onLimitReached() {
     ALOGI("onLimitReached()");
-    auto ret = mFramework->onEvent(OffloadCallbackEvent::OFFLOAD_STOPPED_LIMIT_REACHED);
-    if (!ret.isOk()) {
-        ALOGE("Triggering LimitReached Callback failed.");
-    }
+    sendEvent(OffloadCallbackEvent::OFFLOAD_STOPPED_LIMIT_REACHED, V1_0);
 } /* onLimitReached */
+
+/** V1_1 API's **/
+void IpaEventRelay::onWarningReached() {
+    ALOGI("onWarningReached()");
+    sendEvent(OffloadCallbackEvent::OFFLOAD_WARNING_REACHED, V1_1);
+} /* onWarningReached */