diff --git a/python/adapters/brcm_openomci_onu/brcm_openomci_onu_handler.py b/python/adapters/brcm_openomci_onu/brcm_openomci_onu_handler.py
index 94b555b..05d6730 100644
--- a/python/adapters/brcm_openomci_onu/brcm_openomci_onu_handler.py
+++ b/python/adapters/brcm_openomci_onu/brcm_openomci_onu_handler.py
@@ -43,7 +43,9 @@
 from pyvoltha.common.config.config_backend import EtcdStore
 from voltha_protos.logical_device_pb2 import LogicalPort
 from voltha_protos.common_pb2 import OperStatus, ConnectStatus, AdminState
-from voltha_protos.openflow_13_pb2 import OFPXMC_OPENFLOW_BASIC, ofp_port, OFPPS_LIVE, OFPPF_FIBER, OFPPF_1GB_FD
+from voltha_protos.device_pb2 import Port
+from voltha_protos.openflow_13_pb2 import OFPXMC_OPENFLOW_BASIC, ofp_port, OFPPS_LIVE,OFPPS_LINK_DOWN,\
+    OFPPF_FIBER, OFPPF_1GB_FD
 from voltha_protos.inter_container_pb2 import InterAdapterMessageType, \
     InterAdapterOmciMessage, PortCapability, InterAdapterTechProfileDownloadMessage, InterAdapterDeleteGemPortMessage, \
     InterAdapterDeleteTcontMessage
@@ -110,6 +112,7 @@
         self._deferred = None
 
         self._in_sync_subscription = None
+        self._port_state_subscription = None
         self._connectivity_subscription = None
         self._capabilities_subscription = None
 
@@ -196,7 +199,11 @@
 
         uni_port = self.uni_port(int(port_no))
         name = device.serial_number + '-' + str(uni_port.mac_bridge_port_num)
-        self.log.debug('ofp_port_name', port_no=port_no, name=name)
+        self.log.debug('ofp_port_name', port_no=port_no, name=name, uni_port=uni_port)
+
+        ofstate = OFPPS_LINK_DOWN
+        if uni_port.operstatus is OperStatus.ACTIVE:
+            ofstate = OFPPS_LIVE
 
         return PortCapability(
             port=LogicalPort(
@@ -204,7 +211,7 @@
                     name=name,
                     hw_addr=hw_addr,
                     config=0,
-                    state=OFPPS_LIVE,
+                    state=ofstate,
                     curr=cap,
                     advertised=cap,
                     peer=cap,
@@ -967,7 +974,7 @@
             for uni_id in self._tech_profile_download_done:
                 self._tech_profile_download_done[uni_id].clear()
 
-            self.disable_ports()
+            yield self.disable_ports(lock_ports=False)
             yield self.core_proxy.device_reason_update(self.device_id, "stopping-openomci")
             yield self.core_proxy.device_state_update(self.device_id, oper_status=OperStatus.DISCOVERED,
                                                       connect_status=ConnectStatus.UNREACHABLE)
@@ -988,7 +995,7 @@
         for uni_id in self._tech_profile_download_done:
             self._tech_profile_download_done[uni_id].clear()
 
-        self.disable_ports()
+        yield self.disable_ports(lock_ports=False)
         yield self.core_proxy.device_reason_update(self.device_id, "stopping-openomci")
 
         # TODO: im sure there is more to do here
@@ -1019,36 +1026,15 @@
 
         # TODO: create objects and populate for later omci calls
 
+    @inlineCallbacks
     def disable(self, device):
         self.log.debug('disable', device_id=device.id, serial_number=device.serial_number)
         try:
             self.log.info('sending-uni-lock-towards-device', device_id=device.id, serial_number=device.serial_number)
+            yield self.disable_ports(lock_ports=True)
+            yield self.core_proxy.device_reason_update(self.device_id, "omci-admin-lock")
+            yield self.core_proxy.device_state_update(self.device_id, oper_status=OperStatus.UNKNOWN)
 
-            @inlineCallbacks
-            def stop_anyway(reason):
-                # proceed with disable regardless if we could reach the onu. for example onu is unplugged
-                self.log.debug('stopping-openomci-statemachine')
-                reactor.callLater(0, self._onu_omci_device.stop)
-
-                # Note: The tech-profile states should not be cleared here.
-                # They will be cleared if a DELETE_TCONT_REQ was triggered from openolt-adapter
-                # as a result of all flow references for the TCONT being removed OR as a result
-                # 'update_interface' call with oper_state as "down".
-
-                # for uni_id in self._tp_service_specific_task:
-                #    self._tp_service_specific_task[uni_id].clear()
-                # for uni_id in self._tech_profile_download_done:
-                #    self._tech_profile_download_done[uni_id].clear()
-
-                self.disable_ports()
-                device.oper_status = OperStatus.UNKNOWN
-                device.reason = "omci-admin-lock"
-                yield self.core_proxy.device_update(device)
-
-            # lock all the unis
-            task = BrcmUniLockTask(self.omci_agent, self.device_id, lock=True)
-            self._deferred = self._onu_omci_device.task_runner.queue_task(task)
-            self._deferred.addCallbacks(stop_anyway, stop_anyway)
         except Exception as e:
             self.log.exception('exception-in-onu-disable', exception=e)
 
@@ -1056,13 +1042,12 @@
     def reenable(self, device):
         self.log.debug('reenable', device_id=device.id, serial_number=device.serial_number)
         try:
-            # Start up OpenOMCI state machines for this device
-            # this will ultimately resync mib and unlock unis on successful redownloading the mib
-            self.log.debug('restarting-openomci-statemachine')
-            self._subscribe_to_events()
-            yield self.core_proxy.device_reason_update(self.device_id, "restarting-openomci")
-            reactor.callLater(1, self._onu_omci_device.start, device)
-            self._heartbeat.enabled = True
+            self.log.info('sending-uni-unlock-towards-device', device_id=device.id, serial_number=device.serial_number)
+            yield self.core_proxy.device_state_update(device.id,
+                                                      oper_status=OperStatus.ACTIVE,
+                                                      connect_status=ConnectStatus.REACHABLE)
+            yield self.core_proxy.device_reason_update(self.device_id, 'onu-reenabled')
+            yield self.enable_ports()
         except Exception as e:
             self.log.exception('exception-in-onu-reenable', exception=e)
 
@@ -1077,11 +1062,7 @@
         @inlineCallbacks
         def success(_results):
             self.log.info('reboot-success', _results=_results)
-            self.disable_ports()
-            device.connect_status = ConnectStatus.UNREACHABLE
-            device.oper_status = OperStatus.DISCOVERED
-            device.reason = "rebooting"
-            yield self.core_proxy.device_update(device)
+            yield self.core_proxy.device_reason_update(self.device_id, 'rebooting')
 
         def failure(_reason):
             self.log.info('reboot-failure', _reason=_reason)
@@ -1090,18 +1071,69 @@
         self._deferred.addCallbacks(success, failure)
 
     @inlineCallbacks
-    def disable_ports(self):
+    def disable_ports(self, lock_ports=True):
         self.log.info('disable-ports', device_id=self.device_id)
 
+        self.log.info('unsubscribe-to-port-events', device_id=self.device_id)
+        bus = self._onu_omci_device.event_bus
+        bus.unsubscribe(self._port_state_subscription)
+        self._port_state_subscription = None
+
         # Disable all ports on that device
+        for port in self.uni_ports:
+            port.operstatus = OperStatus.UNKNOWN
+            self.log.info('disable-port', device_id=self.device_id, port=port)
+
+        if lock_ports is True:
+            self.log.info('locking-ports', device_id=self.device_id)
+            self.lock_ports(lock=True)
+
         yield self.core_proxy.ports_state_update(self.device_id, OperStatus.UNKNOWN)
 
     @inlineCallbacks
     def enable_ports(self):
         self.log.info('enable-ports', device_id=self.device_id)
 
-        # Enable all ports on that device
-        yield self.core_proxy.ports_state_update(self.device_id, OperStatus.ACTIVE)
+        # Listen for UNI link state alarms and set the oper_state based on that rather than assuming all UNI are up
+        self.log.info('subscribe-to-port-events', device_id=self.device_id)
+        bus = self._onu_omci_device.event_bus
+        topic = OnuDeviceEntry.event_bus_topic(self.device_id,
+                                               OnuDeviceEvents.PortEvent)
+        self._port_state_subscription = bus.subscribe(topic, self.port_state_handler)
+
+        self.log.info('unlocking-ports', device_id=self.device_id)
+        self.lock_ports(lock=False)
+
+        # TODO: Currently the only VEIP capable ONU i can test with does not send UNI link state alarms
+        #  or set operational-state per OMCI spec.  So i have know way of "knowing" if the port is up.
+        #  Given this i assume its always up for now.  Maybe a software upgrade will fix my onu...
+        for port in self.uni_ports:
+            if port.type.value == UniType.VEIP.value:
+                port.operstatus = OperStatus.ACTIVE
+                self.log.warn('force-showing-veip-link-up', device_id=self.device_id, port=port)
+                yield self.core_proxy.port_state_update(self.device_id, Port.ETHERNET_UNI, port.port_number, port.operstatus)
+
+    @inlineCallbacks
+    def port_state_handler(self, _topic, msg):
+        self.log.info("port-state-change", _topic=_topic, msg=msg)
+
+        onu_id = msg['onu_id']
+        port_no = msg['port_number']
+        serial_number = msg['serial_number']
+        port_status = msg['port_status']
+        uni_port = self.uni_port(int(port_no))
+
+        self.log.debug("port-state-parsed-message", onu_id=onu_id, port_no=port_no, serial_number=serial_number,
+                       port_status=port_status)
+
+        if port_status is True:
+            uni_port.operstatus = OperStatus.ACTIVE
+            self.log.info('link-up', device_id=self.device_id, port=uni_port)
+        else:
+            uni_port.operstatus = OperStatus.UNKNOWN
+            self.log.info('link-down', device_id=self.device_id, port=uni_port)
+
+        yield self.core_proxy.port_state_update(self.device_id, Port.ETHERNET_UNI, uni_port.port_number, uni_port.operstatus)
 
     # Called just before openomci state machine is started.  These listen for events from selected state machines,
     # most importantly, mib in sync.  Which ultimately leads to downloading the mib
@@ -1164,9 +1196,6 @@
             omci_dev = self._onu_omci_device
             config = omci_dev.configuration
 
-            # TODO: run this sooner somehow. shouldnt have to wait for mib sync to push an initial download
-            # In Sync, we can register logical ports now. Ideally this could occur on
-            # the first time we received a successful (no timeout) OMCI Rx response.
             try:
 
                 # sort the lists so we get consistent port ordering.
@@ -1236,11 +1265,11 @@
                 @inlineCallbacks
                 def success(_results):
                     self.log.info('mib-download-success', _results=_results)
-                    yield self.enable_ports()
                     yield self.core_proxy.device_state_update(device.id,
                                                               oper_status=OperStatus.ACTIVE,
                                                               connect_status=ConnectStatus.REACHABLE)
                     yield self.core_proxy.device_reason_update(self.device_id, 'initial-mib-downloaded')
+                    yield self.enable_ports()
                     self._mib_download_task = None
                     yield self.onu_active_event()
 
@@ -1250,6 +1279,10 @@
                     yield self.core_proxy.device_reason_update(self.device_id, 'initial-mib-download-failure-retrying')
                     self._deferred = reactor.callLater(_STARTUP_RETRY_WAIT, self._mib_in_sync)
 
+                # start by locking all the unis till mib sync and initial mib is downloaded
+                # this way we can capture the port down/up events when we are ready
+                self.lock_ports(lock=True)
+
                 # Download an initial mib that creates simple bridge that can pass EAP.  On success (above) finally set
                 # the device to active/reachable.   This then opens up the handler to openflow pushes from outside
                 self.log.info('downloading-initial-mib-configuration')
@@ -1330,3 +1363,15 @@
         except Exception as active_event_error:
             self.log.exception('onu-activated-event-error',
                                errmsg=active_event_error.message)
+
+    def lock_ports(self, lock=True):
+
+        def success(response):
+            self.log.debug('set-onu-ports-state', lock=lock, response=response)
+
+        def failure(response):
+            self.log.error('cannot-set-onu-ports-state', lock=lock, response=response)
+
+        task = BrcmUniLockTask(self.omci_agent, self.device_id, lock=lock)
+        self._deferred = self._onu_omci_device.task_runner.queue_task(task)
+        self._deferred.addCallbacks(success, failure)
diff --git a/python/adapters/brcm_openomci_onu/omci/brcm_mib_download_task.py b/python/adapters/brcm_openomci_onu/omci/brcm_mib_download_task.py
index 18f7fbf..eaa8ff5 100644
--- a/python/adapters/brcm_openomci_onu/omci/brcm_mib_download_task.py
+++ b/python/adapters/brcm_openomci_onu/omci/brcm_mib_download_task.py
@@ -185,14 +185,9 @@
                 yield self.perform_initial_bridge_setup()
 
                 for uni_port in self._handler.uni_ports:
-                    yield self.enable_uni(uni_port, True)
-
                     # Provision the initial bridge configuration
                     yield self.perform_uni_initial_bridge_setup(uni_port)
 
-                    # And re-enable the UNIs if needed
-                    yield self.enable_uni(uni_port, False)
-
                 self.deferred.callback('initial-download-success')
 
             except TimeoutError as e:
@@ -318,51 +313,3 @@
             raise
 
         returnValue(None)
-
-    @inlineCallbacks
-    def enable_uni(self, uni_port, force_lock):
-        """
-        Lock or unlock a single uni port
-
-        :param uni_port: UniPort to admin up/down
-        :param force_lock: (boolean) If True, force lock regardless of enabled state
-        """
-        self.log.debug('function-entry')
-
-        omci_cc = self._onu_device.omci_cc
-        frame = None
-
-        ################################################################################
-        #  Lock/Unlock UNI  -  0 to Unlock, 1 to lock
-        #
-        #  EntityID is referenced by:
-        #            - MAC bridge port configuration data for the UNI side
-        #  References:
-        #            - Nothing
-        try:
-            state = 1 if force_lock or not uni_port.enabled else 0
-            msg = None
-            if uni_port.type.value == UniType.PPTP.value:
-                msg = PptpEthernetUniFrame(uni_port.entity_id,
-                                           attributes=dict(administrative_state=state))
-            elif uni_port.type.value == UniType.VEIP.value:
-                msg = VeipUniFrame(uni_port.entity_id,
-                                   attributes=dict(administrative_state=state))
-            else:
-                self.log.warn('unknown-uni-type', uni_port=uni_port)
-
-            if msg:
-               frame = msg.set()
-               self.log.debug('openomci-msg', omci_msg=msg)
-               results = yield omci_cc.send(frame)
-               self.check_status_and_state(results, 'set-pptp-ethernet-uni-lock-restore')
-
-        except TimeoutError as e:
-            self.log.warn('rx-timeout', e=e)
-            raise
-
-        except Exception as e:
-            self.log.exception('omci-failure', e=e)
-            raise
-
-        returnValue(None)
diff --git a/python/adapters/brcm_openomci_onu/omci/brcm_uni_lock_task.py b/python/adapters/brcm_openomci_onu/omci/brcm_uni_lock_task.py
index 8e9a2e1..2edd43c 100644
--- a/python/adapters/brcm_openomci_onu/omci/brcm_uni_lock_task.py
+++ b/python/adapters/brcm_openomci_onu/omci/brcm_uni_lock_task.py
@@ -74,7 +74,6 @@
         super(BrcmUniLockTask, self).start()
         self._local_deferred = reactor.callLater(0, self.perform_lock)
 
-    @inlineCallbacks
     def perform_lock(self):
         """
         Perform the lock/unlock
@@ -88,53 +87,51 @@
             pptp_list = sorted(self._config.pptp_entities) if self._config.pptp_entities else []
             veip_list = sorted(self._config.veip_entities) if self._config.veip_entities else []
 
-            for entity_id in pptp_list:
-                pptp_value = self._config.pptp_entities[entity_id]
-                msg = PptpEthernetUniFrame(entity_id,
-                                           attributes=dict(administrative_state=state))
-                yield self._send_uni_lock_msg(entity_id, pptp_value, msg)
+            if self._lock is True:
+                # lock unis first, ontg must be last
+                for entity_id in pptp_list:
+                    msg = PptpEthernetUniFrame(entity_id,
+                                               attributes=dict(administrative_state=state))
+                    self._send_omci_msg(msg)
 
-            for entity_id in veip_list:
-                veip_value = self._config.veip_entities[entity_id]
-                msg = VeipUniFrame(entity_id,
-                                   attributes=dict(administrative_state=state))
-                yield self._send_uni_lock_msg(entity_id, veip_value, msg)
+                for entity_id in veip_list:
+                    msg = VeipUniFrame(entity_id,
+                                       attributes=dict(administrative_state=state))
+                    self._send_omci_msg(msg)
 
-            msg = OntGFrame(attributes={'administrative_state': state})
-            frame = msg.set()
-            self.log.debug('openomci-msg', omci_msg=msg)
-            results = yield self._device.omci_cc.send(frame)
-            self.strobe_watchdog()
-
-            status = results.fields['omci_message'].fields['success_code']
-            self.log.info('response-status', status=status)
-
-            # Success?
-            if status in (RC.Success.value, RC.InstanceExists):
-                self.log.debug('set-lock-ontg', lock=self._lock)
+                msg = OntGFrame(attributes={'administrative_state': state})
+                self._send_omci_msg(msg)
             else:
-                self.log.warn('cannot-set-lock-ontg', lock=self._lock)
+                # ontg must be unlocked first, then unis
+                msg = OntGFrame(attributes={'administrative_state': state})
+                self._send_omci_msg(msg)
 
-            self.deferred.callback(self)
+                for entity_id in pptp_list:
+                    msg = PptpEthernetUniFrame(entity_id,
+                                               attributes=dict(administrative_state=state))
+                    self._send_omci_msg(msg)
+
+                for entity_id in veip_list:
+                    msg = VeipUniFrame(entity_id,
+                                       attributes=dict(administrative_state=state))
+                    self._send_omci_msg(msg)
+
+            self.deferred.callback('setting-uni-lock-state-finished')
 
         except Exception as e:
             self.log.exception('setting-uni-lock-state', e=e)
             self.deferred.errback(failure.Failure(e))
 
     @inlineCallbacks
-    def _send_uni_lock_msg(self, entity_id, value, me_message):
+    def _send_omci_msg(self, me_message):
         frame = me_message.set()
         self.log.debug('openomci-msg', omci_msg=me_message)
         results = yield self._device.omci_cc.send(frame)
         self.strobe_watchdog()
 
         status = results.fields['omci_message'].fields['success_code']
-        self.log.info('response-status', status=status)
+        self.log.debug('response-status', status=status)
 
         # Success?
-        if status in (RC.Success.value, RC.InstanceExists):
-            self.log.debug('set-lock-uni', uni=entity_id, value=value, lock=self._lock)
-        else:
-            self.log.warn('cannot-set-lock-uni', uni=entity_id, value=value, lock=self._lock)
-
-        returnValue(None)
+        if status not in (RC.Success.value, RC.InstanceExists):
+            raise BrcmUniLockException('openomci-set-failed')
diff --git a/python/adapters/brcm_openomci_onu/uni_port.py b/python/adapters/brcm_openomci_onu/uni_port.py
index 0548458..99d42cd 100644
--- a/python/adapters/brcm_openomci_onu/uni_port.py
+++ b/python/adapters/brcm_openomci_onu/uni_port.py
@@ -51,12 +51,14 @@
         self._type = type
         self._uni_id = uni_id
 
-        self._admin_state = AdminState.ENABLED
-        self._oper_status = OperStatus.ACTIVE
+        self._admin_state = AdminState.DISABLED
+        self._oper_status = OperStatus.DISCOVERED
 
     def __str__(self):
-        return "UniPort - name: {}, port_number: {}, entity_id: {}, mac_bridge_port_num: {}, type: {}, ofp_port: {}"\
-            .format(self.name, self.port_number, self.entity_id, self._mac_bridge_port_num, self.type, self._ofp_port_no)
+        return "UniPort - name: {}, port_number: {}, admin_state: {}, oper_state: {}, entity_id: {}, " \
+               "mac_bridge_port_num: {}, type: {}, ofp_port: {}"\
+            .format(self.name, self.port_number, self.adminstate, self.operstatus, self.entity_id,
+                    self._mac_bridge_port_num, self.type, self._ofp_port_no)
 
     def __repr__(self):
         return str(self)
@@ -69,7 +71,7 @@
     def _start(self):
         self._cancel_deferred()
         self._admin_state = AdminState.ENABLED
-        self._oper_status = OperStatus.ACTIVE
+        self._oper_status = OperStatus.ACTIVATING
 
     def _stop(self):
         self._cancel_deferred()
@@ -84,6 +86,22 @@
         pass
 
     @property
+    def adminstate(self):
+        return self._admin_state
+
+    @adminstate.setter
+    def adminstate(self, value):
+        self._admin_state = value
+
+    @property
+    def operstatus(self):
+        return self._oper_status
+
+    @operstatus.setter
+    def operstatus(self, value):
+        self._oper_status = value
+
+    @property
     def name(self):
         return self._name
 
diff --git a/python/requirements.txt b/python/requirements.txt
index 1a0c30a..e67e469 100644
--- a/python/requirements.txt
+++ b/python/requirements.txt
@@ -1,2 +1,2 @@
 voltha-protos==2.1.2
-pyvoltha==2.3.5
+pyvoltha==2.3.6