diff --git a/internal/common/omci/get.go b/internal/common/omci/get.go
index a8fc6d7..1f76a0d 100644
--- a/internal/common/omci/get.go
+++ b/internal/common/omci/get.go
@@ -20,13 +20,14 @@
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"math/rand"
+	"strconv"
+
 	"github.com/google/gopacket"
 	"github.com/opencord/omci-lib-go/v2"
 	me "github.com/opencord/omci-lib-go/v2/generated"
 	"github.com/opencord/voltha-protos/v5/go/openolt"
 	log "github.com/sirupsen/logrus"
-	"math/rand"
-	"strconv"
 )
 
 func ParseGetRequest(omciPkt gopacket.Packet) (*omci.GetRequest, error) {
@@ -72,10 +73,14 @@
 			activeImageEntityId, committedImageEntityId, standbyImageVersion, activeImageVersion, committedImageVersion)
 	case me.IpHostConfigDataClassID:
 		response = createIpHostResponse(msgObj.AttributeMask, msgObj.EntityInstance)
+	case me.VoipConfigDataClassID:
+		response = createVoipConfigDataResponse(msgObj.AttributeMask, msgObj.EntityInstance)
 	case me.UniGClassID:
 		response = createUnigResponse(msgObj.AttributeMask, msgObj.EntityInstance, onuDown)
 	case me.PhysicalPathTerminationPointEthernetUniClassID:
-		response = createPptpResponse(msgObj.AttributeMask, msgObj.EntityInstance, onuDown)
+		response = createPptpEthernetResponse(msgObj.AttributeMask, msgObj.EntityInstance, onuDown)
+	case me.PhysicalPathTerminationPointPotsUniClassID:
+		response = createPptpPotsResponse(msgObj.AttributeMask, msgObj.EntityInstance, onuDown)
 	case me.AniGClassID:
 		response = createAnigResponse(msgObj.AttributeMask, msgObj.EntityInstance)
 	case me.OnuDataClassID:
@@ -281,6 +286,28 @@
 	}
 }
 
+func createVoipConfigDataResponse(attributeMask uint16, entityInstance uint16) *omci.GetResponse {
+	return &omci.GetResponse{
+		MeBasePacket: omci.MeBasePacket{
+			EntityClass:    me.VoipConfigDataClassID,
+			EntityInstance: entityInstance,
+		},
+		Attributes: me.AttributeValueMap{
+			"ManagedEntityId":                   0,
+			"AvailableSignallingProtocols":      1,
+			"SignallingProtocolUsed":            1,
+			"AvailableVoipConfigurationMethods": 1,
+			"VoipConfigurationMethodUsed":       1,
+			"VoipConfigurationAddressPointer":   0xFFFF,
+			"VoipConfigurationState":            0,
+			"RetrieveProfile":                   0,
+			"ProfileVersion":                    0,
+		},
+		Result:        me.Success,
+		AttributeMask: attributeMask,
+	}
+}
+
 func createUnigResponse(attributeMask uint16, entityID uint16, onuDown bool) *omci.GetResponse {
 	// Valid values for uni_admin_state are 0 (unlocks) and 1 (locks)
 	omciAdminState := 1
@@ -315,7 +342,7 @@
 	}
 }
 
-func createPptpResponse(attributeMask uint16, entityID uint16, onuDown bool) *omci.GetResponse {
+func createPptpEthernetResponse(attributeMask uint16, entityID uint16, onuDown bool) *omci.GetResponse {
 	// Valid values for oper_state are 0 (enabled) and 1 (disabled)
 	// Valid values for uni_admin_state are 0 (unlocks) and 1 (locks)
 	onuAdminState := 1
@@ -361,6 +388,50 @@
 	}
 }
 
+func createPptpPotsResponse(attributeMask uint16, entityID uint16, onuDown bool) *omci.GetResponse {
+	// Valid values for oper_state are 0 (enabled) and 1 (disabled)
+	// Valid values for uni_admin_state are 0 (unlocks) and 1 (locks)
+	onuAdminState := 1
+	if !onuDown {
+		onuAdminState = 0
+	}
+	onuOperState := onuAdminState // For now make the assumption that oper state reflects the admin state
+	managedEntity, meErr := me.NewPhysicalPathTerminationPointPotsUni(me.ParamData{
+		EntityID: entityID,
+		Attributes: me.AttributeValueMap{
+			"ManagedEntityId":     entityID,
+			"AdministrativeState": onuAdminState,
+			"Deprecated":          0,
+			"Arc":                 0,
+			"ArcInterval":         0,
+			"Impedance":           0,
+			"TransmissionPath":    0,
+			"RxGain":              0,
+			"TxGain":              0,
+			"OperationalState":    onuOperState,
+			"HookState":           0,
+			"PotsHoldoverTime":    0,
+			"NominalFeedVoltage":  0,
+			"LossOfSoftswitch":    0,
+		},
+	})
+
+	if meErr.GetError() != nil {
+		omciLogger.Errorf("NewPhysicalPathTerminationPointPotsUni %v", meErr.Error())
+		return nil
+	}
+
+	return &omci.GetResponse{
+		MeBasePacket: omci.MeBasePacket{
+			EntityClass:    me.PhysicalPathTerminationPointPotsUniClassID,
+			EntityInstance: entityID,
+		},
+		Attributes:    managedEntity.GetAttributeValueMap(),
+		AttributeMask: attributeMask,
+		Result:        me.Success,
+	}
+}
+
 func createEthernetFramePerformanceMonitoringHistoryDataUpstreamResponse(attributeMask uint16, entityID uint16) *omci.GetResponse {
 	managedEntity, meErr := me.NewEthernetFramePerformanceMonitoringHistoryDataUpstream(me.ParamData{
 		EntityID: entityID,
diff --git a/internal/common/omci/onu_mib_db.go b/internal/common/omci/onu_mib_db.go
index 2a41c81..79ba3a5 100644
--- a/internal/common/omci/onu_mib_db.go
+++ b/internal/common/omci/onu_mib_db.go
@@ -20,6 +20,7 @@
 	"bytes"
 	"encoding/binary"
 	"encoding/hex"
+
 	me "github.com/opencord/omci-lib-go/v2/generated"
 )
 
@@ -69,6 +70,7 @@
 	cardHolderOnuType byte = 0x01 // ONU is a single piece of integrated equipment
 	ethernetUnitType  byte = 0x2f // Ethernet BASE-T
 	xgsPonUnitType    byte = 0xee // XG-PON10G10
+	potsUnitType      byte = 0x20 // POTS
 	cardHolderSlotID  byte = 0x01
 	tcontSlotId       byte = 0x80 // why is this not the same as the cardHolderSlotID, it does not point to anything
 	aniGId            byte = 0x01
@@ -90,7 +92,7 @@
 
 // creates a MIB database for a ONU
 // CircuitPack and CardHolder are static, everything else can be configured
-func GenerateMibDatabase(uniPortCount int) (*MibDb, error) {
+func GenerateMibDatabase(ethUniPortCount int, potsUniPortCount int) (*MibDb, error) {
 
 	mibDb := MibDb{
 		items: []MibDbEntry{},
@@ -129,7 +131,7 @@
 		me.CircuitPackClassID,
 		circuitPackEntityID,
 		me.AttributeValueMap{
-			"VendorId":            "ONF",
+			"VendorId":            ToOctets("ONF", 4),
 			"AdministrativeState": 0,
 			"OperationalState":    0,
 			"BridgedOrIpInd":      0,
@@ -185,7 +187,7 @@
 		circuitPackEntityID,
 		me.AttributeValueMap{
 			"Type":          ethernetUnitType,
-			"NumberOfPorts": uniPortCount,
+			"NumberOfPorts": ethUniPortCount,
 			"SerialNumber":  ToOctets("BBSM-Circuit-Pack", 20),
 			"Version":       ToOctets("v0.0.1", 20),
 		},
@@ -194,7 +196,7 @@
 		me.CircuitPackClassID,
 		circuitPackEntityID,
 		me.AttributeValueMap{
-			"VendorId":            "ONF",
+			"VendorId":            ToOctets("ONF", 4),
 			"AdministrativeState": 0,
 			"OperationalState":    0,
 			"BridgedOrIpInd":      0,
@@ -219,33 +221,101 @@
 		},
 	})
 
+	if potsUniPortCount > 0 {
+		// circuitPack POTS
+		// NOTE the circuit pack is divided in multiple messages as too big to fit in a single one
+		mibDb.items = append(mibDb.items, MibDbEntry{
+			me.CircuitPackClassID,
+			circuitPackEntityID,
+			me.AttributeValueMap{
+				"Type":          potsUnitType,
+				"NumberOfPorts": potsUniPortCount,
+				"SerialNumber":  ToOctets("BBSM-Circuit-Pack", 20),
+				"Version":       ToOctets("v0.0.1", 20),
+			},
+		})
+		mibDb.items = append(mibDb.items, MibDbEntry{
+			me.CircuitPackClassID,
+			circuitPackEntityID,
+			me.AttributeValueMap{
+				"VendorId":            ToOctets("ONF", 4),
+				"AdministrativeState": 0,
+				"OperationalState":    0,
+				"BridgedOrIpInd":      0,
+			},
+		})
+		mibDb.items = append(mibDb.items, MibDbEntry{
+			me.CircuitPackClassID,
+			circuitPackEntityID,
+			me.AttributeValueMap{
+				"EquipmentId":                 ToOctets("BBSM-Circuit-Pack", 20),
+				"CardConfiguration":           0,
+				"TotalTContBufferNumber":      8,
+				"TotalPriorityQueueNumber":    8,
+				"TotalTrafficSchedulerNumber": 16,
+			},
+		})
+		mibDb.items = append(mibDb.items, MibDbEntry{
+			me.CircuitPackClassID,
+			circuitPackEntityID,
+			me.AttributeValueMap{
+				"PowerShedOverride": uint32(0),
+			},
+		})
+	}
+
 	// PPTP and UNI-Gs
 	// NOTE this are dependent on the number of UNI this ONU supports
 	// Through an identical ID, the UNI-G ME is implicitly linked to an instance of a PPTP
-	for i := 1; i <= uniPortCount; i++ {
+	totalPortsCount := ethUniPortCount + potsUniPortCount
+	for i := 1; i <= totalPortsCount; i++ {
 		uniEntityId := GenerateUniPortEntityId(uint32(i))
 
-		mibDb.items = append(mibDb.items, MibDbEntry{
-			me.PhysicalPathTerminationPointEthernetUniClassID,
-			uniEntityId,
-			me.AttributeValueMap{
-				"ExpectedType":                  0,
-				"SensedType":                    ethernetUnitType,
-				"AutoDetectionConfiguration":    0,
-				"EthernetLoopbackConfiguration": 0,
-				"AdministrativeState":           0,
-				"OperationalState":              0,
-				"ConfigurationInd":              3,
-				"MaxFrameSize":                  1518,
-				"DteOrDceInd":                   0,
-				"PauseTime":                     0,
-				"BridgedOrIpInd":                2,
-				"Arc":                           0,
-				"ArcInterval":                   0,
-				"PppoeFilter":                   0,
-				"PowerControl":                  0,
-			},
-		})
+		if i <= ethUniPortCount {
+			// first, create the correct amount of ethernet UNIs, the same is done in onu.go
+			mibDb.items = append(mibDb.items, MibDbEntry{
+				me.PhysicalPathTerminationPointEthernetUniClassID,
+				uniEntityId,
+				me.AttributeValueMap{
+					"ExpectedType":                  0,
+					"SensedType":                    ethernetUnitType,
+					"AutoDetectionConfiguration":    0,
+					"EthernetLoopbackConfiguration": 0,
+					"AdministrativeState":           0,
+					"OperationalState":              0,
+					"ConfigurationInd":              3,
+					"MaxFrameSize":                  1518,
+					"DteOrDceInd":                   0,
+					"PauseTime":                     0,
+					"BridgedOrIpInd":                2,
+					"Arc":                           0,
+					"ArcInterval":                   0,
+					"PppoeFilter":                   0,
+					"PowerControl":                  0,
+				},
+			})
+		} else {
+			// the remaining ones are pots UNIs, the same is done in onu.go
+			mibDb.items = append(mibDb.items, MibDbEntry{
+				me.PhysicalPathTerminationPointPotsUniClassID,
+				uniEntityId,
+				me.AttributeValueMap{
+					"AdministrativeState": 0,
+					"Deprecated":          0,
+					"Arc":                 0,
+					"ArcInterval":         0,
+					"Impedance":           0,
+					"TransmissionPath":    0,
+					"RxGain":              0,
+					"TxGain":              0,
+					"OperationalState":    0,
+					"HookState":           0,
+					"PotsHoldoverTime":    0,
+					"NominalFeedVoltage":  0,
+					"LossOfSoftswitch":    0,
+				},
+			})
+		}
 
 		mibDb.items = append(mibDb.items, MibDbEntry{
 			me.UniGClassID,
diff --git a/internal/common/omci/onu_mib_db_test.go b/internal/common/omci/onu_mib_db_test.go
index aefbae5..378ac6e 100644
--- a/internal/common/omci/onu_mib_db_test.go
+++ b/internal/common/omci/onu_mib_db_test.go
@@ -17,10 +17,11 @@
 package omci
 
 import (
+	"testing"
+
 	"github.com/opencord/omci-lib-go/v2"
 	me "github.com/opencord/omci-lib-go/v2/generated"
 	"github.com/stretchr/testify/assert"
-	"testing"
 )
 
 func TestEntityID_ToUint16(t *testing.T) {
@@ -55,7 +56,7 @@
 
 func Test_GenerateMibDatabase(t *testing.T) {
 	const uniPortCount = 4
-	mibDb, err := GenerateMibDatabase(uniPortCount)
+	mibDb, err := GenerateMibDatabase(uniPortCount, 0)
 
 	expectedItems := 9                     //ONU-G + 2 Circuit Packs (4 messages each)
 	expectedItems += 2 * uniPortCount      // 1 PPTP and 1 UniG per UNI
@@ -89,3 +90,41 @@
 	}
 
 }
+
+func Test_GenerateMibDatabase_withPots(t *testing.T) {
+	const uniPortCount = 4
+	const potsPortCount = 1
+	mibDb, err := GenerateMibDatabase(uniPortCount, potsPortCount)
+
+	expectedItems := 13                                      //ONU-G + 3 Circuit Packs (4 messages each)
+	expectedItems += 2 * (uniPortCount + potsPortCount)      // 1 PPTP and 1 UniG per UNI
+	expectedItems += 1                                       // ANI-G
+	expectedItems += 2 * tconts                              // T-CONT and traffic schedulers
+	expectedItems += 1                                       // ONU-2g
+	expectedItems += 2 * 8 * tconts                          // 8 upstream queues for each T-CONT, and we report each queue twice
+	expectedItems += 2 * 16 * (uniPortCount + potsPortCount) // 16 downstream queues for each T-CONT, and we report each queue twice
+
+	assert.NoError(t, err)
+	assert.NotNil(t, mibDb)
+	assert.Equal(t, expectedItems, int(mibDb.NumberOfCommands))
+
+	// now try to serialize all messages to check on the attributes
+	for _, entry := range mibDb.items {
+		reportedMe, meErr := me.LoadManagedEntityDefinition(entry.classId, me.ParamData{
+			EntityID:   entry.entityId.ToUint16(),
+			Attributes: entry.params,
+		})
+		assert.NoError(t, meErr.GetError())
+
+		response := &omci.MibUploadNextResponse{
+			MeBasePacket: omci.MeBasePacket{
+				EntityClass: me.OnuDataClassID,
+			},
+			ReportedME: *reportedMe,
+		}
+
+		_, err := Serialize(omci.MibUploadNextResponseType, response, uint16(10))
+		assert.NoError(t, err)
+	}
+
+}