diff --git a/core/net/src/main/java/org/onosproject/net/meter/impl/MeterDriverProvider.java b/core/net/src/main/java/org/onosproject/net/meter/impl/MeterDriverProvider.java
new file mode 100644
index 0000000..e6151b0
--- /dev/null
+++ b/core/net/src/main/java/org/onosproject/net/meter/impl/MeterDriverProvider.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2017-present Open Networking Foundation
+ *
+ * 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.
+ */
+
+package org.onosproject.net.meter.impl;
+
+import com.google.common.collect.Sets;
+import org.onosproject.mastership.MastershipService;
+import org.onosproject.net.Device;
+import org.onosproject.net.DeviceId;
+import org.onosproject.net.device.DeviceEvent;
+import org.onosproject.net.device.DeviceListener;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.meter.Meter;
+import org.onosproject.net.meter.MeterOperation;
+import org.onosproject.net.meter.MeterOperations;
+import org.onosproject.net.meter.MeterProgrammable;
+import org.onosproject.net.meter.MeterProvider;
+
+import org.onosproject.net.meter.MeterProviderService;
+import org.onosproject.net.provider.AbstractProvider;
+import org.onosproject.net.provider.ProviderId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import static java.util.concurrent.Executors.newSingleThreadScheduledExecutor;
+import static org.onlab.util.Tools.groupedThreads;
+import static org.onosproject.net.device.DeviceEvent.Type.DEVICE_ADDED;
+import static org.onosproject.net.device.DeviceEvent.Type.DEVICE_AVAILABILITY_CHANGED;
+
+/**
+ * Driver-based Meter provider.
+ */
+public class MeterDriverProvider extends AbstractProvider implements MeterProvider {
+
+    private final Logger log = LoggerFactory.getLogger(getClass());
+
+    // To be extracted for reuse as we deal with other.
+    private static final String SCHEME = "default";
+    private static final String PROVIDER_NAME = "org.onosproject.provider.meter";
+
+    // potentially positive device event
+    private static final Set<DeviceEvent.Type> POSITIVE_DEVICE_EVENT =
+            Sets.immutableEnumSet(DEVICE_ADDED,
+                    DEVICE_AVAILABILITY_CHANGED);
+
+    protected DeviceService deviceService;
+    protected MastershipService mastershipService;
+    MeterProviderService meterProviderService;
+    int pollFrequency;
+
+    private InternalDeviceListener deviceListener = new InternalDeviceListener();
+    private ScheduledExecutorService executor
+            = newSingleThreadScheduledExecutor(groupedThreads("MeterDriverProvider", "%d", log));
+    private ScheduledFuture<?> poller = null;
+
+    public MeterDriverProvider() {
+        super(new ProviderId(SCHEME, PROVIDER_NAME));
+    }
+
+    /**
+     * Initializes the provider with the necessary device service, meter provider service,
+     * mastership service and poll frequency.
+     *
+     * @param deviceService        device service
+     * @param meterProviderService meter provider service
+     * @param mastershipService    mastership service
+     * @param pollFrequency        meter entry poll frequency
+     */
+    void init(DeviceService deviceService, MeterProviderService meterProviderService,
+              MastershipService mastershipService, int pollFrequency) {
+        this.deviceService = deviceService;
+        this.meterProviderService = meterProviderService;
+        this.mastershipService = mastershipService;
+        this.pollFrequency = pollFrequency;
+
+        deviceService.addListener(deviceListener);
+
+        if (poller != null && !poller.isCancelled()) {
+            poller.cancel(false);
+        }
+
+        poller = executor.scheduleAtFixedRate(this::pollMeters, pollFrequency,
+                pollFrequency, TimeUnit.SECONDS);
+
+    }
+
+    void terminate() {
+        deviceService.removeListener(deviceListener);
+        deviceService = null;
+        meterProviderService = null;
+        mastershipService = null;
+        poller.cancel(true);
+        executor.shutdown();
+    }
+
+    private void pollMeters() {
+        deviceService.getAvailableDevices().forEach(device -> {
+            if (mastershipService.isLocalMaster(device.id()) &&
+                    device.is(MeterProgrammable.class)) {
+                pollDeviceMeters(device.id());
+            }
+        });
+    }
+
+    @Override
+    public void performMeterOperation(DeviceId deviceId, MeterOperations meterOps) {
+        meterOps.operations().forEach(meterOperation -> performMeterOperation(deviceId, meterOperation));
+    }
+
+    @Override
+    public void performMeterOperation(DeviceId deviceId, MeterOperation meterOp) {
+        MeterProgrammable programmable = getMeterProgrammable(deviceId);
+        if (programmable != null) {
+            programmable.performMeterOperation(meterOp);
+        }
+    }
+
+    private void pollDeviceMeters(DeviceId deviceId) {
+        Collection<Meter> meters = null;
+        try {
+            meters = getMeterProgrammable(deviceId).getMeters().get(pollFrequency, TimeUnit.SECONDS);
+        } catch (InterruptedException | ExecutionException | TimeoutException e) {
+            log.warn("Unable to get the Meters from {}, error: {}", deviceId, e.getMessage());
+            log.debug("Exception: ", e);
+        }
+        meterProviderService.pushMeterMetrics(deviceId, meters);
+    }
+
+    private MeterProgrammable getMeterProgrammable(DeviceId deviceId) {
+        Device device = deviceService.getDevice(deviceId);
+        if (device.is(MeterProgrammable.class)) {
+            return device.as(MeterProgrammable.class);
+        } else {
+            log.debug("Device {} is not meter programmable", deviceId);
+            return null;
+        }
+    }
+
+    private class InternalDeviceListener implements DeviceListener {
+
+        @Override
+        public void event(DeviceEvent event) {
+            executor.execute(() -> handleEvent(event));
+        }
+
+        @Override
+        public boolean isRelevant(DeviceEvent event) {
+            Device device = event.subject();
+            return POSITIVE_DEVICE_EVENT.contains(event.type()) &&
+                    device.is(MeterProgrammable.class);
+        }
+
+        private void handleEvent(DeviceEvent event) {
+            Device device = event.subject();
+            boolean isRelevant = mastershipService.isLocalMaster(device.id()) &&
+                    deviceService.isAvailable(device.id());
+
+            if (isRelevant) {
+                pollDeviceMeters(device.id());
+            }
+        }
+    }
+}
diff --git a/core/net/src/main/java/org/onosproject/net/meter/impl/MeterManager.java b/core/net/src/main/java/org/onosproject/net/meter/impl/MeterManager.java
index 0d7ab42..2bd9746 100644
--- a/core/net/src/main/java/org/onosproject/net/meter/impl/MeterManager.java
+++ b/core/net/src/main/java/org/onosproject/net/meter/impl/MeterManager.java
@@ -18,12 +18,17 @@
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Component;
 import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Modified;
 import org.apache.felix.scr.annotations.Property;
 import org.apache.felix.scr.annotations.Reference;
 import org.apache.felix.scr.annotations.ReferenceCardinality;
 import org.apache.felix.scr.annotations.Service;
 import org.onlab.util.TriConsumer;
+import org.onosproject.cfg.ComponentConfigService;
+import org.onosproject.mastership.MastershipService;
 import org.onosproject.net.DeviceId;
+import org.onosproject.net.device.DeviceService;
+import org.onosproject.net.driver.DriverService;
 import org.onosproject.net.meter.DefaultMeter;
 import org.onosproject.net.meter.Meter;
 import org.onosproject.net.meter.MeterEvent;
@@ -44,15 +49,19 @@
 import org.onosproject.net.meter.MeterStoreResult;
 import org.onosproject.net.provider.AbstractListenerProviderRegistry;
 import org.onosproject.net.provider.AbstractProviderService;
+import org.osgi.service.component.ComponentContext;
 import org.slf4j.Logger;
 
 import java.util.Collection;
+import java.util.Dictionary;
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.stream.Collectors;
 
 import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Strings.isNullOrEmpty;
 import static java.util.concurrent.Executors.newFixedThreadPool;
+import static org.onlab.util.Tools.get;
 import static org.onlab.util.Tools.groupedThreads;
 import static org.slf4j.LoggerFactory.getLogger;
 
@@ -81,13 +90,33 @@
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     private MeterStore store;
 
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected DriverService driverService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected DeviceService deviceService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected ComponentConfigService cfgService;
+
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected MastershipService mastershipService;
+
+    private static final int DEFAULT_POLL_FREQUENCY = 30;
+    @Property(name = "fallbackMeterPollFrequency", intValue = DEFAULT_POLL_FREQUENCY,
+            label = "Frequency (in seconds) for polling meters via fallback provider")
+    private int fallbackMeterPollFrequency = DEFAULT_POLL_FREQUENCY;
+
     private TriConsumer<MeterRequest, MeterStoreResult, Throwable> onComplete;
 
     private ExecutorService executorService;
 
+    private final MeterDriverProvider defaultProvider = new MeterDriverProvider();
+
     @Activate
-    public void activate() {
+    public void activate(ComponentContext context) {
         store.setDelegate(delegate);
+        cfgService.registerProperties(getClass());
         eventDispatcher.addSink(MeterEvent.class, listenerRegistry);
 
         onComplete = (request, result, error) -> {
@@ -107,17 +136,50 @@
 
         executorService = newFixedThreadPool(numThreads,
                 groupedThreads(GROUP_THREAD_NAME, WORKER_PATTERN, log));
+        modified(context);
         log.info("Started");
     }
 
+    @Modified
+    public void modified(ComponentContext context) {
+        if (context != null) {
+            readComponentConfiguration(context);
+        }
+        defaultProvider.init(deviceService, createProviderService(defaultProvider),
+                mastershipService, fallbackMeterPollFrequency);
+    }
+
     @Deactivate
     public void deactivate() {
+        defaultProvider.terminate();
         store.unsetDelegate(delegate);
         eventDispatcher.removeSink(MeterEvent.class);
+        cfgService.unregisterProperties(getClass(), false);
         executorService.shutdown();
         log.info("Stopped");
     }
 
+    /**
+     * Extracts properties from the component configuration context.
+     *
+     * @param context the component context
+     */
+    private void readComponentConfiguration(ComponentContext context) {
+        Dictionary<?, ?> properties = context.getProperties();
+
+        String s = get(properties, "fallbackMeterPollFrequency");
+        try {
+            fallbackMeterPollFrequency = isNullOrEmpty(s) ? DEFAULT_POLL_FREQUENCY : Integer.parseInt(s);
+        } catch (NumberFormatException e) {
+            fallbackMeterPollFrequency = DEFAULT_POLL_FREQUENCY;
+        }
+    }
+
+    @Override
+    protected MeterProvider defaultProvider() {
+        return defaultProvider;
+    }
+
     @Override
     protected MeterProviderService createProviderService(MeterProvider provider) {
         return new InternalMeterProviderService(provider);