diff --git a/clock.c b/clock.c
index ddea72f..5b251c1 100644
--- a/clock.c
+++ b/clock.c
@@ -336,76 +336,76 @@ static int clock_management_fill_response(struct clock *c, struct port *p,
 	tlv->id = id;
 
 	switch (id) {
-	case USER_DESCRIPTION:
+	case TLV_USER_DESCRIPTION:
 		text = (struct PTPText *) tlv->data;
 		text->length = c->desc.userDescription.length;
 		memcpy(text->text, c->desc.userDescription.text, text->length);
 		datalen = 1 + text->length;
 		respond = 1;
 		break;
-	case DEFAULT_DATA_SET:
+	case TLV_DEFAULT_DATA_SET:
 		memcpy(tlv->data, &c->dds, sizeof(c->dds));
 		datalen = sizeof(c->dds);
 		respond = 1;
 		break;
-	case CURRENT_DATA_SET:
+	case TLV_CURRENT_DATA_SET:
 		memcpy(tlv->data, &c->cur, sizeof(c->cur));
 		datalen = sizeof(c->cur);
 		respond = 1;
 		break;
-	case PARENT_DATA_SET:
+	case TLV_PARENT_DATA_SET:
 		memcpy(tlv->data, &c->dad.pds, sizeof(c->dad.pds));
 		datalen = sizeof(c->dad.pds);
 		respond = 1;
 		break;
-	case TIME_PROPERTIES_DATA_SET:
+	case TLV_TIME_PROPERTIES_DATA_SET:
 		memcpy(tlv->data, &c->tds, sizeof(c->tds));
 		datalen = sizeof(c->tds);
 		respond = 1;
 		break;
-	case PRIORITY1:
+	case TLV_PRIORITY1:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = c->dds.priority1;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case PRIORITY2:
+	case TLV_PRIORITY2:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = c->dds.priority2;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case DOMAIN:
+	case TLV_DOMAIN:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = c->dds.domainNumber;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case SLAVE_ONLY:
+	case TLV_SLAVE_ONLY:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = c->dds.flags & DDS_SLAVE_ONLY;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case CLOCK_ACCURACY:
+	case TLV_CLOCK_ACCURACY:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = c->dds.clockQuality.clockAccuracy;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case TRACEABILITY_PROPERTIES:
+	case TLV_TRACEABILITY_PROPERTIES:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = c->tds.flags & (TIME_TRACEABLE|FREQ_TRACEABLE);
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case TIMESCALE_PROPERTIES:
+	case TLV_TIMESCALE_PROPERTIES:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = c->tds.flags & PTP_TIMESCALE;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case TIME_STATUS_NP:
+	case TLV_TIME_STATUS_NP:
 		tsn = (struct time_status_np *) tlv->data;
 		tsn->master_offset = c->master_offset;
 		tsn->ingress_time = tmv_to_nanoseconds(c->t2);
@@ -423,7 +423,7 @@ static int clock_management_fill_response(struct clock *c, struct port *p,
 		datalen = sizeof(*tsn);
 		respond = 1;
 		break;
-	case GRANDMASTER_SETTINGS_NP:
+	case TLV_GRANDMASTER_SETTINGS_NP:
 		gsn = (struct grandmaster_settings_np *) tlv->data;
 		gsn->clockQuality = c->dds.clockQuality;
 		gsn->utc_offset = c->utc_offset;
@@ -432,7 +432,7 @@ static int clock_management_fill_response(struct clock *c, struct port *p,
 		datalen = sizeof(*gsn);
 		respond = 1;
 		break;
-	case SUBSCRIBE_EVENTS_NP:
+	case TLV_SUBSCRIBE_EVENTS_NP:
 		if (p != c->port[c->nports]) {
 			/* Only the UDS port allowed. */
 			break;
@@ -483,7 +483,7 @@ static int clock_management_set(struct clock *c, struct port *p,
 	tlv = (struct management_tlv *) req->management.suffix;
 
 	switch (id) {
-	case GRANDMASTER_SETTINGS_NP:
+	case TLV_GRANDMASTER_SETTINGS_NP:
 		gsn = (struct grandmaster_settings_np *) tlv->data;
 		c->dds.clockQuality = gsn->clockQuality;
 		c->utc_offset = gsn->utc_offset;
@@ -492,7 +492,7 @@ static int clock_management_set(struct clock *c, struct port *p,
 		*changed = 1;
 		respond = 1;
 		break;
-	case SUBSCRIBE_EVENTS_NP:
+	case TLV_SUBSCRIBE_EVENTS_NP:
 		sen = (struct subscribe_events_np *)tlv->data;
 		clock_update_subscription(c, req, sen->bitmask,
 					  sen->duration);
@@ -1017,13 +1017,13 @@ int clock_manage(struct clock *c, struct port *p, struct ptp_message *msg)
 			return changed;
 		break;
 	case SET:
-		if (mgt->length == 2 && mgt->id != NULL_MANAGEMENT) {
-			clock_management_send_error(p, msg, WRONG_LENGTH);
+		if (mgt->length == 2 && mgt->id != TLV_NULL_MANAGEMENT) {
+			clock_management_send_error(p, msg, TLV_WRONG_LENGTH);
 			return changed;
 		}
 		if (p != c->port[c->nports]) {
 			/* Sorry, only allowed on the UDS port. */
-			clock_management_send_error(p, msg, NOT_SUPPORTED);
+			clock_management_send_error(p, msg, TLV_NOT_SUPPORTED);
 			return changed;
 		}
 		if (clock_management_set(c, p, mgt->id, msg, &changed))
@@ -1036,49 +1036,49 @@ int clock_manage(struct clock *c, struct port *p, struct ptp_message *msg)
 	}
 
 	switch (mgt->id) {
-	case PORT_PROPERTIES_NP:
+	case TLV_PORT_PROPERTIES_NP:
 		if (p != c->port[c->nports]) {
 			/* Only the UDS port allowed. */
-			clock_management_send_error(p, msg, NOT_SUPPORTED);
+			clock_management_send_error(p, msg, TLV_NOT_SUPPORTED);
 			return 0;
 		}
 	}
 
 	switch (mgt->id) {
-	case USER_DESCRIPTION:
-	case SAVE_IN_NON_VOLATILE_STORAGE:
-	case RESET_NON_VOLATILE_STORAGE:
-	case INITIALIZE:
-	case FAULT_LOG:
-	case FAULT_LOG_RESET:
-	case DEFAULT_DATA_SET:
-	case CURRENT_DATA_SET:
-	case PARENT_DATA_SET:
-	case TIME_PROPERTIES_DATA_SET:
-	case PRIORITY1:
-	case PRIORITY2:
-	case DOMAIN:
-	case SLAVE_ONLY:
-	case TIME:
-	case CLOCK_ACCURACY:
-	case UTC_PROPERTIES:
-	case TRACEABILITY_PROPERTIES:
-	case TIMESCALE_PROPERTIES:
-	case PATH_TRACE_LIST:
-	case PATH_TRACE_ENABLE:
-	case GRANDMASTER_CLUSTER_TABLE:
-	case ACCEPTABLE_MASTER_TABLE:
-	case ACCEPTABLE_MASTER_MAX_TABLE_SIZE:
-	case ALTERNATE_TIME_OFFSET_ENABLE:
-	case ALTERNATE_TIME_OFFSET_NAME:
-	case ALTERNATE_TIME_OFFSET_MAX_KEY:
-	case ALTERNATE_TIME_OFFSET_PROPERTIES:
-	case TRANSPARENT_CLOCK_DEFAULT_DATA_SET:
-	case PRIMARY_DOMAIN:
-	case TIME_STATUS_NP:
-	case GRANDMASTER_SETTINGS_NP:
-	case SUBSCRIBE_EVENTS_NP:
-		clock_management_send_error(p, msg, NOT_SUPPORTED);
+	case TLV_USER_DESCRIPTION:
+	case TLV_SAVE_IN_NON_VOLATILE_STORAGE:
+	case TLV_RESET_NON_VOLATILE_STORAGE:
+	case TLV_INITIALIZE:
+	case TLV_FAULT_LOG:
+	case TLV_FAULT_LOG_RESET:
+	case TLV_DEFAULT_DATA_SET:
+	case TLV_CURRENT_DATA_SET:
+	case TLV_PARENT_DATA_SET:
+	case TLV_TIME_PROPERTIES_DATA_SET:
+	case TLV_PRIORITY1:
+	case TLV_PRIORITY2:
+	case TLV_DOMAIN:
+	case TLV_SLAVE_ONLY:
+	case TLV_TIME:
+	case TLV_CLOCK_ACCURACY:
+	case TLV_UTC_PROPERTIES:
+	case TLV_TRACEABILITY_PROPERTIES:
+	case TLV_TIMESCALE_PROPERTIES:
+	case TLV_PATH_TRACE_LIST:
+	case TLV_PATH_TRACE_ENABLE:
+	case TLV_GRANDMASTER_CLUSTER_TABLE:
+	case TLV_ACCEPTABLE_MASTER_TABLE:
+	case TLV_ACCEPTABLE_MASTER_MAX_TABLE_SIZE:
+	case TLV_ALTERNATE_TIME_OFFSET_ENABLE:
+	case TLV_ALTERNATE_TIME_OFFSET_NAME:
+	case TLV_ALTERNATE_TIME_OFFSET_MAX_KEY:
+	case TLV_ALTERNATE_TIME_OFFSET_PROPERTIES:
+	case TLV_TRANSPARENT_CLOCK_DEFAULT_DATA_SET:
+	case TLV_PRIMARY_DOMAIN:
+	case TLV_TIME_STATUS_NP:
+	case TLV_GRANDMASTER_SETTINGS_NP:
+	case TLV_SUBSCRIBE_EVENTS_NP:
+		clock_management_send_error(p, msg, TLV_NOT_SUPPORTED);
 		break;
 	default:
 		answers = 0;
@@ -1091,8 +1091,8 @@ int clock_manage(struct clock *c, struct port *p, struct ptp_message *msg)
 		}
 		if (!answers) {
 			/* IEEE 1588 Interpretation #21 suggests to use
-			 * WRONG_VALUE for ports that do not exist */
-			clock_management_send_error(p, msg, WRONG_VALUE);
+			 * TLV_WRONG_VALUE for ports that do not exist */
+			clock_management_send_error(p, msg, TLV_WRONG_VALUE);
 		}
 		break;
 	}
diff --git a/phc2sys.c b/phc2sys.c
index 224c03e..7815a8e 100644
--- a/phc2sys.c
+++ b/phc2sys.c
@@ -700,7 +700,7 @@ static int recv_subscribed(struct node *node, struct ptp_message *msg,
 	if (mgt_id == excluded)
 		return 0;
 	switch (mgt_id) {
-	case PORT_DATA_SET:
+	case TLV_PORT_DATA_SET:
 		pds = get_mgt_data(msg);
 		port = port_get(node, pds->portIdentity.portNumber);
 		if (!port) {
@@ -732,7 +732,7 @@ static void send_subscription(struct node *node)
 	memset(&sen, 0, sizeof(sen));
 	sen.duration = PMC_SUBSCRIBE_DURATION;
 	sen.bitmask[0] = 1 << NOTIFY_PORT_STATE;
-	pmc_send_set_action(node->pmc, SUBSCRIBE_EVENTS_NP, &sen, sizeof(sen));
+	pmc_send_set_action(node->pmc, TLV_SUBSCRIBE_EVENTS_NP, &sen, sizeof(sen));
 }
 
 static int init_pmc(struct node *node, int domain_number)
@@ -781,7 +781,7 @@ static int run_pmc(struct node *node, int timeout, int ds_id,
 		if ((pollfd[0].revents & POLLOUT) &&
 		    !(pollfd[0].revents & (POLLIN|POLLPRI))) {
 			switch (ds_id) {
-			case SUBSCRIBE_EVENTS_NP:
+			case TLV_SUBSCRIBE_EVENTS_NP:
 				send_subscription(node);
 				break;
 			default:
@@ -829,7 +829,7 @@ static int run_pmc_wait_sync(struct node *node, int timeout)
 	Enumeration8 portState;
 
 	while (1) {
-		res = run_pmc(node, timeout, PORT_DATA_SET, &msg);
+		res = run_pmc(node, timeout, TLV_PORT_DATA_SET, &msg);
 		if (res <= 0)
 			return res;
 
@@ -853,7 +853,7 @@ static int run_pmc_get_utc_offset(struct node *node, int timeout)
 	int res;
 	struct timePropertiesDS *tds;
 
-	res = run_pmc(node, timeout, TIME_PROPERTIES_DATA_SET, &msg);
+	res = run_pmc(node, timeout, TLV_TIME_PROPERTIES_DATA_SET, &msg);
 	if (res <= 0)
 		return res;
 
@@ -883,7 +883,7 @@ static int run_pmc_get_number_ports(struct node *node, int timeout)
 	int res;
 	struct defaultDS *dds;
 
-	res = run_pmc(node, timeout, DEFAULT_DATA_SET, &msg);
+	res = run_pmc(node, timeout, TLV_DEFAULT_DATA_SET, &msg);
 	if (res <= 0)
 		return res;
 
@@ -898,7 +898,7 @@ static int run_pmc_subscribe(struct node *node, int timeout)
 	struct ptp_message *msg;
 	int res;
 
-	res = run_pmc(node, timeout, SUBSCRIBE_EVENTS_NP, &msg);
+	res = run_pmc(node, timeout, TLV_SUBSCRIBE_EVENTS_NP, &msg);
 	if (res <= 0)
 		return res;
 	msg_put(msg);
@@ -922,7 +922,7 @@ static int run_pmc_port_properties(struct node *node, int timeout,
 
 	pmc_target_port(node->pmc, port);
 	while (1) {
-		res = run_pmc(node, timeout, PORT_PROPERTIES_NP, &msg);
+		res = run_pmc(node, timeout, TLV_PORT_PROPERTIES_NP, &msg);
 		if (res <= 0)
 			goto out;
 
@@ -955,7 +955,7 @@ static int run_pmc_clock_identity(struct node *node, int timeout)
 	struct defaultDS *dds;
 	int res;
 
-	res = run_pmc(node, timeout, DEFAULT_DATA_SET, &msg);
+	res = run_pmc(node, timeout, TLV_DEFAULT_DATA_SET, &msg);
 	if (res <= 0)
 		return res;
 
diff --git a/pmc.c b/pmc.c
index 65c789c..ba06293 100644
--- a/pmc.c
+++ b/pmc.c
@@ -56,57 +56,57 @@ struct management_id {
 
 struct management_id idtab[] = {
 /* Clock management ID values */
-	{ "USER_DESCRIPTION", USER_DESCRIPTION, do_get_action },
-	{ "SAVE_IN_NON_VOLATILE_STORAGE", SAVE_IN_NON_VOLATILE_STORAGE, not_supported },
-	{ "RESET_NON_VOLATILE_STORAGE", RESET_NON_VOLATILE_STORAGE, not_supported },
-	{ "INITIALIZE", INITIALIZE, not_supported },
-	{ "FAULT_LOG", FAULT_LOG, not_supported },
-	{ "FAULT_LOG_RESET", FAULT_LOG_RESET, not_supported },
-	{ "DEFAULT_DATA_SET", DEFAULT_DATA_SET, do_get_action },
-	{ "CURRENT_DATA_SET", CURRENT_DATA_SET, do_get_action },
-	{ "PARENT_DATA_SET", PARENT_DATA_SET, do_get_action },
-	{ "TIME_PROPERTIES_DATA_SET", TIME_PROPERTIES_DATA_SET, do_get_action },
-	{ "PRIORITY1", PRIORITY1, do_get_action },
-	{ "PRIORITY2", PRIORITY2, do_get_action },
-	{ "DOMAIN", DOMAIN, do_get_action },
-	{ "SLAVE_ONLY", SLAVE_ONLY, do_get_action },
-	{ "TIME", TIME, not_supported },
-	{ "CLOCK_ACCURACY", CLOCK_ACCURACY, do_get_action },
-	{ "UTC_PROPERTIES", UTC_PROPERTIES, not_supported },
-	{ "TRACEABILITY_PROPERTIES", TRACEABILITY_PROPERTIES, do_get_action },
-	{ "TIMESCALE_PROPERTIES", TIMESCALE_PROPERTIES, do_get_action },
-	{ "PATH_TRACE_LIST", PATH_TRACE_LIST, not_supported },
-	{ "PATH_TRACE_ENABLE", PATH_TRACE_ENABLE, not_supported },
-	{ "GRANDMASTER_CLUSTER_TABLE", GRANDMASTER_CLUSTER_TABLE, not_supported },
-	{ "ACCEPTABLE_MASTER_TABLE", ACCEPTABLE_MASTER_TABLE, not_supported },
-	{ "ACCEPTABLE_MASTER_MAX_TABLE_SIZE", ACCEPTABLE_MASTER_MAX_TABLE_SIZE, not_supported },
-	{ "ALTERNATE_TIME_OFFSET_ENABLE", ALTERNATE_TIME_OFFSET_ENABLE, not_supported },
-	{ "ALTERNATE_TIME_OFFSET_NAME", ALTERNATE_TIME_OFFSET_NAME, not_supported },
-	{ "ALTERNATE_TIME_OFFSET_MAX_KEY", ALTERNATE_TIME_OFFSET_MAX_KEY, not_supported },
-	{ "ALTERNATE_TIME_OFFSET_PROPERTIES", ALTERNATE_TIME_OFFSET_PROPERTIES, not_supported },
-	{ "TRANSPARENT_CLOCK_DEFAULT_DATA_SET", TRANSPARENT_CLOCK_DEFAULT_DATA_SET, not_supported },
-	{ "PRIMARY_DOMAIN", PRIMARY_DOMAIN, not_supported },
-	{ "TIME_STATUS_NP", TIME_STATUS_NP, do_get_action },
-	{ "GRANDMASTER_SETTINGS_NP", GRANDMASTER_SETTINGS_NP, do_set_action },
+	{ "USER_DESCRIPTION", TLV_USER_DESCRIPTION, do_get_action },
+	{ "SAVE_IN_NON_VOLATILE_STORAGE", TLV_SAVE_IN_NON_VOLATILE_STORAGE, not_supported },
+	{ "RESET_NON_VOLATILE_STORAGE", TLV_RESET_NON_VOLATILE_STORAGE, not_supported },
+	{ "INITIALIZE", TLV_INITIALIZE, not_supported },
+	{ "FAULT_LOG", TLV_FAULT_LOG, not_supported },
+	{ "FAULT_LOG_RESET", TLV_FAULT_LOG_RESET, not_supported },
+	{ "DEFAULT_DATA_SET", TLV_DEFAULT_DATA_SET, do_get_action },
+	{ "CURRENT_DATA_SET", TLV_CURRENT_DATA_SET, do_get_action },
+	{ "PARENT_DATA_SET", TLV_PARENT_DATA_SET, do_get_action },
+	{ "TIME_PROPERTIES_DATA_SET", TLV_TIME_PROPERTIES_DATA_SET, do_get_action },
+	{ "PRIORITY1", TLV_PRIORITY1, do_get_action },
+	{ "PRIORITY2", TLV_PRIORITY2, do_get_action },
+	{ "DOMAIN", TLV_DOMAIN, do_get_action },
+	{ "SLAVE_ONLY", TLV_SLAVE_ONLY, do_get_action },
+	{ "TIME", TLV_TIME, not_supported },
+	{ "CLOCK_ACCURACY", TLV_CLOCK_ACCURACY, do_get_action },
+	{ "UTC_PROPERTIES", TLV_UTC_PROPERTIES, not_supported },
+	{ "TRACEABILITY_PROPERTIES", TLV_TRACEABILITY_PROPERTIES, do_get_action },
+	{ "TIMESCALE_PROPERTIES", TLV_TIMESCALE_PROPERTIES, do_get_action },
+	{ "PATH_TRACE_LIST", TLV_PATH_TRACE_LIST, not_supported },
+	{ "PATH_TRACE_ENABLE", TLV_PATH_TRACE_ENABLE, not_supported },
+	{ "GRANDMASTER_CLUSTER_TABLE", TLV_GRANDMASTER_CLUSTER_TABLE, not_supported },
+	{ "ACCEPTABLE_MASTER_TABLE", TLV_ACCEPTABLE_MASTER_TABLE, not_supported },
+	{ "ACCEPTABLE_MASTER_MAX_TABLE_SIZE", TLV_ACCEPTABLE_MASTER_MAX_TABLE_SIZE, not_supported },
+	{ "ALTERNATE_TIME_OFFSET_ENABLE", TLV_ALTERNATE_TIME_OFFSET_ENABLE, not_supported },
+	{ "ALTERNATE_TIME_OFFSET_NAME", TLV_ALTERNATE_TIME_OFFSET_NAME, not_supported },
+	{ "ALTERNATE_TIME_OFFSET_MAX_KEY", TLV_ALTERNATE_TIME_OFFSET_MAX_KEY, not_supported },
+	{ "ALTERNATE_TIME_OFFSET_PROPERTIES", TLV_ALTERNATE_TIME_OFFSET_PROPERTIES, not_supported },
+	{ "TRANSPARENT_CLOCK_DEFAULT_DATA_SET", TLV_TRANSPARENT_CLOCK_DEFAULT_DATA_SET, not_supported },
+	{ "PRIMARY_DOMAIN", TLV_PRIMARY_DOMAIN, not_supported },
+	{ "TIME_STATUS_NP", TLV_TIME_STATUS_NP, do_get_action },
+	{ "GRANDMASTER_SETTINGS_NP", TLV_GRANDMASTER_SETTINGS_NP, do_set_action },
 /* Port management ID values */
-	{ "NULL_MANAGEMENT", NULL_MANAGEMENT, null_management },
-	{ "CLOCK_DESCRIPTION", CLOCK_DESCRIPTION, do_get_action },
-	{ "PORT_DATA_SET", PORT_DATA_SET, do_get_action },
-	{ "LOG_ANNOUNCE_INTERVAL", LOG_ANNOUNCE_INTERVAL, do_get_action },
-	{ "ANNOUNCE_RECEIPT_TIMEOUT", ANNOUNCE_RECEIPT_TIMEOUT, do_get_action },
-	{ "LOG_SYNC_INTERVAL", LOG_SYNC_INTERVAL, do_get_action },
-	{ "VERSION_NUMBER", VERSION_NUMBER, do_get_action },
-	{ "ENABLE_PORT", ENABLE_PORT, not_supported },
-	{ "DISABLE_PORT", DISABLE_PORT, not_supported },
-	{ "UNICAST_NEGOTIATION_ENABLE", UNICAST_NEGOTIATION_ENABLE, not_supported },
-	{ "UNICAST_MASTER_TABLE", UNICAST_MASTER_TABLE, not_supported },
-	{ "UNICAST_MASTER_MAX_TABLE_SIZE", UNICAST_MASTER_MAX_TABLE_SIZE, not_supported },
-	{ "ACCEPTABLE_MASTER_TABLE_ENABLED", ACCEPTABLE_MASTER_TABLE_ENABLED, not_supported },
-	{ "ALTERNATE_MASTER", ALTERNATE_MASTER, not_supported },
-	{ "TRANSPARENT_CLOCK_PORT_DATA_SET", TRANSPARENT_CLOCK_PORT_DATA_SET, not_supported },
-	{ "DELAY_MECHANISM", DELAY_MECHANISM, do_get_action },
-	{ "LOG_MIN_PDELAY_REQ_INTERVAL", LOG_MIN_PDELAY_REQ_INTERVAL, do_get_action },
-	{ "PORT_DATA_SET_NP", PORT_DATA_SET_NP, do_set_action },
+	{ "NULL_MANAGEMENT", TLV_NULL_MANAGEMENT, null_management },
+	{ "CLOCK_DESCRIPTION", TLV_CLOCK_DESCRIPTION, do_get_action },
+	{ "PORT_DATA_SET", TLV_PORT_DATA_SET, do_get_action },
+	{ "LOG_ANNOUNCE_INTERVAL", TLV_LOG_ANNOUNCE_INTERVAL, do_get_action },
+	{ "ANNOUNCE_RECEIPT_TIMEOUT", TLV_ANNOUNCE_RECEIPT_TIMEOUT, do_get_action },
+	{ "LOG_SYNC_INTERVAL", TLV_LOG_SYNC_INTERVAL, do_get_action },
+	{ "VERSION_NUMBER", TLV_VERSION_NUMBER, do_get_action },
+	{ "ENABLE_PORT", TLV_ENABLE_PORT, not_supported },
+	{ "DISABLE_PORT", TLV_DISABLE_PORT, not_supported },
+	{ "UNICAST_NEGOTIATION_ENABLE", TLV_UNICAST_NEGOTIATION_ENABLE, not_supported },
+	{ "UNICAST_MASTER_TABLE", TLV_UNICAST_MASTER_TABLE, not_supported },
+	{ "UNICAST_MASTER_MAX_TABLE_SIZE", TLV_UNICAST_MASTER_MAX_TABLE_SIZE, not_supported },
+	{ "ACCEPTABLE_MASTER_TABLE_ENABLED", TLV_ACCEPTABLE_MASTER_TABLE_ENABLED, not_supported },
+	{ "ALTERNATE_MASTER", TLV_ALTERNATE_MASTER, not_supported },
+	{ "TRANSPARENT_CLOCK_PORT_DATA_SET", TLV_TRANSPARENT_CLOCK_PORT_DATA_SET, not_supported },
+	{ "DELAY_MECHANISM", TLV_DELAY_MECHANISM, do_get_action },
+	{ "LOG_MIN_PDELAY_REQ_INTERVAL", TLV_LOG_MIN_PDELAY_REQ_INTERVAL, do_get_action },
+	{ "PORT_DATA_SET_NP", TLV_PORT_DATA_SET_NP, do_set_action },
 };
 
 static const char *action_string[] = {
@@ -219,12 +219,12 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 		fprintf(fp, "unknown-tlv ");
 	}
 	mgt = (struct management_tlv *) msg->management.suffix;
-	if (mgt->length == 2 && mgt->id != NULL_MANAGEMENT) {
+	if (mgt->length == 2 && mgt->id != TLV_NULL_MANAGEMENT) {
 		fprintf(fp, "empty-tlv ");
 		goto out;
 	}
 	switch (mgt->id) {
-	case CLOCK_DESCRIPTION:
+	case TLV_CLOCK_DESCRIPTION:
 		cd = &msg->last_tlv.cd;
 		fprintf(fp, "CLOCK_DESCRIPTION "
 			IFMT "clockType             0x%hx"
@@ -248,12 +248,12 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 			text2str(cd->userDescription),
 			bin2str(cd->profileIdentity, PROFILE_ID_LEN));
 		break;
-	case USER_DESCRIPTION:
+	case TLV_USER_DESCRIPTION:
 		fprintf(fp, "USER_DESCRIPTION "
 			IFMT "userDescription  %s",
 			text2str(msg->last_tlv.cd.userDescription));
 		break;
-	case DEFAULT_DATA_SET:
+	case TLV_DEFAULT_DATA_SET:
 		dds = (struct defaultDS *) mgt->data;
 		fprintf(fp, "DEFAULT_DATA_SET "
 			IFMT "twoStepFlag             %d"
@@ -277,7 +277,7 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 			cid2str(&dds->clockIdentity),
 			dds->domainNumber);
 		break;
-	case CURRENT_DATA_SET:
+	case TLV_CURRENT_DATA_SET:
 		cds = (struct currentDS *) mgt->data;
 		fprintf(fp, "CURRENT_DATA_SET "
 			IFMT "stepsRemoved     %hd"
@@ -286,7 +286,7 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 			cds->stepsRemoved, cds->offsetFromMaster / 65536.0,
 			cds->meanPathDelay / 65536.0);
 		break;
-	case PARENT_DATA_SET:
+	case TLV_PARENT_DATA_SET:
 		pds = (struct parentDS *) mgt->data;
 		fprintf(fp, "PARENT_DATA_SET "
 			IFMT "parentPortIdentity                    %s"
@@ -310,7 +310,7 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 			pds->grandmasterPriority2,
 			cid2str(&pds->grandmasterIdentity));
 		break;
-	case TIME_PROPERTIES_DATA_SET:
+	case TLV_TIME_PROPERTIES_DATA_SET:
 		tp = (struct timePropertiesDS *) mgt->data;
 		fprintf(fp, "TIME_PROPERTIES_DATA_SET "
 			IFMT "currentUtcOffset      %hd"
@@ -330,32 +330,32 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 			tp->flags & FREQ_TRACEABLE ? 1 : 0,
 			tp->timeSource);
 		break;
-	case PRIORITY1:
+	case TLV_PRIORITY1:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "PRIORITY1 "
 			IFMT "priority1 %hhu", mtd->val);
 		break;
-	case PRIORITY2:
+	case TLV_PRIORITY2:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "PRIORITY2 "
 			IFMT "priority2 %hhu", mtd->val);
 		break;
-	case DOMAIN:
+	case TLV_DOMAIN:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "DOMAIN "
 			IFMT "domainNumber %hhu", mtd->val);
 		break;
-	case SLAVE_ONLY:
+	case TLV_SLAVE_ONLY:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "SLAVE_ONLY "
 			IFMT "slaveOnly %d", mtd->val & DDS_SLAVE_ONLY ? 1 : 0);
 		break;
-	case CLOCK_ACCURACY:
+	case TLV_CLOCK_ACCURACY:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "CLOCK_ACCURACY "
 			IFMT "clockAccuracy 0x%02hhx", mtd->val);
 		break;
-	case TRACEABILITY_PROPERTIES:
+	case TLV_TRACEABILITY_PROPERTIES:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "TRACEABILITY_PROPERTIES "
 			IFMT "timeTraceable      %d"
@@ -363,12 +363,12 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 			mtd->val & TIME_TRACEABLE ? 1 : 0,
 			mtd->val & FREQ_TRACEABLE ? 1 : 0);
 		break;
-	case TIMESCALE_PROPERTIES:
+	case TLV_TIMESCALE_PROPERTIES:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "TIMESCALE_PROPERTIES "
 			IFMT "ptpTimescale %d", mtd->val & PTP_TIMESCALE ? 1 : 0);
 		break;
-	case TIME_STATUS_NP:
+	case TLV_TIME_STATUS_NP:
 		tsn = (struct time_status_np *) mgt->data;
 		fprintf(fp, "TIME_STATUS_NP "
 			IFMT "master_offset              %" PRId64
@@ -390,7 +390,7 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 			tsn->gmPresent ? "true" : "false",
 			cid2str(&tsn->gmIdentity));
 		break;
-	case GRANDMASTER_SETTINGS_NP:
+	case TLV_GRANDMASTER_SETTINGS_NP:
 		gsn = (struct grandmaster_settings_np *) mgt->data;
 		fprintf(fp, "GRANDMASTER_SETTINGS_NP "
 			IFMT "clockClass              %hhu"
@@ -416,7 +416,7 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 			gsn->time_flags & FREQ_TRACEABLE ? 1 : 0,
 			gsn->time_source);
 		break;
-	case PORT_DATA_SET:
+	case TLV_PORT_DATA_SET:
 		p = (struct portDS *) mgt->data;
 		if (p->portState > PS_SLAVE) {
 			p->portState = 0;
@@ -438,7 +438,7 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 			p->logSyncInterval, p->delayMechanism,
 			p->logMinPdelayReqInterval, p->versionNumber);
 		break;
-	case PORT_DATA_SET_NP:
+	case TLV_PORT_DATA_SET_NP:
 		pnp = (struct port_ds_np *) mgt->data;
 		fprintf(fp, "PORT_DATA_SET_NP "
 			IFMT "neighborPropDelayThresh %u"
@@ -446,32 +446,32 @@ static void pmc_show(struct ptp_message *msg, FILE *fp)
 			pnp->neighborPropDelayThresh,
 			pnp->asCapable ? 1 : 0);
 		break;
-	case LOG_ANNOUNCE_INTERVAL:
+	case TLV_LOG_ANNOUNCE_INTERVAL:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "LOG_ANNOUNCE_INTERVAL "
 			IFMT "logAnnounceInterval %hhd", mtd->val);
 		break;
-	case ANNOUNCE_RECEIPT_TIMEOUT:
+	case TLV_ANNOUNCE_RECEIPT_TIMEOUT:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "ANNOUNCE_RECEIPT_TIMEOUT "
 			IFMT "announceReceiptTimeout %hhu", mtd->val);
 		break;
-	case LOG_SYNC_INTERVAL:
+	case TLV_LOG_SYNC_INTERVAL:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "ANNOUNCE_RECEIPT_TIMEOUT "
 			IFMT "logSyncInterval %hhd", mtd->val);
 		break;
-	case VERSION_NUMBER:
+	case TLV_VERSION_NUMBER:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "VERSION_NUMBER "
 			IFMT "versionNumber %hhu", mtd->val);
 		break;
-	case DELAY_MECHANISM:
+	case TLV_DELAY_MECHANISM:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "DELAY_MECHANISM "
 			IFMT "delayMechanism %hhu", mtd->val);
 		break;
-	case LOG_MIN_PDELAY_REQ_INTERVAL:
+	case TLV_LOG_MIN_PDELAY_REQ_INTERVAL:
 		mtd = (struct management_tlv_datum *) mgt->data;
 		fprintf(fp, "LOG_MIN_PDELAY_REQ_INTERVAL "
 			IFMT "logMinPdelayReqInterval %hhd", mtd->val);
@@ -513,7 +513,7 @@ static void do_set_action(int action, int index, char *str)
 		return;
 	}
 	switch (code) {
-	case GRANDMASTER_SETTINGS_NP:
+	case TLV_GRANDMASTER_SETTINGS_NP:
 		cnt = sscanf(str, " %*s %*s "
 			     "clockClass              %hhu "
 			     "clockAccuracy           %hhx "
@@ -557,7 +557,7 @@ static void do_set_action(int action, int index, char *str)
 			gsn.time_flags |= FREQ_TRACEABLE;
 		pmc_send_set_action(pmc, code, &gsn, sizeof(gsn));
 		break;
-	case PORT_DATA_SET_NP:
+	case TLV_PORT_DATA_SET_NP:
 		cnt = sscanf(str, " %*s %*s "
 			     "neighborPropDelayThresh %u "
 			     "asCapable               %d ",
diff --git a/pmc_common.c b/pmc_common.c
index 41385da..afd6e5f 100644
--- a/pmc_common.c
+++ b/pmc_common.c
@@ -161,53 +161,53 @@ static int pmc_tlv_datalen(struct pmc *pmc, int id)
 		return len;
 
 	switch (id) {
-	case USER_DESCRIPTION:
+	case TLV_USER_DESCRIPTION:
 		len += EMPTY_PTP_TEXT;
 		break;
-	case DEFAULT_DATA_SET:
+	case TLV_DEFAULT_DATA_SET:
 		len += sizeof(struct defaultDS);
 		break;
-	case CURRENT_DATA_SET:
+	case TLV_CURRENT_DATA_SET:
 		len += sizeof(struct currentDS);
 		break;
-	case PARENT_DATA_SET:
+	case TLV_PARENT_DATA_SET:
 		len += sizeof(struct parentDS);
 		break;
-	case TIME_PROPERTIES_DATA_SET:
+	case TLV_TIME_PROPERTIES_DATA_SET:
 		len += sizeof(struct timePropertiesDS);
 		break;
-	case PRIORITY1:
-	case PRIORITY2:
-	case DOMAIN:
-	case SLAVE_ONLY:
-	case CLOCK_ACCURACY:
-	case TRACEABILITY_PROPERTIES:
-	case TIMESCALE_PROPERTIES:
+	case TLV_PRIORITY1:
+	case TLV_PRIORITY2:
+	case TLV_DOMAIN:
+	case TLV_SLAVE_ONLY:
+	case TLV_CLOCK_ACCURACY:
+	case TLV_TRACEABILITY_PROPERTIES:
+	case TLV_TIMESCALE_PROPERTIES:
 		len += sizeof(struct management_tlv_datum);
 		break;
-	case TIME_STATUS_NP:
+	case TLV_TIME_STATUS_NP:
 		len += sizeof(struct time_status_np);
 		break;
-	case GRANDMASTER_SETTINGS_NP:
+	case TLV_GRANDMASTER_SETTINGS_NP:
 		len += sizeof(struct grandmaster_settings_np);
 		break;
-	case NULL_MANAGEMENT:
+	case TLV_NULL_MANAGEMENT:
 		break;
-	case CLOCK_DESCRIPTION:
+	case TLV_CLOCK_DESCRIPTION:
 		len += EMPTY_CLOCK_DESCRIPTION;
 		break;
-	case PORT_DATA_SET:
+	case TLV_PORT_DATA_SET:
 		len += sizeof(struct portDS);
 		break;
-	case PORT_DATA_SET_NP:
+	case TLV_PORT_DATA_SET_NP:
 		len += sizeof(struct port_ds_np);
 		break;
-	case LOG_ANNOUNCE_INTERVAL:
-	case ANNOUNCE_RECEIPT_TIMEOUT:
-	case LOG_SYNC_INTERVAL:
-	case VERSION_NUMBER:
-	case DELAY_MECHANISM:
-	case LOG_MIN_PDELAY_REQ_INTERVAL:
+	case TLV_LOG_ANNOUNCE_INTERVAL:
+	case TLV_ANNOUNCE_RECEIPT_TIMEOUT:
+	case TLV_LOG_SYNC_INTERVAL:
+	case TLV_VERSION_NUMBER:
+	case TLV_DELAY_MECHANISM:
+	case TLV_LOG_MIN_PDELAY_REQ_INTERVAL:
 		len += sizeof(struct management_tlv_datum);
 		break;
 	}
@@ -237,7 +237,7 @@ int pmc_send_get_action(struct pmc *pmc, int id)
 	msg->header.messageLength = pdulen;
 	msg->tlv_count = 1;
 
-	if (id == CLOCK_DESCRIPTION && !pmc->zero_length_gets) {
+	if (id == TLV_CLOCK_DESCRIPTION && !pmc->zero_length_gets) {
 		/*
 		 * Make sure the tlv_extra pointers dereferenced in
 		 * mgt_pre_send() do point to something.
diff --git a/port.c b/port.c
index 63fabc1..080bc8e 100644
--- a/port.c
+++ b/port.c
@@ -622,11 +622,11 @@ static int port_management_fill_response(struct port *target,
 	tlv->id = id;
 
 	switch (id) {
-	case NULL_MANAGEMENT:
+	case TLV_NULL_MANAGEMENT:
 		datalen = 0;
 		respond = 1;
 		break;
-	case CLOCK_DESCRIPTION:
+	case TLV_CLOCK_DESCRIPTION:
 		cd = &rsp->last_tlv.cd;
 		buf = tlv->data;
 		cd->clockType = (UInteger16 *) buf;
@@ -692,7 +692,7 @@ static int port_management_fill_response(struct port *target,
 		datalen = buf - tlv->data;
 		respond = 1;
 		break;
-	case PORT_DATA_SET:
+	case TLV_PORT_DATA_SET:
 		pds = (struct portDS *) tlv->data;
 		pds->portIdentity            = target->portIdentity;
 		if (target->state == PS_GRAND_MASTER) {
@@ -715,31 +715,31 @@ static int port_management_fill_response(struct port *target,
 		datalen = sizeof(*pds);
 		respond = 1;
 		break;
-	case LOG_ANNOUNCE_INTERVAL:
+	case TLV_LOG_ANNOUNCE_INTERVAL:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = target->logAnnounceInterval;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case ANNOUNCE_RECEIPT_TIMEOUT:
+	case TLV_ANNOUNCE_RECEIPT_TIMEOUT:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = target->announceReceiptTimeout;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case LOG_SYNC_INTERVAL:
+	case TLV_LOG_SYNC_INTERVAL:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = target->logSyncInterval;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case VERSION_NUMBER:
+	case TLV_VERSION_NUMBER:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = target->versionNumber;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case DELAY_MECHANISM:
+	case TLV_DELAY_MECHANISM:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		if (target->delayMechanism)
 			mtd->val = target->delayMechanism;
@@ -748,20 +748,20 @@ static int port_management_fill_response(struct port *target,
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case LOG_MIN_PDELAY_REQ_INTERVAL:
+	case TLV_LOG_MIN_PDELAY_REQ_INTERVAL:
 		mtd = (struct management_tlv_datum *) tlv->data;
 		mtd->val = target->logMinPdelayReqInterval;
 		datalen = sizeof(*mtd);
 		respond = 1;
 		break;
-	case PORT_DATA_SET_NP:
+	case TLV_PORT_DATA_SET_NP:
 		pdsnp = (struct port_ds_np *) tlv->data;
 		pdsnp->neighborPropDelayThresh = target->neighborPropDelayThresh;
 		pdsnp->asCapable = target->asCapable;
 		datalen = sizeof(*pdsnp);
 		respond = 1;
 		break;
-	case PORT_PROPERTIES_NP:
+	case TLV_PORT_PROPERTIES_NP:
 		ppn = (struct port_properties_np *)tlv->data;
 		ppn->portIdentity = target->portIdentity;
 		if (target->state == PS_GRAND_MASTER)
@@ -816,7 +816,7 @@ static int port_management_set(struct port *target,
 	tlv = (struct management_tlv *) req->management.suffix;
 
 	switch (id) {
-	case PORT_DATA_SET_NP:
+	case TLV_PORT_DATA_SET_NP:
 		pdsnp = (struct port_ds_np *) tlv->data;
 		target->neighborPropDelayThresh = pdsnp->neighborPropDelayThresh;
 		respond = 1;
@@ -2243,27 +2243,27 @@ int port_manage(struct port *p, struct port *ingress, struct ptp_message *msg)
 	}
 
 	switch (mgt->id) {
-	case NULL_MANAGEMENT:
-	case CLOCK_DESCRIPTION:
-	case PORT_DATA_SET:
-	case LOG_ANNOUNCE_INTERVAL:
-	case ANNOUNCE_RECEIPT_TIMEOUT:
-	case LOG_SYNC_INTERVAL:
-	case VERSION_NUMBER:
-	case ENABLE_PORT:
-	case DISABLE_PORT:
-	case UNICAST_NEGOTIATION_ENABLE:
-	case UNICAST_MASTER_TABLE:
-	case UNICAST_MASTER_MAX_TABLE_SIZE:
-	case ACCEPTABLE_MASTER_TABLE_ENABLED:
-	case ALTERNATE_MASTER:
-	case TRANSPARENT_CLOCK_PORT_DATA_SET:
-	case DELAY_MECHANISM:
-	case LOG_MIN_PDELAY_REQ_INTERVAL:
-		port_management_send_error(p, ingress, msg, NOT_SUPPORTED);
+	case TLV_NULL_MANAGEMENT:
+	case TLV_CLOCK_DESCRIPTION:
+	case TLV_PORT_DATA_SET:
+	case TLV_LOG_ANNOUNCE_INTERVAL:
+	case TLV_ANNOUNCE_RECEIPT_TIMEOUT:
+	case TLV_LOG_SYNC_INTERVAL:
+	case TLV_VERSION_NUMBER:
+	case TLV_ENABLE_PORT:
+	case TLV_DISABLE_PORT:
+	case TLV_UNICAST_NEGOTIATION_ENABLE:
+	case TLV_UNICAST_MASTER_TABLE:
+	case TLV_UNICAST_MASTER_MAX_TABLE_SIZE:
+	case TLV_ACCEPTABLE_MASTER_TABLE_ENABLED:
+	case TLV_ALTERNATE_MASTER:
+	case TLV_TRANSPARENT_CLOCK_PORT_DATA_SET:
+	case TLV_DELAY_MECHANISM:
+	case TLV_LOG_MIN_PDELAY_REQ_INTERVAL:
+		port_management_send_error(p, ingress, msg, TLV_NOT_SUPPORTED);
 		break;
 	default:
-		port_management_send_error(p, ingress, msg, NO_SUCH_ID);
+		port_management_send_error(p, ingress, msg, TLV_NO_SUCH_ID);
 		return -1;
 	}
 	return 1;
@@ -2367,7 +2367,7 @@ void port_notify_event(struct port *p, enum notification event)
 
 	switch (event) {
 	case NOTIFY_PORT_STATE:
-		id = PORT_DATA_SET;
+		id = TLV_PORT_DATA_SET;
 		break;
 	default:
 		return;
diff --git a/tlv.c b/tlv.c
index 4593c77..cef10a0 100644
--- a/tlv.c
+++ b/tlv.c
@@ -69,7 +69,7 @@ static int mgt_post_recv(struct management_tlv *m, uint16_t data_len,
 	uint8_t *buf;
 	uint16_t u16;
 	switch (m->id) {
-	case CLOCK_DESCRIPTION:
+	case TLV_CLOCK_DESCRIPTION:
 		cd = &extra->cd;
 		buf = m->data;
 		len = data_len;
@@ -168,14 +168,14 @@ static int mgt_post_recv(struct management_tlv *m, uint16_t data_len,
 
 		extra_len = buf - m->data;
 		break;
-	case USER_DESCRIPTION:
+	case TLV_USER_DESCRIPTION:
 		if (data_len < sizeof(struct PTPText))
 			goto bad_length;
 		extra->cd.userDescription = (struct PTPText *) m->data;
 		extra_len = sizeof(struct PTPText);
 		extra_len += extra->cd.userDescription->length;
 		break;
-	case DEFAULT_DATA_SET:
+	case TLV_DEFAULT_DATA_SET:
 		if (data_len != sizeof(struct defaultDS))
 			goto bad_length;
 		dds = (struct defaultDS *) m->data;
@@ -183,7 +183,7 @@ static int mgt_post_recv(struct management_tlv *m, uint16_t data_len,
 		dds->clockQuality.offsetScaledLogVariance =
 			ntohs(dds->clockQuality.offsetScaledLogVariance);
 		break;
-	case CURRENT_DATA_SET:
+	case TLV_CURRENT_DATA_SET:
 		if (data_len != sizeof(struct currentDS))
 			goto bad_length;
 		cds = (struct currentDS *) m->data;
@@ -191,7 +191,7 @@ static int mgt_post_recv(struct management_tlv *m, uint16_t data_len,
 		cds->offsetFromMaster = net2host64(cds->offsetFromMaster);
 		cds->meanPathDelay = net2host64(cds->meanPathDelay);
 		break;
-	case PARENT_DATA_SET:
+	case TLV_PARENT_DATA_SET:
 		if (data_len != sizeof(struct parentDS))
 			goto bad_length;
 		pds = (struct parentDS *) m->data;
@@ -204,20 +204,20 @@ static int mgt_post_recv(struct management_tlv *m, uint16_t data_len,
 		pds->grandmasterClockQuality.offsetScaledLogVariance =
 			ntohs(pds->grandmasterClockQuality.offsetScaledLogVariance);
 		break;
-	case TIME_PROPERTIES_DATA_SET:
+	case TLV_TIME_PROPERTIES_DATA_SET:
 		if (data_len != sizeof(struct timePropertiesDS))
 			goto bad_length;
 		tp = (struct timePropertiesDS *) m->data;
 		tp->currentUtcOffset = ntohs(tp->currentUtcOffset);
 		break;
-	case PORT_DATA_SET:
+	case TLV_PORT_DATA_SET:
 		if (data_len != sizeof(struct portDS))
 			goto bad_length;
 		p = (struct portDS *) m->data;
 		p->portIdentity.portNumber = ntohs(p->portIdentity.portNumber);
 		p->peerMeanPathDelay = net2host64(p->peerMeanPathDelay);
 		break;
-	case TIME_STATUS_NP:
+	case TLV_TIME_STATUS_NP:
 		if (data_len != sizeof(struct time_status_np))
 			goto bad_length;
 		tsn = (struct time_status_np *) m->data;
@@ -229,7 +229,7 @@ static int mgt_post_recv(struct management_tlv *m, uint16_t data_len,
 		scaled_ns_n2h(&tsn->lastGmPhaseChange);
 		tsn->gmPresent = ntohl(tsn->gmPresent);
 		break;
-	case GRANDMASTER_SETTINGS_NP:
+	case TLV_GRANDMASTER_SETTINGS_NP:
 		if (data_len != sizeof(struct grandmaster_settings_np))
 			goto bad_length;
 		gsn = (struct grandmaster_settings_np *) m->data;
@@ -237,20 +237,20 @@ static int mgt_post_recv(struct management_tlv *m, uint16_t data_len,
 			ntohs(gsn->clockQuality.offsetScaledLogVariance);
 		gsn->utc_offset = ntohs(gsn->utc_offset);
 		break;
-	case PORT_DATA_SET_NP:
+	case TLV_PORT_DATA_SET_NP:
 		if (data_len != sizeof(struct port_ds_np))
 			goto bad_length;
 		pdsnp = (struct port_ds_np *) m->data;
 		pdsnp->neighborPropDelayThresh = ntohl(pdsnp->neighborPropDelayThresh);
 		pdsnp->asCapable = ntohl(pdsnp->asCapable);
 		break;
-	case SUBSCRIBE_EVENTS_NP:
+	case TLV_SUBSCRIBE_EVENTS_NP:
 		if (data_len != sizeof(struct subscribe_events_np))
 			goto bad_length;
 		sen = (struct subscribe_events_np *)m->data;
 		sen->duration = ntohs(sen->duration);
 		break;
-	case PORT_PROPERTIES_NP:
+	case TLV_PORT_PROPERTIES_NP:
 		if (data_len < sizeof(struct port_properties_np))
 			goto bad_length;
 		ppn = (struct port_properties_np *)m->data;
@@ -258,12 +258,12 @@ static int mgt_post_recv(struct management_tlv *m, uint16_t data_len,
 		extra_len = sizeof(struct port_properties_np);
 		extra_len += ppn->interface.length;
 		break;
-	case SAVE_IN_NON_VOLATILE_STORAGE:
-	case RESET_NON_VOLATILE_STORAGE:
-	case INITIALIZE:
-	case FAULT_LOG_RESET:
-	case ENABLE_PORT:
-	case DISABLE_PORT:
+	case TLV_SAVE_IN_NON_VOLATILE_STORAGE:
+	case TLV_RESET_NON_VOLATILE_STORAGE:
+	case TLV_INITIALIZE:
+	case TLV_FAULT_LOG_RESET:
+	case TLV_ENABLE_PORT:
+	case TLV_DISABLE_PORT:
 		if (data_len != 0)
 			goto bad_length;
 		break;
@@ -293,7 +293,7 @@ static void mgt_pre_send(struct management_tlv *m, struct tlv_extra *extra)
 	struct port_properties_np *ppn;
 	struct mgmt_clock_description *cd;
 	switch (m->id) {
-	case CLOCK_DESCRIPTION:
+	case TLV_CLOCK_DESCRIPTION:
 		if (extra) {
 			cd = &extra->cd;
 			flip16(cd->clockType);
@@ -302,19 +302,19 @@ static void mgt_pre_send(struct management_tlv *m, struct tlv_extra *extra)
 			flip16(&cd->protocolAddress->addressLength);
 		}
 		break;
-	case DEFAULT_DATA_SET:
+	case TLV_DEFAULT_DATA_SET:
 		dds = (struct defaultDS *) m->data;
 		dds->numberPorts = htons(dds->numberPorts);
 		dds->clockQuality.offsetScaledLogVariance =
 			htons(dds->clockQuality.offsetScaledLogVariance);
 		break;
-	case CURRENT_DATA_SET:
+	case TLV_CURRENT_DATA_SET:
 		cds = (struct currentDS *) m->data;
 		cds->stepsRemoved = htons(cds->stepsRemoved);
 		cds->offsetFromMaster = host2net64(cds->offsetFromMaster);
 		cds->meanPathDelay = host2net64(cds->meanPathDelay);
 		break;
-	case PARENT_DATA_SET:
+	case TLV_PARENT_DATA_SET:
 		pds = (struct parentDS *) m->data;
 		pds->parentPortIdentity.portNumber =
 			htons(pds->parentPortIdentity.portNumber);
@@ -325,16 +325,16 @@ static void mgt_pre_send(struct management_tlv *m, struct tlv_extra *extra)
 		pds->grandmasterClockQuality.offsetScaledLogVariance =
 			htons(pds->grandmasterClockQuality.offsetScaledLogVariance);
 		break;
-	case TIME_PROPERTIES_DATA_SET:
+	case TLV_TIME_PROPERTIES_DATA_SET:
 		tp = (struct timePropertiesDS *) m->data;
 		tp->currentUtcOffset = htons(tp->currentUtcOffset);
 		break;
-	case PORT_DATA_SET:
+	case TLV_PORT_DATA_SET:
 		p = (struct portDS *) m->data;
 		p->portIdentity.portNumber = htons(p->portIdentity.portNumber);
 		p->peerMeanPathDelay = host2net64(p->peerMeanPathDelay);
 		break;
-	case TIME_STATUS_NP:
+	case TLV_TIME_STATUS_NP:
 		tsn = (struct time_status_np *) m->data;
 		tsn->master_offset = host2net64(tsn->master_offset);
 		tsn->ingress_time = host2net64(tsn->ingress_time);
@@ -344,22 +344,22 @@ static void mgt_pre_send(struct management_tlv *m, struct tlv_extra *extra)
 		scaled_ns_h2n(&tsn->lastGmPhaseChange);
 		tsn->gmPresent = htonl(tsn->gmPresent);
 		break;
-	case GRANDMASTER_SETTINGS_NP:
+	case TLV_GRANDMASTER_SETTINGS_NP:
 		gsn = (struct grandmaster_settings_np *) m->data;
 		gsn->clockQuality.offsetScaledLogVariance =
 			htons(gsn->clockQuality.offsetScaledLogVariance);
 		gsn->utc_offset = htons(gsn->utc_offset);
 		break;
-	case PORT_DATA_SET_NP:
+	case TLV_PORT_DATA_SET_NP:
 		pdsnp = (struct port_ds_np *) m->data;
 		pdsnp->neighborPropDelayThresh = htonl(pdsnp->neighborPropDelayThresh);
 		pdsnp->asCapable = htonl(pdsnp->asCapable);
 		break;
-	case SUBSCRIBE_EVENTS_NP:
+	case TLV_SUBSCRIBE_EVENTS_NP:
 		sen = (struct subscribe_events_np *)m->data;
 		sen->duration = htons(sen->duration);
 		break;
-	case PORT_PROPERTIES_NP:
+	case TLV_PORT_PROPERTIES_NP:
 		ppn = (struct port_properties_np *)m->data;
 		ppn->portIdentity.portNumber = htons(ppn->portIdentity.portNumber);
 		break;
diff --git a/tlv.h b/tlv.h
index a4bc2ce..504e269 100644
--- a/tlv.h
+++ b/tlv.h
@@ -47,69 +47,69 @@ enum management_action {
 };
 
 /* Clock management ID values */
-#define USER_DESCRIPTION				0x0002
-#define SAVE_IN_NON_VOLATILE_STORAGE			0x0003
-#define RESET_NON_VOLATILE_STORAGE			0x0004
-#define INITIALIZE					0x0005
-#define FAULT_LOG					0x0006
-#define FAULT_LOG_RESET					0x0007
-#define DEFAULT_DATA_SET				0x2000
-#define CURRENT_DATA_SET				0x2001
-#define PARENT_DATA_SET					0x2002
-#define TIME_PROPERTIES_DATA_SET			0x2003
-#define PRIORITY1					0x2005
-#define PRIORITY2					0x2006
-#define DOMAIN						0x2007
-#define SLAVE_ONLY					0x2008
-#define TIME						0x200F
-#define CLOCK_ACCURACY					0x2010
-#define UTC_PROPERTIES					0x2011
-#define TRACEABILITY_PROPERTIES				0x2012
-#define TIMESCALE_PROPERTIES				0x2013
-#define PATH_TRACE_LIST					0x2015
-#define PATH_TRACE_ENABLE				0x2016
-#define GRANDMASTER_CLUSTER_TABLE			0x2017
-#define ACCEPTABLE_MASTER_TABLE				0x201A
-#define ACCEPTABLE_MASTER_MAX_TABLE_SIZE		0x201C
-#define ALTERNATE_TIME_OFFSET_ENABLE			0x201E
-#define ALTERNATE_TIME_OFFSET_NAME			0x201F
-#define ALTERNATE_TIME_OFFSET_MAX_KEY			0x2020
-#define ALTERNATE_TIME_OFFSET_PROPERTIES		0x2021
-#define TRANSPARENT_CLOCK_DEFAULT_DATA_SET		0x4000
-#define PRIMARY_DOMAIN					0x4002
-#define TIME_STATUS_NP					0xC000
-#define GRANDMASTER_SETTINGS_NP				0xC001
-#define SUBSCRIBE_EVENTS_NP				0xC003
+#define TLV_USER_DESCRIPTION				0x0002
+#define TLV_SAVE_IN_NON_VOLATILE_STORAGE		0x0003
+#define TLV_RESET_NON_VOLATILE_STORAGE			0x0004
+#define TLV_INITIALIZE					0x0005
+#define TLV_FAULT_LOG					0x0006
+#define TLV_FAULT_LOG_RESET				0x0007
+#define TLV_DEFAULT_DATA_SET				0x2000
+#define TLV_CURRENT_DATA_SET				0x2001
+#define TLV_PARENT_DATA_SET				0x2002
+#define TLV_TIME_PROPERTIES_DATA_SET			0x2003
+#define TLV_PRIORITY1					0x2005
+#define TLV_PRIORITY2					0x2006
+#define TLV_DOMAIN					0x2007
+#define TLV_SLAVE_ONLY					0x2008
+#define TLV_TIME					0x200F
+#define TLV_CLOCK_ACCURACY				0x2010
+#define TLV_UTC_PROPERTIES				0x2011
+#define TLV_TRACEABILITY_PROPERTIES			0x2012
+#define TLV_TIMESCALE_PROPERTIES			0x2013
+#define TLV_PATH_TRACE_LIST				0x2015
+#define TLV_PATH_TRACE_ENABLE				0x2016
+#define TLV_GRANDMASTER_CLUSTER_TABLE			0x2017
+#define TLV_ACCEPTABLE_MASTER_TABLE			0x201A
+#define TLV_ACCEPTABLE_MASTER_MAX_TABLE_SIZE		0x201C
+#define TLV_ALTERNATE_TIME_OFFSET_ENABLE		0x201E
+#define TLV_ALTERNATE_TIME_OFFSET_NAME			0x201F
+#define TLV_ALTERNATE_TIME_OFFSET_MAX_KEY		0x2020
+#define TLV_ALTERNATE_TIME_OFFSET_PROPERTIES		0x2021
+#define TLV_TRANSPARENT_CLOCK_DEFAULT_DATA_SET		0x4000
+#define TLV_PRIMARY_DOMAIN				0x4002
+#define TLV_TIME_STATUS_NP				0xC000
+#define TLV_GRANDMASTER_SETTINGS_NP			0xC001
+#define TLV_SUBSCRIBE_EVENTS_NP				0xC003
 
 /* Port management ID values */
-#define NULL_MANAGEMENT					0x0000
-#define CLOCK_DESCRIPTION				0x0001
-#define PORT_DATA_SET					0x2004
-#define LOG_ANNOUNCE_INTERVAL				0x2009
-#define ANNOUNCE_RECEIPT_TIMEOUT			0x200A
-#define LOG_SYNC_INTERVAL				0x200B
-#define VERSION_NUMBER					0x200C
-#define ENABLE_PORT					0x200D
-#define DISABLE_PORT					0x200E
-#define UNICAST_NEGOTIATION_ENABLE			0x2014
-#define UNICAST_MASTER_TABLE				0x2018
-#define UNICAST_MASTER_MAX_TABLE_SIZE			0x2019
-#define ACCEPTABLE_MASTER_TABLE_ENABLED			0x201B
-#define ALTERNATE_MASTER				0x201D
-#define TRANSPARENT_CLOCK_PORT_DATA_SET			0x4001
-#define DELAY_MECHANISM					0x6000
-#define LOG_MIN_PDELAY_REQ_INTERVAL			0x6001
-#define PORT_DATA_SET_NP					0xC002
-#define PORT_PROPERTIES_NP				0xC004
+#define TLV_NULL_MANAGEMENT				0x0000
+#define TLV_CLOCK_DESCRIPTION				0x0001
+#define TLV_PORT_DATA_SET				0x2004
+#define TLV_LOG_ANNOUNCE_INTERVAL			0x2009
+#define TLV_ANNOUNCE_RECEIPT_TIMEOUT			0x200A
+#define TLV_LOG_SYNC_INTERVAL				0x200B
+#define TLV_VERSION_NUMBER				0x200C
+#define TLV_ENABLE_PORT					0x200D
+#define TLV_DISABLE_PORT				0x200E
+#define TLV_UNICAST_NEGOTIATION_ENABLE			0x2014
+#define TLV_UNICAST_MASTER_TABLE			0x2018
+#define TLV_UNICAST_MASTER_MAX_TABLE_SIZE		0x2019
+#define TLV_ACCEPTABLE_MASTER_TABLE_ENABLED		0x201B
+#define TLV_ALTERNATE_MASTER				0x201D
+#define TLV_TRANSPARENT_CLOCK_PORT_DATA_SET		0x4001
+#define TLV_DELAY_MECHANISM				0x6000
+#define TLV_LOG_MIN_PDELAY_REQ_INTERVAL			0x6001
+#define TLV_PORT_DATA_SET_NP				0xC002
+#define TLV_PORT_PROPERTIES_NP				0xC004
 
 /* Management error ID values */
-#define RESPONSE_TOO_BIG				0x0001
-#define NO_SUCH_ID					0x0002
-#define WRONG_LENGTH					0x0003
-#define WRONG_VALUE					0x0004
-#define NOT_SETABLE					0x0005
-#define NOT_SUPPORTED					0x0006
-#define GENERAL_ERROR					0xFFFE
+#define TLV_RESPONSE_TOO_BIG				0x0001
+#define TLV_NO_SUCH_ID					0x0002
+#define TLV_WRONG_LENGTH				0x0003
+#define TLV_WRONG_VALUE					0x0004
+#define TLV_NOT_SETABLE					0x0005
+#define TLV_NOT_SUPPORTED				0x0006
+#define TLV_GENERAL_ERROR				0xFFFE
 
 struct management_tlv {
 	Enumeration16 type;