diff --git a/src/channels/chan_voicemngr.c b/src/channels/chan_voicemngr.c
index 60ade124b0952eae4b8c978b7f52c5a369e92252..7c114483c294b28cf9497b7a06b7535e0067687c 100644
--- a/src/channels/chan_voicemngr.c
+++ b/src/channels/chan_voicemngr.c
@@ -25,7 +25,7 @@
  * \ingroup channel_drivers
  */
 
-//	#define BRCM_LOCK_DEBUG		/* If defined we will log lock events to the asterisk debug channel */
+//	#define CHAN_VOICEMNGR_LOCK_DEBUG		/* If defined we will log lock events to the asterisk debug channel */
 
 #include "asterisk.h"
 
@@ -72,62 +72,62 @@
 #define AST_MODULE "chan_voicemngr"
 #endif
 
-static void brcm_dialtone_set(struct brcm_pvt *p, dialtone_state state);
-static int brcm_signal_dialtone(struct brcm_pvt *p);
-static int brcm_in_conference(const struct brcm_pvt *p);
+static void chan_voicemngr_dialtone_set(struct chan_voicemngr_pvt *p, dialtone_state state);
+static int chan_voicemngr_signal_dialtone(struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_in_conference(const struct chan_voicemngr_pvt *p);
 static int cwtimeout_cb(const void *data);
 static int cwbeep_cb(const void *data);
 static int r4hanguptimeout_cb(const void *data);
-static void brcm_generate_rtp_packet(struct brcm_subchannel *p, uint8_t *packet_buf, int type, int marker, int dtmf_timestamp, int seqno);
-static void brcm_process_rtcp_packet(struct brcm_subchannel *p, uint8_t *rtcp_frame, uint32_t rtcp_size);
-static int brcm_mute_connection(struct brcm_subchannel *p);
-static int brcm_unmute_connection(struct brcm_subchannel *p);
-static int brcm_close_connection(struct brcm_subchannel *p);
-static int brcm_create_conference(struct brcm_pvt *p);
-static int brcm_stop_conference(struct brcm_subchannel *p);
-static void brcm_attended_call_transfer(struct brcm_subchannel *sub, struct brcm_subchannel *sub_peer,
+static void chan_voicemngr_generate_rtp_packet(struct chan_voicemngr_subchannel *p, uint8_t *packet_buf, int type, int marker, int dtmf_timestamp, int seqno);
+static void chan_voicemngr_process_rtcp_packet(struct chan_voicemngr_subchannel *p, uint8_t *rtcp_frame, uint32_t rtcp_size);
+static int chan_voicemngr_mute_connection(struct chan_voicemngr_subchannel *p);
+static int chan_voicemngr_unmute_connection(struct chan_voicemngr_subchannel *p);
+static int chan_voicemngr_close_connection(struct chan_voicemngr_subchannel *p);
+static int chan_voicemngr_create_conference(struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_stop_conference(struct chan_voicemngr_subchannel *p);
+static void chan_voicemngr_attended_call_transfer(struct chan_voicemngr_subchannel *sub, struct chan_voicemngr_subchannel *sub_peer,
 		struct ast_channel *owner, struct ast_channel *peer_owner);
-static void brcm_unattended_call_transfer(struct brcm_subchannel *sub, struct brcm_subchannel *sub_peer,
+static void chan_voicemngr_unattended_call_transfer(struct chan_voicemngr_subchannel *sub, struct chan_voicemngr_subchannel *sub_peer,
 		struct ast_channel *owner, struct ast_channel *peer_owner);
-static int brcm_finish_transfer(struct ast_channel *owner, struct brcm_subchannel *p, int result);
-static int brcm_call(struct ast_channel *ast, const char *dest, int timeout);
-static int brcm_devicestate(const char *device_number);
-static int brcm_hangup(struct ast_channel *ast);
-static int brcm_getRtpStats(struct ast_channel *ast);
-static int brcm_answer(struct ast_channel *ast);
-static struct ast_frame *brcm_read(struct ast_channel *ast);
-static int brcm_write(struct ast_channel *ast, struct ast_frame *frame);
-static int brcm_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
-static int brcm_transfer(struct ast_channel *ast, const char *newdest);
-static int brcm_senddigit_begin(struct ast_channel *ast, char digit);
-static int brcm_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration);
-static int brcm_in_call(const struct brcm_pvt *p);
-static int brcm_in_callwaiting(const struct brcm_pvt *p);
-static int brcm_in_onhold(const struct brcm_pvt *p);
-static int brcm_subchannel_is_idle(const struct brcm_subchannel *sub);
-static struct ast_channel *brcm_request(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *dest, int *cause);
-static void brcm_lock_pvts(void);
-static void brcm_unlock_pvts(void);
-static struct brcm_pvt* brcm_get_next_pvt(struct brcm_pvt *p);
+static int chan_voicemngr_finish_transfer(struct ast_channel *owner, struct chan_voicemngr_subchannel *p, int result);
+static int chan_voicemngr_call(struct ast_channel *ast, const char *dest, int timeout);
+static int chan_voicemngr_devicestate(const char *device_number);
+static int chan_voicemngr_hangup(struct ast_channel *ast);
+static int chan_voicemngr_getRtpStats(struct ast_channel *ast);
+static int chan_voicemngr_answer(struct ast_channel *ast);
+static struct ast_frame *chan_voicemngr_read(struct ast_channel *ast);
+static int chan_voicemngr_write(struct ast_channel *ast, struct ast_frame *frame);
+static int chan_voicemngr_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
+static int chan_voicemngr_transfer(struct ast_channel *ast, const char *newdest);
+static int chan_voicemngr_senddigit_begin(struct ast_channel *ast, char digit);
+static int chan_voicemngr_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration);
+static int chan_voicemngr_in_call(const struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_in_callwaiting(const struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_in_onhold(const struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_subchannel_is_idle(const struct chan_voicemngr_subchannel *sub);
+static struct ast_channel *chan_voicemngr_request(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *dest, int *cause);
+static void chan_voicemngr_lock_pvts(void);
+static void chan_voicemngr_unlock_pvts(void);
+static struct chan_voicemngr_pvt* chan_voicemngr_get_next_pvt(struct chan_voicemngr_pvt *p);
 static void *pe_base_run(void *unused);
-static int brcm_create_connection(struct brcm_subchannel *p);
-static int brcm_stop_dialtone(struct brcm_pvt *p);
-static void brcm_signal_howler(struct brcm_pvt *p);
-static int brcm_signal_ringing(struct brcm_pvt *p);
-static int brcm_stop_ringing(struct brcm_pvt *p);
-static int brcm_signal_ringing_callerid_pending(struct brcm_pvt *p);
-static int brcm_stop_ringing_callerid_pending(struct brcm_pvt *p);
-static int brcm_signal_callwaiting(const struct brcm_pvt *p);
-static int brcm_stop_callwaiting(const struct brcm_pvt *p);
-static int brcm_signal_callerid(struct ast_channel *chan, struct brcm_subchannel *sub);
-static struct brcm_subchannel *brcm_get_idle_subchannel(const struct brcm_pvt *p);
-static struct brcm_subchannel* brcm_get_active_subchannel(const struct brcm_pvt *p);
-static struct brcm_subchannel *brcm_subchannel_get_peer(const struct brcm_subchannel *sub);
-static struct brcm_pvt* brcm_get_pvt_from_lineid(struct brcm_pvt *p, int line_id);
-static void handle_dtmf_calling(struct brcm_subchannel *sub);
-static void brcm_cancel_dialing_timeouts(struct brcm_pvt *p);
-static int brcm_should_relay_dtmf(const struct brcm_subchannel *sub);
-static struct ast_channel *brcm_new(struct brcm_subchannel *subchan, int state, const char *ext, const char *context,
+static int chan_voicemngr_create_connection(struct chan_voicemngr_subchannel *p);
+static int chan_voicemngr_stop_dialtone(struct chan_voicemngr_pvt *p);
+static void chan_voicemngr_signal_howler(struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_signal_ringing(struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_stop_ringing(struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_signal_ringing_callerid_pending(struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_stop_ringing_callerid_pending(struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_signal_callwaiting(const struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_stop_callwaiting(const struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_signal_callerid(struct ast_channel *chan, struct chan_voicemngr_subchannel *sub);
+static struct chan_voicemngr_subchannel *chan_voicemngr_get_idle_subchannel(const struct chan_voicemngr_pvt *p);
+static struct chan_voicemngr_subchannel* chan_voicemngr_get_active_subchannel(const struct chan_voicemngr_pvt *p);
+static struct chan_voicemngr_subchannel *chan_voicemngr_subchannel_get_peer(const struct chan_voicemngr_subchannel *sub);
+static struct chan_voicemngr_pvt* chan_voicemngr_get_pvt_from_lineid(struct chan_voicemngr_pvt *p, int line_id);
+static void handle_dtmf_calling(struct chan_voicemngr_subchannel *sub);
+static void chan_voicemngr_cancel_dialing_timeouts(struct chan_voicemngr_pvt *p);
+static int chan_voicemngr_should_relay_dtmf(const struct chan_voicemngr_subchannel *sub);
+static struct ast_channel *chan_voicemngr_new(struct chan_voicemngr_subchannel *subchan, int state, const char *ext, const char *context,
 		const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor,
 		struct ast_format_cap *format);
 static int handle_dialtone_timeout(const void *data);
@@ -145,8 +145,8 @@ static struct ast_jb_conf default_jbconf =
 	.target_extra = -1,
 };
 
-/* Global brcm channel parameters */
-static const char tdesc[] = "Broadcom SLIC Driver";
+/* Global chan_voicemngr channel parameters */
+static const char tdesc[] = "Voice SLIC Driver";
 static const char config[] = "chan_telephony.conf";
 static const char broadcast_path[] = "voice.line";
 static channel_settings channel_config[MAX_NUM_LINEID];
@@ -425,9 +425,9 @@ static const DTMF_CHARNAME_MAP dtmf_to_charname[] =
 };
 
 /* Linked list of pvt:s */
-static struct brcm_pvt *iflist;
+static struct chan_voicemngr_pvt *iflist;
 
-/* Protect the interface list (of brcm_pvt's) */
+/* Protect the interface list (of chan_voicemngr_pvt's) */
 AST_MUTEX_DEFINE_STATIC(iflock);
 
 /* Protect the monitoring thread, so only one process can kill or start it, and not
@@ -438,37 +438,37 @@ static struct ast_format_cap *default_cap;
 
 static int load_common_settings(struct ast_config **cfg);
 static void load_settings(struct ast_config *cfg);
-static char *state2str(enum brcm_channel_state state);
+static char *state2str(enum chan_voicemngr_channel_state state);
 
 /* exported capabilities */
-static struct ast_channel_tech brcm_tech = {
+static struct ast_channel_tech chan_voicemngr_tech = {
 	.type = "TELCHAN",
 	.description = tdesc,
-	.requester = brcm_request,			//No lock held (no channel yet)
-	.call = brcm_call,				//Channel is locked
-	.hangup = brcm_hangup,				//Channel is locked
-	.answer = brcm_answer,				//Channel is locked
-	.read = brcm_read,				//Channel is locked
-	.write = brcm_write,				//Channel is locked
-	.send_digit_begin = brcm_senddigit_begin,	//Channel is NOT locked
-	.getRtpStats = brcm_getRtpStats,	//Channel is NOT locked
-	.send_digit_end = brcm_senddigit_end,		//Channel is NOT locked
-	.indicate = brcm_indicate,			//Channel is locked
-	.transfer = brcm_transfer,			// Channel is locked
-	.devicestate = brcm_devicestate			// Channel is NOT locked
+	.requester = chan_voicemngr_request,			//No lock held (no channel yet)
+	.call = chan_voicemngr_call,				//Channel is locked
+	.hangup = chan_voicemngr_hangup,				//Channel is locked
+	.answer = chan_voicemngr_answer,				//Channel is locked
+	.read = chan_voicemngr_read,				//Channel is locked
+	.write = chan_voicemngr_write,				//Channel is locked
+	.send_digit_begin = chan_voicemngr_senddigit_begin,	//Channel is NOT locked
+	.getRtpStats = chan_voicemngr_getRtpStats,	//Channel is NOT locked
+	.send_digit_end = chan_voicemngr_senddigit_end,		//Channel is NOT locked
+	.indicate = chan_voicemngr_indicate,			//Channel is locked
+	.transfer = chan_voicemngr_transfer,			// Channel is locked
+	.devicestate = chan_voicemngr_devicestate			// Channel is NOT locked
 };
 
-static struct brcm_channel_tech fxs_tech = {
-	.signal_ringing = brcm_signal_ringing,
-	.signal_ringing_callerid_pending = brcm_signal_ringing_callerid_pending,
-	.signal_callerid = brcm_signal_callerid,
-	.stop_ringing = brcm_stop_ringing,
-	.stop_ringing_callerid_pending = brcm_stop_ringing_callerid_pending,
+static struct chan_voicemngr_channel_tech fxs_tech = {
+	.signal_ringing = chan_voicemngr_signal_ringing,
+	.signal_ringing_callerid_pending = chan_voicemngr_signal_ringing_callerid_pending,
+	.signal_callerid = chan_voicemngr_signal_callerid,
+	.stop_ringing = chan_voicemngr_stop_ringing,
+	.stop_ringing_callerid_pending = chan_voicemngr_stop_ringing_callerid_pending,
 	.release = NULL,
 };
 
 /* Tries to lock 10 timees, then gives up */
-/* static int pvt_trylock(struct brcm_pvt *pvt, const char *reason) */
+/* static int pvt_trylock(struct chan_voicemngr_pvt *pvt, const char *reason) */
 /* { */
 /* 	int i = 10; */
 /* 	while (i--) { */
@@ -481,8 +481,8 @@ static struct brcm_channel_tech fxs_tech = {
 /* 	return 0; */
 /* } */
 
-#ifdef BRCM_LOCK_DEBUG
-static int pvt_lock(struct brcm_pvt *pvt, const char *reason)
+#ifdef CHAN_VOICEMNGR_LOCK_DEBUG
+static int pvt_lock(struct chan_voicemngr_pvt *pvt, const char *reason)
 {
 	ast_debug(9, "----> Trying to lock port %d - %s\n", pvt->line_id, reason);
 	ast_mutex_lock(&pvt->lock);
@@ -491,21 +491,21 @@ static int pvt_lock(struct brcm_pvt *pvt, const char *reason)
 }
 
 
-static int pvt_lock_silent(struct brcm_pvt *pvt)
+static int pvt_lock_silent(struct chan_voicemngr_pvt *pvt)
 {
 	ast_mutex_lock(&pvt->lock);
 	return 1;
 }
 
 
-static int pvt_unlock(struct brcm_pvt *pvt)
+static int pvt_unlock(struct chan_voicemngr_pvt *pvt)
 {
 	ast_mutex_unlock(&pvt->lock);
 	ast_debug(10, "----> Unlocking pvt port %d\n", pvt->line_id);
 	return 1;
 }
 
-static int pvt_unlock_silent(struct brcm_pvt *pvt)
+static int pvt_unlock_silent(struct chan_voicemngr_pvt *pvt)
 {
 	ast_mutex_unlock(&pvt->lock);
 	return 1;
@@ -591,7 +591,7 @@ static void endpt_signal(int line, char *signal, char *state, char *data) {
 	}
 }
 
-static int brcm_send_ubus_event(char *ev_name, int line)
+static int chan_voicemngr_send_ubus_event(char *ev_name, int line)
 {
 	struct blob_buf blob;
 	struct ubus_context *ubusctx;
@@ -653,9 +653,9 @@ static void endpt_connection(int line, int id, char *action) {
 	}
 }
 
-static int brcm_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
+static int chan_voicemngr_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
 {
-	struct brcm_subchannel *sub = ast_channel_tech_pvt(ast);
+	struct chan_voicemngr_subchannel *sub = ast_channel_tech_pvt(ast);
 	struct ast_bridge_channel *play_bridge_channel;
 	struct ast_bridge *myBridge;
 	struct ast_frame astFrame;
@@ -667,7 +667,7 @@ static int brcm_indicate(struct ast_channel *ast, int condition, const void *dat
 	switch(condition) {
 	case AST_CONTROL_UNHOLD:
 		pvt_lock(sub->parent, "indicate");
-		brcm_stop_dialtone(sub->parent);
+		chan_voicemngr_stop_dialtone(sub->parent);
 		pvt_unlock(sub->parent);
 		// Play a beep when unholding.
 		play_bridge_channel = ast_channel_get_bridge_channel(ast);
@@ -733,12 +733,12 @@ static int brcm_indicate(struct ast_channel *ast, int condition, const void *dat
 			ast_log(LOG_ERROR, "Invalid datalen for AST_CONTROL_TRANSFER. Expected %d, got %d\n", (int) sizeof(enum ast_control_transfer), (int) datalen);
 		} else {
 			enum ast_control_transfer *message = (enum ast_control_transfer *) data;
-                        struct brcm_subchannel* peer_sub;
-                        peer_sub = brcm_subchannel_get_peer(sub);
+                        struct chan_voicemngr_subchannel* peer_sub;
+                        peer_sub = chan_voicemngr_subchannel_get_peer(sub);
 			if (peer_sub->channel_state == TRANSFERING)
-				brcm_finish_transfer(ast, peer_sub, *message);
+				chan_voicemngr_finish_transfer(ast, peer_sub, *message);
 			else
-				brcm_finish_transfer(ast, sub, *message);
+				chan_voicemngr_finish_transfer(ast, sub, *message);
 		}
 		break;
 	case AST_CONTROL_CONGESTION:
@@ -747,7 +747,7 @@ static int brcm_indicate(struct ast_channel *ast, int condition, const void *dat
 		if (ast_channel_state(ast) != AST_STATE_UP) {
 			/* If state is UP, we can't do anything */
 			ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
-			brcm_hangup(ast);
+			chan_voicemngr_hangup(ast);
 			break;
 		}
 		res = -1;
@@ -757,7 +757,7 @@ static int brcm_indicate(struct ast_channel *ast, int condition, const void *dat
 		res = -1;
 		ast_debug(4, "Got CONNECTED LINE UPDATE on %s\n", ast_channel_name(ast));
 		/* Update caller IDs on display - dect ? */
-		struct brcm_subchannel *sub_peer = brcm_subchannel_get_peer(sub);
+		struct chan_voicemngr_subchannel *sub_peer = chan_voicemngr_subchannel_get_peer(sub);
 		if ((sub->connection_id != -1) && (sub_peer->connection_id != -1)) {
 			ast_channel_lock(sub->owner);
 			struct ast_bridge *bridge = ast_channel_internal_bridge(sub->owner);
@@ -799,7 +799,7 @@ static int brcm_indicate(struct ast_channel *ast, int condition, const void *dat
 		if (ast_channel_state(ast) != AST_STATE_UP) {
 			/* XXX We should play a busy tone here!! */
 			ast_softhangup_nolock(ast, AST_SOFTHANGUP_DEV);
-			brcm_hangup(ast);
+			chan_voicemngr_hangup(ast);
 			break;
 		}
 		res = -1;
@@ -812,12 +812,12 @@ static int brcm_indicate(struct ast_channel *ast, int condition, const void *dat
 		break;
 	case AST_CONTROL_NORMAL_DIALTONE:
 		pvt_lock(sub->parent, "indicate");
-		brcm_dialtone_set(sub->parent, DIALTONE_ON);
+		chan_voicemngr_dialtone_set(sub->parent, DIALTONE_ON);
 		pvt_unlock(sub->parent);
 		break;
 	case AST_CONTROL_SPECIAL_DIALTONE:
 		pvt_lock(sub->parent, "indicate");
-		brcm_dialtone_set(sub->parent, DIALTONE_SPECIAL_CONDITION);
+		chan_voicemngr_dialtone_set(sub->parent, DIALTONE_SPECIAL_CONDITION);
 		pvt_unlock(sub->parent);
 		break;
 	case AST_CONTROL_PVT_CAUSE_CODE:
@@ -852,7 +852,7 @@ static int brcm_indicate(struct ast_channel *ast, int condition, const void *dat
 			}
 			res = -1;
 		  case AST_CAUSE_NETWORK_OUT_OF_ORDER:
-			brcm_stop_dialtone(sub->parent); // stop any dialtone exist if disconnection happened due to network/server
+			chan_voicemngr_stop_dialtone(sub->parent); // stop any dialtone exist if disconnection happened due to network/server
 			break;
 		  default:
 			ast_debug(1, "Don't know how to handle cause code %d\n", ast_cause);
@@ -869,9 +869,9 @@ static int brcm_indicate(struct ast_channel *ast, int condition, const void *dat
 	return res;
 }
 
-static int brcm_getRtpStats(struct ast_channel *ast)
+static int chan_voicemngr_getRtpStats(struct ast_channel *ast)
 {
-	struct brcm_subchannel *sub;
+	struct chan_voicemngr_subchannel *sub;
 
 	sub = ast_channel_tech_pvt(ast);
 	if (!sub) {
@@ -879,7 +879,7 @@ static int brcm_getRtpStats(struct ast_channel *ast)
 		return -1;
 	}
 
-	pvt_lock(sub->parent, "brcm_getRtpStats");
+	pvt_lock(sub->parent, "chan_voicemngr_getRtpStats");
 	if (sub->parent) {
 		if (endpt_get_rtp_stats(sub->parent->line_id)) {
 			ast_log(LOG_WARNING, "Unable to get RTP statistics\n");
@@ -893,10 +893,10 @@ static int brcm_getRtpStats(struct ast_channel *ast)
 	return 0;
 }
 
-static int brcm_transfer(struct ast_channel *ast, const char *newdest)
+static int chan_voicemngr_transfer(struct ast_channel *ast, const char *newdest)
 {
-	struct brcm_pvt *pvt;
-	struct brcm_subchannel *subchan_active, *subchan_inactive;
+	struct chan_voicemngr_pvt *pvt;
+	struct chan_voicemngr_subchannel *subchan_active, *subchan_inactive;
 	struct ast_channel *chan_new;
 	char ext[strlen(newdest) + 1], *replaces;
 
@@ -905,8 +905,8 @@ static int brcm_transfer(struct ast_channel *ast, const char *newdest)
 	// Get the other subchannel
 	subchan_active = ast_channel_tech_pvt(ast);
 	if (!subchan_active || !(pvt = subchan_active->parent) ||
-		!(subchan_inactive = brcm_subchannel_get_peer(subchan_active)) ||
-		!brcm_subchannel_is_idle(subchan_inactive)) {
+		!(subchan_inactive = chan_voicemngr_subchannel_get_peer(subchan_active)) ||
+		!chan_voicemngr_subchannel_is_idle(subchan_inactive)) {
 		return -1;
 	}
 
@@ -919,10 +919,10 @@ static int brcm_transfer(struct ast_channel *ast, const char *newdest)
 
 	if (!subchan_inactive->connection_init) {
 		subchan_inactive->connection_id = ast_atomic_fetchadd_int((int *)&current_connection_id, +1);
-		brcm_create_connection(subchan_inactive);
+		chan_voicemngr_create_connection(subchan_inactive);
 	}
 
-	chan_new = brcm_new(subchan_inactive, AST_STATE_DOWN, ext, pvt->context, NULL, NULL, NULL);
+	chan_new = chan_voicemngr_new(subchan_inactive, AST_STATE_DOWN, ext, pvt->context, NULL, NULL, NULL);
 	if (!chan_new) {
 		ast_log(LOG_ERROR, "couldn't create channel\n");
 		return -1;
@@ -943,9 +943,9 @@ static int brcm_transfer(struct ast_channel *ast, const char *newdest)
 	return 0;
 }
 
-static int brcm_finish_transfer(struct ast_channel *owner, struct brcm_subchannel *p, int result)
+static int chan_voicemngr_finish_transfer(struct ast_channel *owner, struct chan_voicemngr_subchannel *p, int result)
 {
-	struct brcm_subchannel* peer_sub;
+	struct chan_voicemngr_subchannel* peer_sub;
 	/*
 	 * We have received the result of a transfer operation.
 	 * This could be:
@@ -963,13 +963,13 @@ static int brcm_finish_transfer(struct ast_channel *owner, struct brcm_subchanne
 		return -1;
 	}
 
-	peer_sub = brcm_subchannel_get_peer(p);
+	peer_sub = chan_voicemngr_subchannel_get_peer(p);
 	if (!peer_sub) {
 		ast_log(LOG_ERROR, "Failed to get peer subchannel\n");
 		return -1;
 	}
 
-	if (brcm_subchannel_is_idle(peer_sub)) {
+	if (chan_voicemngr_subchannel_is_idle(peer_sub)) {
 		// In the case of Transfer-On-Hangup peer sub should be a idle
 		if (result == AST_TRANSFER_SUCCESS) {
 			ast_log(LOG_NOTICE, "Remote transfer completed successfully, hanging up\n");
@@ -998,9 +998,9 @@ static int brcm_finish_transfer(struct ast_channel *owner, struct brcm_subchanne
 }
 
 /*! \brief Incoming DTMF begin event */
-static int brcm_senddigit_begin(struct ast_channel *ast, char digit)
+static int chan_voicemngr_senddigit_begin(struct ast_channel *ast, char digit)
 {
-	struct brcm_subchannel *sub;
+	struct chan_voicemngr_subchannel *sub;
 	char signal[10];
 
 	//ast_debug(5, "DTMF send begin: %c\n", digit);
@@ -1016,9 +1016,9 @@ static int brcm_senddigit_begin(struct ast_channel *ast, char digit)
 }
 
 /*! \brief Incoming DTMF end */
-static int brcm_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration)
+static int chan_voicemngr_senddigit_end(struct ast_channel *ast, char digit, unsigned int duration)
 {
-	struct brcm_subchannel *sub;
+	struct chan_voicemngr_subchannel *sub;
 	char signal[10];
 
 	//ast_debug(5, "DTMF send end: %c, %d ms\n", digit, duration);
@@ -1040,11 +1040,11 @@ static int brcm_senddigit_end(struct ast_channel *ast, char digit, unsigned int
  *
  * @return enum ast_device_state
  */
-static int brcm_devicestate(const char *device_number)
+static int chan_voicemngr_devicestate(const char *device_number)
 {
 	char *sep = NULL;
 	int chan_id, connection_id, sub_chan;
-	struct brcm_pvt *pvt;
+	struct chan_voicemngr_pvt *pvt;
 
 	if (!device_number || strlen(device_number) < 3 || (sep = strchr(device_number, '/')) == NULL) {
 		goto __ret;
@@ -1056,7 +1056,7 @@ static int brcm_devicestate(const char *device_number)
 		goto __ret;
 	}
 
-	pvt = brcm_get_pvt_from_lineid(iflist, chan_id);
+	pvt = chan_voicemngr_get_pvt_from_lineid(iflist, chan_id);
 	if (!pvt) {
 		goto __ret;
 	}
@@ -1095,11 +1095,11 @@ __ret:
 	return AST_DEVICE_UNKNOWN;
 }
 
-static int brcm_call(struct ast_channel *chan, const char *dest, int timeout)
+static int chan_voicemngr_call(struct ast_channel *chan, const char *dest, int timeout)
 {
-	struct brcm_pvt *p;
-	struct brcm_subchannel *sub;
-	struct brcm_subchannel *sub_peer;
+	struct chan_voicemngr_pvt *p;
+	struct chan_voicemngr_subchannel *sub;
+	struct chan_voicemngr_subchannel *sub_peer;
 
 	struct timeval UtcTime = ast_tvnow();
 	struct ast_tm tm;
@@ -1109,38 +1109,38 @@ static int brcm_call(struct ast_channel *chan, const char *dest, int timeout)
 	ast_localtime(&UtcTime, &tm, NULL);
 
 	if ((ast_channel_state(chan) != AST_STATE_DOWN) && (ast_channel_state(chan) != AST_STATE_RESERVED)) {
-		ast_log(LOG_WARNING, "brcm_call called on %s, neither down nor reserved\n", ast_channel_name(chan));
+		ast_log(LOG_WARNING, "chan_voicemngr_call called on %s, neither down nor reserved\n", ast_channel_name(chan));
 		return -1;
 	}
 
 	//ast_mutex_lock(&sub->parent->lock);
-	pvt_lock(sub->parent, "brcm_call");
+	pvt_lock(sub->parent, "chan_voicemngr_call");
 
 	p = sub->parent;
-	sub_peer = brcm_subchannel_get_peer(sub);
+	sub_peer = chan_voicemngr_subchannel_get_peer(sub);
 	if (!channel_config[p->line_id].enabled) {
 		ast_debug(1, "tel_line %d disabled!\n", p->line_id);
 		ast_channel_hangupcause_set(chan, AST_CAUSE_CALL_REJECTED);
 		ast_queue_control(chan, AST_CONTROL_BUSY);
-		brcm_send_ubus_event("CALL_REJECTED",p->line_id);
+		chan_voicemngr_send_ubus_event("CALL_REJECTED",p->line_id);
 	}
 	else if (channel_config[p->line_id].do_not_disturb) {
 		ast_debug(1, "Do not disturbed\n");
 		ast_channel_hangupcause_set(chan, AST_CAUSE_USER_BUSY);
-		brcm_send_ubus_event("USER_BUSY",p->line_id);
+		chan_voicemngr_send_ubus_event("USER_BUSY",p->line_id);
 		ast_queue_control(chan, AST_CONTROL_BUSY);
 	}
 	else if(p->emergency) {
 		ast_debug(1, "Emergency Call Ongoing\n");
 		ast_channel_hangupcause_set(chan, AST_CAUSE_USER_BUSY);
-		brcm_send_ubus_event("USER_BUSY",p->line_id);
+		chan_voicemngr_send_ubus_event("USER_BUSY",p->line_id);
 		ast_queue_control(chan, AST_CONTROL_BUSY);
 	}
-	else if (brcm_in_call(p) &&                          		// a call is established
+	else if (chan_voicemngr_in_call(p) &&                          		// a call is established
 		is_call_waiting_enabled(p->context)) {			// call waiting enabled
 		ast_debug(1, "Call waiting\n");
 		sub->channel_state = CALLWAITING;
-		brcm_signal_callwaiting(p);
+		chan_voicemngr_signal_callwaiting(p);
 		int cwtimeout_ms = cwtimeout * 1000;
 		int cwBeep_ms = cwBeep * 1000;
 		sub->cw_timer_id = ast_sched_add(sched, cwtimeout_ms, cwtimeout_cb, sub);
@@ -1148,29 +1148,29 @@ static int brcm_call(struct ast_channel *chan, const char *dest, int timeout)
 		ast_setstate(chan, AST_STATE_RINGING_CW);
 		ast_queue_control(chan, AST_CONTROL_RINGING_CW);
 	}
-	else if (!brcm_subchannel_is_idle(sub_peer)) {
+	else if (!chan_voicemngr_subchannel_is_idle(sub_peer)) {
 		ast_debug(1, "Line is busy\n");
 		ast_channel_hangupcause_set(chan, AST_CAUSE_USER_BUSY);
 		ast_queue_control(chan, AST_CONTROL_BUSY);
 		/*When call comes but the sub_peer is not idle,move to old ONHOOK state*/
 		if(sub->channel_state == ALLOCATED)
 			sub->channel_state = ONHOOK;
-		brcm_send_ubus_event("USER_BUSY",p->line_id);
+		chan_voicemngr_send_ubus_event("USER_BUSY",p->line_id);
 
-		struct brcm_pvt *tmp = p;
-		struct brcm_subchannel *s = NULL;
+		struct chan_voicemngr_pvt *tmp = p;
+		struct chan_voicemngr_subchannel *s = NULL;
 		int con_id = -1;
 
 		while(tmp) {
-			s = brcm_get_active_subchannel(tmp);
+			s = chan_voicemngr_get_active_subchannel(tmp);
 			con_id = s->connection_id;
 			// for local call we need to find the other party and change its subchannel state to CALLENDED
-			// so the extensionCallStatus is properly set to Disconnected in brcm_answer()
+			// so the extensionCallStatus is properly set to Disconnected in chan_voicemngr_answer()
 			if (con_id > 0 && (strncmp(tmp->extensionCallStatus, "Dialing", strlen(tmp->extensionCallStatus)) == 0)) {
 				s->channel_state = CALLENDED;
 				break;
 			}
-			tmp = brcm_get_next_pvt(tmp);
+			tmp = chan_voicemngr_get_next_pvt(tmp);
 		}
 	}
 	else {
@@ -1199,7 +1199,7 @@ static int brcm_call(struct ast_channel *chan, const char *dest, int timeout)
 			ast_queue_control(chan, AST_CONTROL_RINGING);
 		}
 
-		brcm_send_ubus_event("RINGING",p->line_id);
+		chan_voicemngr_send_ubus_event("RINGING",p->line_id);
 	}
 	//ast_mutex_unlock(&sub->parent->lock);
 	pvt_unlock(sub->parent);
@@ -1207,10 +1207,10 @@ static int brcm_call(struct ast_channel *chan, const char *dest, int timeout)
 	return 0;
 }
 
-static int brcm_hangup(struct ast_channel *ast)
+static int chan_voicemngr_hangup(struct ast_channel *ast)
 {
-	struct brcm_pvt *p;
-	struct brcm_subchannel *sub = ast_channel_tech_pvt(ast), *sub_peer;
+	struct chan_voicemngr_pvt *p;
+	struct chan_voicemngr_subchannel *sub = ast_channel_tech_pvt(ast), *sub_peer;
 	struct ast_channel *peer_owner;
 	int conf_timer_removed = 0;
 
@@ -1221,9 +1221,9 @@ static int brcm_hangup(struct ast_channel *ast)
 
 	p = sub->parent;
 	pvt_lock(p, "TELCHAN hangup");
-	sub_peer = brcm_subchannel_get_peer(sub);
+	sub_peer = chan_voicemngr_subchannel_get_peer(sub);
 
-	ast_log(LOG_NOTICE, "brcm_hangup chan=%s line_id=%d connection_id=%d dialtone=%s channel_state=%s peer_state=%s sub_timer: %d, peer_timer: %d\n",
+	ast_log(LOG_NOTICE, "chan_voicemngr_hangup chan=%s line_id=%d connection_id=%d dialtone=%s channel_state=%s peer_state=%s sub_timer: %d, peer_timer: %d\n",
 		ast_channel_name(ast), p->line_id, sub->connection_id, dialtone_map[p->dialtone].str,
 		state2str(sub->channel_state), state2str(sub_peer->channel_state), sub->conf_timer_id, sub_peer->conf_timer_id);
 	/* If call is not connected (INCALL) or is dialing but Subchannel is busy, move to Disconnected state */
@@ -1259,7 +1259,7 @@ static int brcm_hangup(struct ast_channel *ast)
 	}
 
 	if (sub->channel_state == CALLWAITING) {
-		brcm_stop_callwaiting(p);
+		chan_voicemngr_stop_callwaiting(p);
 	} else if (sub_peer->channel_state == ONHOLD &&
 			sub_peer->onhold_hangup_timer_id != -1 && sub->channel_state == RINGING) {
 		ast_debug(2, "There is a forgotten onhold call, not releasing channel\n");
@@ -1272,7 +1272,7 @@ static int brcm_hangup(struct ast_channel *ast)
 		} else {
 			p->tech->stop_ringing_callerid_pending(p);
 		}
-	} else if (brcm_subchannel_is_idle(sub_peer) && p->tech->release) {
+	} else if (chan_voicemngr_subchannel_is_idle(sub_peer) && p->tech->release) {
 		// No active subchannel left, release
 		ast_debug(1, "Release the call since the peer sub-channel is also idle\n");
 		p->tech->release(p);
@@ -1327,21 +1327,21 @@ static int brcm_hangup(struct ast_channel *ast)
 		ast_debug(6, "Setting channel state to %s\n", state2str(sub->channel_state));
 	}
 
-	if (sub->conference_initiator && brcm_in_conference(p)) {
+	if (sub->conference_initiator && chan_voicemngr_in_conference(p)) {
 		/* Switch still active call leg out of conference mode */
-		brcm_stop_conference(sub);
-		brcm_stop_conference(sub_peer);
+		chan_voicemngr_stop_conference(sub);
+		chan_voicemngr_stop_conference(sub_peer);
 	}
 
 	if (sub_peer->channel_state == INCALL && conf_timer_removed == 1) {
 		ast_log(LOG_NOTICE,"In case some party hangs up ,Unhold the other parties \n");
-		pvt_lock(sub_peer->parent, "Brcm Hangup");
+		pvt_lock(sub_peer->parent, "chan_voicemngr Hangup");
 		if(sub_peer->owner)
 			ast_channel_ref(sub_peer->owner);
 		peer_owner = sub_peer->owner;
 		pvt_unlock(sub_peer->parent);
 		if (peer_owner) {
-			brcm_unmute_connection(sub_peer);
+			chan_voicemngr_unmute_connection(sub_peer);
 			ast_queue_unhold(peer_owner);
 			sub_peer->channel_state = INCALL;
 		}
@@ -1355,7 +1355,7 @@ static int brcm_hangup(struct ast_channel *ast)
 	ast_module_unref(ast_module_info->self);
 	ast_verb(3, "Hungup '%s'\n", ast_channel_name(ast));
 	ast_channel_tech_pvt_set(ast, NULL);
-	brcm_close_connection(sub);
+	chan_voicemngr_close_connection(sub);
 
 	/* Check for channel state before dial tone timeout */
 	if(sub->channel_state == CALLENDED && sub_peer->channel_state != INCALL) {
@@ -1377,31 +1377,31 @@ static int brcm_hangup(struct ast_channel *ast)
 	return 0;
 }
 
-static int brcm_answer(struct ast_channel *ast)
+static int chan_voicemngr_answer(struct ast_channel *ast)
 {
-	struct brcm_subchannel *sub = ast_channel_tech_pvt(ast);
-	struct brcm_pvt *pvt = sub->parent;
+	struct chan_voicemngr_subchannel *sub = ast_channel_tech_pvt(ast);
+	struct chan_voicemngr_pvt *pvt = sub->parent;
 
-	ast_debug(1, "brcm_answer(%s)\n", ast_channel_name(ast));
+	ast_debug(1, "chan_voicemngr_answer(%s)\n", ast_channel_name(ast));
 	pvt_lock(pvt, "TELCHAN answer");
 
 	/* For attended call transfer, if the transfer target has accepted the call initiated by
 	 * us as the tranferee, we can terminate the original call with the transferor */
 	if (sub->channel_state == TRANSFERING) {
-		struct brcm_subchannel *peer = brcm_subchannel_get_peer(sub);
+		struct chan_voicemngr_subchannel *peer = chan_voicemngr_subchannel_get_peer(sub);
 
 		if (peer->owner) {
 			ast_debug(1, "Transferee terminates the original call with the transferor\n");
 			ast_queue_control(peer->owner, AST_CONTROL_HANGUP);
 			peer->owner = NULL;
 			peer->channel_state = CALLENDED;
-			brcm_close_connection(peer);
+			chan_voicemngr_close_connection(peer);
 		}
 	}
 
 	if (ast_channel_state(ast) != AST_STATE_UP) {
 		ast_setstate(ast, AST_STATE_UP);
-		ast_debug(2, "brcm_answer(%s) set state to up\n", ast_channel_name(ast));
+		ast_debug(2, "chan_voicemngr_answer(%s) set state to up\n", ast_channel_name(ast));
 	}
 	ast_channel_rings_set(ast, 0);
 
@@ -1414,7 +1414,7 @@ static int brcm_answer(struct ast_channel *ast)
 		sub->channel_state = INCALL;
 	}
 	endpt_signal(pvt->line_id, "answer", "on", NULL);
-	brcm_send_ubus_event("RINGING_OFF",pvt->line_id);
+	chan_voicemngr_send_ubus_event("RINGING_OFF",pvt->line_id);
 	endpt_signal(pvt->line_id, "ringback", "off", NULL);
 
 	if(sub->channel_state != CALLENDED)
@@ -1430,7 +1430,7 @@ static int brcm_answer(struct ast_channel *ast)
 /*
 * Map RTP data header value to a codec name
 */
-static char* brcm_get_codec_string(int id) {
+static char* chan_voicemngr_get_codec_string(int id) {
 	switch (id) {
 		case RTP_PT_PCMA: return "alaw"; break;
 		case RTP_PT_PCMU: return "ulaw"; break;
@@ -1444,21 +1444,21 @@ static char* brcm_get_codec_string(int id) {
 	}
 }
 
-static int brcm_classify_rtp_packet(int payload_type) {
+static int chan_voicemngr_classify_rtp_packet(int payload_type) {
 
 	switch (payload_type) {
-		case RTP_PT_PCMU: return BRCM_AUDIO;
-		case RTP_PT_G726: return BRCM_AUDIO;
-		case RTP_PT_G723: return BRCM_AUDIO;
-		case RTP_PT_PCMA: return BRCM_AUDIO;
-		case RTP_PT_G729: return BRCM_AUDIO;
-		case RTP_PT_G722: return BRCM_AUDIO;
-		case RTP_PT_CN:   return BRCM_AUDIO;
-		case RTCP_SR:     return BRCM_RTCP_SR;
-		case RTCP_RR:     return BRCM_RTCP_RR;
+		case RTP_PT_PCMU: return CHAN_VOICEMNGR_AUDIO;
+		case RTP_PT_G726: return CHAN_VOICEMNGR_AUDIO;
+		case RTP_PT_G723: return CHAN_VOICEMNGR_AUDIO;
+		case RTP_PT_PCMA: return CHAN_VOICEMNGR_AUDIO;
+		case RTP_PT_G729: return CHAN_VOICEMNGR_AUDIO;
+		case RTP_PT_G722: return CHAN_VOICEMNGR_AUDIO;
+		case RTP_PT_CN:   return CHAN_VOICEMNGR_AUDIO;
+		case RTCP_SR:     return CHAN_VOICEMNGR_RTCP_SR;
+		case RTCP_RR:     return CHAN_VOICEMNGR_RTCP_RR;
 		default:
 			ast_verbose("Unknown rtp packet payload_type %d\n", payload_type);
-			return BRCM_UNKNOWN;
+			return CHAN_VOICEMNGR_UNKNOWN;
 	}
 }
 
@@ -1483,7 +1483,7 @@ static int map_ast_codec_id_to_rtp(const struct ast_format *astcodec)
 }
 
 
-static struct ast_frame  *brcm_read(struct ast_channel *ast)
+static struct ast_frame  *chan_voicemngr_read(struct ast_channel *ast)
 {
 	return &ast_null_frame;
 }
@@ -1499,9 +1499,9 @@ static void audio_rx_stream_handler(pe_stream_t *stream __attribute__((unused)),
 	pe_bus_dispatch(audio_rx_bus);
 }
 
-static int brcm_write(struct ast_channel *ast, struct ast_frame *frame)
+static int chan_voicemngr_write(struct ast_channel *ast, struct ast_frame *frame)
 {
-	struct brcm_subchannel *sub = ast_channel_tech_pvt(ast);
+	struct chan_voicemngr_subchannel *sub = ast_channel_tech_pvt(ast);
 	int packet_size;
 	audio_packet_t *ap;
 
@@ -1537,7 +1537,7 @@ static int brcm_write(struct ast_channel *ast, struct ast_frame *frame)
 		pvt_lock(sub->parent, "TELCHAN write frame");
 
 		/* generate the rtp header */
-		brcm_generate_rtp_packet(sub, ap->rtp, RTP_PT_CN, 0, 0, frame->seqno);
+		chan_voicemngr_generate_rtp_packet(sub, ap->rtp, RTP_PT_CN, 0, 0, frame->seqno);
 
 		/* set rtp payload type sent to voicemngr */
 		sub->codec = RTP_PT_CN;
@@ -1567,7 +1567,7 @@ static int brcm_write(struct ast_channel *ast, struct ast_frame *frame)
 		pvt_lock(sub->parent, "TELCHAN write frame");
 
 		/* generate the rtp header */
-		brcm_generate_rtp_packet(sub, ap->rtp, map_ast_codec_id_to_rtp(frame->subclass.format), 0, 0, frame->seqno);
+		chan_voicemngr_generate_rtp_packet(sub, ap->rtp, map_ast_codec_id_to_rtp(frame->subclass.format), 0, 0, frame->seqno);
 
 		/* set rtp payload type sent to voicemngr */
 		sub->codec = map_ast_codec_id_to_rtp(frame->subclass.format);
@@ -1594,7 +1594,7 @@ static int brcm_write(struct ast_channel *ast, struct ast_frame *frame)
 		/* copy frame data to audio packet */
 		memcpy(ap->rtp, frame->data.ptr, frame->datalen);
 
-		brcm_process_rtcp_packet(sub, ap->rtp, ap->rtp_size);
+		chan_voicemngr_process_rtcp_packet(sub, ap->rtp, ap->rtp_size);
 
 		pe_bus_send(audio_tx_bus, (uint8_t *)ap, packet_size);
 		free(ap);
@@ -1602,7 +1602,7 @@ static int brcm_write(struct ast_channel *ast, struct ast_frame *frame)
 	return 0;
 }
 
-static void brcm_reset_dtmf_buffer(struct brcm_pvt *p)
+static void chan_voicemngr_reset_dtmf_buffer(struct chan_voicemngr_pvt *p)
 {
 	memset(p->dtmfbuf, 0, sizeof(p->dtmfbuf));
 	p->dtmf_len = 0;
@@ -1610,7 +1610,7 @@ static void brcm_reset_dtmf_buffer(struct brcm_pvt *p)
 	p->dtmfbuf[p->dtmf_len] = '\0';
 }
 
-static char *state2str(enum brcm_channel_state state)
+static char *state2str(enum chan_voicemngr_channel_state state)
 {
 	switch (state) {
 	case ONHOOK:		return "ONHOOK";
@@ -1631,7 +1631,7 @@ static char *state2str(enum brcm_channel_state state)
 	}
 }
 
-static int brcm_subchannel_is_idle(const struct brcm_subchannel *sub)
+static int chan_voicemngr_subchannel_is_idle(const struct chan_voicemngr_subchannel *sub)
 {
 	if (sub->channel_state == ONHOOK || sub->channel_state == CALLENDED) {
 		return 1;
@@ -1639,15 +1639,15 @@ static int brcm_subchannel_is_idle(const struct brcm_subchannel *sub)
 	return 0;
 }
 
-struct brcm_subchannel *brcm_subchannel_get_peer(const struct brcm_subchannel *sub)
+struct chan_voicemngr_subchannel *chan_voicemngr_subchannel_get_peer(const struct chan_voicemngr_subchannel *sub)
 {
-	struct brcm_subchannel *peer_sub;
+	struct chan_voicemngr_subchannel *peer_sub;
 	peer_sub = (sub->parent->sub[0] == sub) ? sub->parent->sub[1] : sub->parent->sub[0];
 	return peer_sub;
 }
 
 /* Tell endpoint to play country specific dialtone. */
-static int brcm_signal_dialtone(struct brcm_pvt *p) {
+static int chan_voicemngr_signal_dialtone(struct chan_voicemngr_pvt *p) {
 
 	ast_verbose("Setting dialtone to %s\n", dialtone_map[p->dialtone].str);	
 	switch (p->dialtone) {
@@ -1669,7 +1669,7 @@ static int brcm_signal_dialtone(struct brcm_pvt *p) {
 			break;
 		case DIALTONE_HOWLER:
 			ast_debug(9, "Trigger howler tone from Asterisk\n");
-			brcm_signal_howler(p);
+			chan_voicemngr_signal_howler(p);
 			break;
 		default:
 			ast_log(LOG_ERROR, "Requested to signal unknown dialtone\n");
@@ -1678,8 +1678,8 @@ static int brcm_signal_dialtone(struct brcm_pvt *p) {
 	return 0;
 }
 
-static void brcm_signal_howler(struct brcm_pvt *p) {
-	struct brcm_subchannel *sub = brcm_get_active_subchannel(p);
+static void chan_voicemngr_signal_howler(struct chan_voicemngr_pvt *p) {
+	struct chan_voicemngr_subchannel *sub = chan_voicemngr_get_active_subchannel(p);
 
 	if(!sub) {
 		ast_debug(9, "Unable to find active subchannel\n");
@@ -1689,21 +1689,21 @@ static void brcm_signal_howler(struct brcm_pvt *p) {
 	/* Start the pbx */
 	if (!sub->connection_init) {
 		sub->connection_id = ast_atomic_fetchadd_int((int *)&current_connection_id, +1);
-		brcm_create_connection(sub);
+		chan_voicemngr_create_connection(sub);
 	}
 
 	/* Create a new channel to context 'howler' handled by extensions.conf */
-	brcm_new(sub, AST_STATE_RING, "0", "howler", NULL, NULL, NULL);
+	chan_voicemngr_new(sub, AST_STATE_RING, "0", "howler", NULL, NULL, NULL);
 }
 
-int brcm_stop_dialtone(struct brcm_pvt *p) {
+int chan_voicemngr_stop_dialtone(struct chan_voicemngr_pvt *p) {
 	p->dialtone = DIALTONE_OFF;
-	brcm_signal_dialtone(p);
-	brcm_send_ubus_event("DIALTONE_OFF",p->line_id);
+	chan_voicemngr_signal_dialtone(p);
+	chan_voicemngr_send_ubus_event("DIALTONE_OFF",p->line_id);
 	return 0;
 }
 
-static struct ast_channel *brcm_new(struct brcm_subchannel *subchan, int state, const char *ext, const char *context,
+static struct ast_channel *chan_voicemngr_new(struct chan_voicemngr_subchannel *subchan, int state, const char *ext, const char *context,
 		const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor,
 		struct ast_format_cap *format)
 {
@@ -1770,29 +1770,29 @@ static struct ast_channel *brcm_new(struct brcm_subchannel *subchan, int state,
 }
 
 
-static struct brcm_pvt* brcm_get_next_pvt(struct brcm_pvt *p) {
+static struct chan_voicemngr_pvt* chan_voicemngr_get_next_pvt(struct chan_voicemngr_pvt *p) {
 	if (p && p->next)
 		return p->next;
 	else
 		return NULL;
 }
 
-struct brcm_pvt* brcm_get_pvt_from_lineid(struct brcm_pvt *p, int line_id)
+struct chan_voicemngr_pvt* chan_voicemngr_get_pvt_from_lineid(struct chan_voicemngr_pvt *p, int line_id)
 {
-	struct brcm_pvt *tmp = p;
+	struct chan_voicemngr_pvt *tmp = p;
 	if (p && p->line_id == line_id) return p;
-	tmp = brcm_get_next_pvt(tmp);
+	tmp = chan_voicemngr_get_next_pvt(tmp);
 
 	while(tmp) {
 		if (tmp->line_id == line_id) return tmp;
-		tmp = brcm_get_next_pvt(tmp);
+		tmp = chan_voicemngr_get_next_pvt(tmp);
 	}
 	return NULL;
 }
 
-struct brcm_subchannel* brcm_get_active_subchannel(const struct brcm_pvt *p)
+struct chan_voicemngr_subchannel* chan_voicemngr_get_active_subchannel(const struct chan_voicemngr_pvt *p)
 {
-	struct brcm_subchannel *sub = NULL;
+	struct chan_voicemngr_subchannel *sub = NULL;
 	int i;
 
 	if(!p)
@@ -1830,9 +1830,9 @@ struct brcm_subchannel* brcm_get_active_subchannel(const struct brcm_pvt *p)
 	return sub;
 }
 
-static struct brcm_subchannel *brcm_get_onhold_subchannel(const struct brcm_pvt *p)
+static struct chan_voicemngr_subchannel *chan_voicemngr_get_onhold_subchannel(const struct chan_voicemngr_pvt *p)
 {
-	struct brcm_subchannel *sub;
+	struct chan_voicemngr_subchannel *sub;
 	int i;
 	for(i=0; i<NUM_SUBCHANNELS; i++) {
 			sub = p->sub[i];
@@ -1846,13 +1846,13 @@ static struct brcm_subchannel *brcm_get_onhold_subchannel(const struct brcm_pvt
 /*Set up a Conference call on press of flash hook once timer expires */
 static int setup_conference_call_cb( const void *data)
 {
-    struct brcm_subchannel *sub_peer;
+    struct chan_voicemngr_subchannel *sub_peer;
     struct ast_channel *peer_owner = NULL;
     
     ast_log(LOG_NOTICE ,"Set up a conference call\n");
-    struct brcm_pvt *p = (struct brcm_pvt *) data;
-    struct brcm_subchannel *sub = brcm_get_active_subchannel(p);
-    sub_peer = brcm_subchannel_get_peer(sub);
+    struct chan_voicemngr_pvt *p = (struct chan_voicemngr_pvt *) data;
+    struct chan_voicemngr_subchannel *sub = chan_voicemngr_get_active_subchannel(p);
+    sub_peer = chan_voicemngr_subchannel_get_peer(sub);
     pvt_lock(sub->parent, "setup_conference_call_cb");
     if (sub_peer->owner) {
         ast_channel_ref(sub_peer->owner);
@@ -1866,15 +1866,15 @@ static int setup_conference_call_cb( const void *data)
         sub->conf_timer_id = -1;
         sub_peer->conf_timer_id = -1;
         ast_log(LOG_NOTICE,"Valid flags to start a Conference Call\n");
-        brcm_create_conference(p);
+        chan_voicemngr_create_conference(p);
         if (peer_owner) {
             sub_peer->channel_state = INCALL;
         }
          sub->channel_state = INCALL;
     }
 
-    brcm_send_ubus_event("UNHOLD",sub->parent->line_id);
-    brcm_send_ubus_event("CONFERENCE_START",sub->parent->line_id);
+    chan_voicemngr_send_ubus_event("UNHOLD",sub->parent->line_id);
+    chan_voicemngr_send_ubus_event("CONFERENCE_START",sub->parent->line_id);
     if (peer_owner) {
         ast_channel_unref(peer_owner);
     }
@@ -1884,11 +1884,11 @@ static int setup_conference_call_cb( const void *data)
 /* Hangup incoming call after call waiting times out */
 static int cwtimeout_cb(const void *data)
 {
-	struct brcm_subchannel *sub;
+	struct chan_voicemngr_subchannel *sub;
 	struct ast_channel *owner = NULL;
 
 
-	sub = (struct brcm_subchannel *) data;
+	sub = (struct chan_voicemngr_subchannel *) data;
 	ast_debug(2, "No response to call waiting, hanging up, sub->channel_state: %d\n", sub->channel_state);
 	//ast_mutex_lock(&sub->parent->lock);
 	pvt_lock(sub->parent, "Cwtimeout callback");
@@ -1905,9 +1905,9 @@ static int cwtimeout_cb(const void *data)
 	}
 	//ast_mutex_unlock(&sub->parent->lock);
 	if (sub->channel_state == CALLWAITING)
-		brcm_stop_callwaiting(sub->parent);
+		chan_voicemngr_stop_callwaiting(sub->parent);
 	else if (sub->channel_state == RINGING)
-		brcm_stop_ringing(sub->parent);
+		chan_voicemngr_stop_ringing(sub->parent);
 	pvt_unlock(sub->parent);
 
 	if (owner) {
@@ -1924,12 +1924,12 @@ static int cwtimeout_cb(const void *data)
 /* Play beep during call waiting */
 static int cwbeep_cb(const void *data)
 {
-	struct brcm_subchannel *sub = (struct brcm_subchannel *) data;
+	struct chan_voicemngr_subchannel *sub = (struct chan_voicemngr_subchannel *) data;
 	int cwBeep_ms = cwBeep * 1000;
 
 	pvt_lock(sub->parent, "cwbeep_cb callback");
 	if (sub->parent) {
-		brcm_signal_callwaiting(sub->parent);
+		chan_voicemngr_signal_callwaiting(sub->parent);
 	}
 	pvt_unlock(sub->parent);
 
@@ -1941,16 +1941,16 @@ static int cwbeep_cb(const void *data)
 /* Hangup calls if not done by remote after R4 transfer */
 static int r4hanguptimeout_cb(const void *data)
 {
-	struct brcm_subchannel *sub;
-	struct brcm_subchannel *peer_sub;
+	struct chan_voicemngr_subchannel *sub;
+	struct chan_voicemngr_subchannel *peer_sub;
 
 	struct ast_channel *sub_owner = NULL;
 	struct ast_channel *peer_sub_owner = NULL;
 
 	ast_debug(2, "No hangup from remote after remote transfer using R4, hanging up\n");
 
-	sub = (struct brcm_subchannel *) data;
-	peer_sub = brcm_subchannel_get_peer(sub);
+	sub = (struct chan_voicemngr_subchannel *) data;
+	peer_sub = chan_voicemngr_subchannel_get_peer(sub);
 
 	//ast_mutex_lock(&sub->parent->lock);
 	pvt_lock(sub->parent, "r4hanguptimeout callback");
@@ -1986,11 +1986,11 @@ static int r4hanguptimeout_cb(const void *data)
 /* Hangup call onhold if user does not pick up after reminder ringing */
 static int onholdhanguptimeout_cb(const void *data)
 {
-	struct brcm_subchannel *sub;
+	struct chan_voicemngr_subchannel *sub;
 	struct ast_channel *sub_owner = NULL;
 
 	ast_debug(2, "No pickup after reminder ringing for call on hold, hanging up\n");
-	sub = (struct brcm_subchannel *) data;
+	sub = (struct chan_voicemngr_subchannel *) data;
 
 	//ast_mutex_lock(&sub->parent->lock);
 	pvt_lock(sub->parent, "onholdhanguptimeout callback");
@@ -2016,7 +2016,7 @@ static int onholdhanguptimeout_cb(const void *data)
  * Helper function that tells asterisk to start a call on the provided pvt/sub/context
  * using the content of the dtmf buffer.
  */
-static void brcm_start_calling(struct brcm_subchannel *sub, char* context)
+static void chan_voicemngr_start_calling(struct chan_voicemngr_subchannel *sub, char* context)
 {
 	sub->channel_state = CALLING;
 	ast_copy_string(sub->parent->ext, sub->parent->dtmfbuf, sizeof(sub->parent->ext));
@@ -2024,7 +2024,7 @@ static void brcm_start_calling(struct brcm_subchannel *sub, char* context)
 	ast_debug(1, "Calling %s@%s\n", sub->parent->ext, context);
 
 	/* Reset the dtmf buffer */
-	brcm_reset_dtmf_buffer(sub->parent);
+	chan_voicemngr_reset_dtmf_buffer(sub->parent);
 
 	/* Reset hook flash state */
 	sub->parent->hf_detected = 0;
@@ -2032,18 +2032,18 @@ static void brcm_start_calling(struct brcm_subchannel *sub, char* context)
 	/* Start the pbx */
 	if (!sub->connection_init) {
 		sub->connection_id = ast_atomic_fetchadd_int((int *)&current_connection_id, +1);
-		brcm_create_connection(sub);
+		chan_voicemngr_create_connection(sub);
 	}
 
-	/* Changed state from AST_STATE_UP to AST_STATE_RING ito get the brcm_answer callback
+	/* Changed state from AST_STATE_UP to AST_STATE_RING ito get the chan_voicemngr_answer callback
 	 * which is needed for call waiting. */
-	brcm_new(sub, AST_STATE_RING, sub->parent->ext, context, NULL, NULL, NULL);
+	chan_voicemngr_new(sub, AST_STATE_RING, sub->parent->ext, context, NULL, NULL, NULL);
 	if(sub->owner){
 		/* check and set the emergency call flag */
 		if(check_emergency_number(channel_config[sub->parent->line_id].emergency_numbers_list, sub->parent->ext)){
 			ast_channel_emergency_ongoing_set(sub->owner, 1); /* flag in ast_channel to add emergency headers */
 			ast_log(LOG_WARNING, "%s has emergency call ongoing %d \n", ast_channel_name(sub->owner), ast_channel_emergency_ongoing_get(sub->owner));
-			sub->parent->emergency = 1; /* flag in brcm_pvt for local handling: ignore flash-hook, deny any incoming calls */
+			sub->parent->emergency = 1; /* flag in chan_voicemngr_pvt for local handling: ignore flash-hook, deny any incoming calls */
 		} else {
 			ast_channel_emergency_ongoing_set(sub->owner, 0);
 			sub->parent->emergency = 0;
@@ -2058,11 +2058,11 @@ static void brcm_start_calling(struct brcm_subchannel *sub, char* context)
 static int handle_interdigit_timeout(const void *data)
 {
 	ast_debug(9, "Interdigit timeout\n");
-	struct brcm_pvt *p = (struct brcm_pvt *) data;
+	struct chan_voicemngr_pvt *p = (struct chan_voicemngr_pvt *) data;
 	//ast_mutex_lock(&p->lock);
 	pvt_lock(p, "interdigit callback");
 	p->interdigit_timer_id = -1;
-	struct brcm_subchannel *sub = brcm_get_active_subchannel(p);
+	struct chan_voicemngr_subchannel *sub = chan_voicemngr_get_active_subchannel(p);
         if (channel_config[p->line_id].minimumnumberdigits  && strlen(p->dtmfbuf) >= channel_config[p->line_id].minimumnumberdigits){
            if (ast_exists_extension(NULL, p->context, p->dtmfbuf, 1, p->cid_num))
  	   {
@@ -2070,7 +2070,7 @@ static int handle_interdigit_timeout(const void *data)
 		//and interdigit timeout has passed, so have asterisk start calling.
 		//Asterisk will select the best matching extension if there are more than one possibility.
 		ast_debug(9, "Interdigit timeout, extension(s) matching %s found\n", p->dtmfbuf);
-		brcm_start_calling(sub, p->context);
+		chan_voicemngr_start_calling(sub, p->context);
 	   }
         }
         //if no limit on minimum digits check extension exits
@@ -2081,7 +2081,7 @@ static int handle_interdigit_timeout(const void *data)
                 //and interdigit timeout has passed, so have asterisk start calling.
                 //Asterisk will select the best matching extension if there are more than one possibility.
                 ast_debug(9, "Interdigit timeout, extension(s) matching %s found\n", p->dtmfbuf);
-                brcm_start_calling(sub, p->context);
+                chan_voicemngr_start_calling(sub, p->context);
            }
        }
 	//ast_mutex_unlock(&p->lock);
@@ -2096,19 +2096,19 @@ static int handle_interdigit_timeout(const void *data)
 static int handle_autodial_timeout(const void *data)
 {
 	ast_debug(9, "Autodial timeout\n");
-	struct brcm_pvt *p = (struct brcm_pvt *) data;
+	struct chan_voicemngr_pvt *p = (struct chan_voicemngr_pvt *) data;
 	pvt_lock(p, "autodial timeout");
 	//ast_mutex_lock(&p->lock);
 	p->autodial_timer_id = -1;
-	struct brcm_subchannel *sub = brcm_get_active_subchannel(p);
+	struct chan_voicemngr_subchannel *sub = chan_voicemngr_get_active_subchannel(p);
 	channel_settings *s = &channel_config[p->line_id];
 
 	if (ast_exists_extension(NULL, p->context, s->autodial_ext, 1, p->cid_num))
 	{
-		brcm_stop_dialtone(p);
+		chan_voicemngr_stop_dialtone(p);
 		ast_copy_string(p->dtmfbuf, s->autodial_ext, sizeof(p->dtmfbuf));
 		ast_debug(9, "Autodialing extension: %s\n", p->dtmfbuf);
-		brcm_start_calling(sub, p->context);
+		chan_voicemngr_start_calling(sub, p->context);
 	}
 	//ast_mutex_unlock(&p->lock);
 	pvt_unlock(p);
@@ -2121,14 +2121,14 @@ static int handle_autodial_timeout(const void *data)
  */
 static int handle_dialtone_timeout(const void *data)
 {
-	struct brcm_pvt *p = (struct brcm_pvt *) data;
+	struct chan_voicemngr_pvt *p = (struct chan_voicemngr_pvt *) data;
 
 	pvt_lock(p, "dialtone timeout");
 	strncpy(p->extensionCallStatus, "Disconnected", CALL_STATUS_MAX_LEN);
 	//ast_mutex_lock(&p->lock);
 	p->dialtone_timeout_timer_id = -1;
 
-	struct brcm_subchannel *sub = brcm_get_active_subchannel(p);
+	struct chan_voicemngr_subchannel *sub = chan_voicemngr_get_active_subchannel(p);
 
 	ast_debug(9, "Dialtone timeout, sub->channel_state: %s\n", state2str(sub->channel_state));
 
@@ -2158,7 +2158,7 @@ static int handle_dialtone_timeout(const void *data)
 				ast_log(LOG_ERROR, "Invalid dialtone timeout state\n");
 				break;
 		}
-		brcm_signal_dialtone(p);
+		chan_voicemngr_signal_dialtone(p);
 	}
 
 	//ast_mutex_unlock(&p->lock);
@@ -2171,9 +2171,9 @@ static int handle_dialtone_timeout(const void *data)
  * Called after each new DTMF event, from monitor_events thread,
  * with the required locks already held.
  */
-void handle_dtmf_calling(struct brcm_subchannel *sub)
+void handle_dtmf_calling(struct chan_voicemngr_subchannel *sub)
 {
-	struct brcm_pvt *p = sub->parent;
+	struct chan_voicemngr_pvt *p = sub->parent;
 	char termination_digit;
 	int dtmfbuf_len = strlen(p->dtmfbuf);
 	char dtmf_last_char = p->dtmfbuf[(dtmfbuf_len - 1)];
@@ -2185,7 +2185,7 @@ void handle_dtmf_calling(struct brcm_subchannel *sub)
 	{
 		//We have a full match in the "direct" context, so have asterisk place a call immediately
 		ast_debug(9, "Direct extension matching %s found\n", p->dtmfbuf);
-		brcm_start_calling(sub, p->context_direct);
+		chan_voicemngr_start_calling(sub, p->context_direct);
 	}
 
 
@@ -2198,7 +2198,7 @@ void handle_dtmf_calling(struct brcm_subchannel *sub)
                     //so have asterisk place a call immediately if sequence is not partially matching a feature access code
                     ast_log(LOG_NOTICE, "Termination key %c is pressed during dialing, extension %s found\n",termination_digit, p->dtmfbuf);
                     if(strlen(p->dtmfbuf) >= channel_config[p->line_id].minimumnumberdigits)
-                        brcm_start_calling(sub, p->context);
+                        chan_voicemngr_start_calling(sub, p->context);
                     else
                         ast_log(LOG_ERROR, "Not reached the minimum digits to start a call!! \n");
                 }
@@ -2208,7 +2208,7 @@ void handle_dtmf_calling(struct brcm_subchannel *sub)
                      //We have a match in the "normal" context, and user ended the dialling sequence with a # or temination digit set  in dialplan,
                      //so have asterisk place a call immediately if sequence is not partially matching a feature access code
                      ast_log(LOG_NOTICE, "No minimum digit limit set start a call right away \n");
-                     brcm_start_calling(sub, p->context);
+                     chan_voicemngr_start_calling(sub, p->context);
                }
 
 	}
@@ -2218,7 +2218,7 @@ void handle_dtmf_calling(struct brcm_subchannel *sub)
 		//since no more digits can be added to the number
 		//(this is unlikely to happen since there is probably a "catch-all" extension)
 		ast_debug(9, "Unique extension matching %s found\n", p->dtmfbuf);
-		brcm_start_calling(sub, p->context);
+		chan_voicemngr_start_calling(sub, p->context);
 	}
 	else if (!ast_matchmore_extension(NULL, p->context, p->dtmfbuf, 1, p->cid_num))
 	{
@@ -2229,7 +2229,7 @@ void handle_dtmf_calling(struct brcm_subchannel *sub)
 	    p->dialtone = DIALTONE_UNOBTAINABLE;
 	    sub->channel_state = AWAITONHOOK;
 		p->dialtone_timeout_timer_id = ast_sched_add(sched, channel_config[p->line_id].offhook_nu_timeoutmsec, handle_dialtone_timeout, p);
-	    brcm_signal_dialtone(p);
+	    chan_voicemngr_signal_dialtone(p);
 	}
 	else {
                if (channel_config[p->line_id].minimumnumberdigits && strlen(p->dtmfbuf) >= channel_config[p->line_id].minimumnumberdigits ){
@@ -2253,10 +2253,10 @@ void handle_dtmf_calling(struct brcm_subchannel *sub)
 	}
 }
 
-static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchannel *sub_peer,
+static void handle_Rnumber_etsi(struct chan_voicemngr_subchannel *sub, struct chan_voicemngr_subchannel *sub_peer,
 		struct ast_channel *owner, struct ast_channel *peer_owner)
 {
-	struct brcm_pvt *p = sub->parent;
+	struct chan_voicemngr_pvt *p = sub->parent;
 
 	switch (p->dtmf_first) {
 		/* Force busy on waiting call or hang up call on hold */
@@ -2277,11 +2277,11 @@ static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchan
 			} else if (sub->channel_state == INCALL && sub_peer->channel_state == ONHOLD) {
 				ast_debug(2, "Hanging up call on hold\n");
 
-				sub_peer = brcm_get_onhold_subchannel(p);
+				sub_peer = chan_voicemngr_get_onhold_subchannel(p);
 
 				ast_queue_control(peer_owner, AST_CONTROL_HANGUP);
 				sub_peer->channel_state = CALLENDED;
-				brcm_close_connection(sub_peer);
+				chan_voicemngr_close_connection(sub_peer);
 			}
 			break;
 		/* Hangup current call and answer waiting call */
@@ -2293,12 +2293,12 @@ static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchan
 					ast_queue_control(owner, AST_CONTROL_HANGUP);
 				}
 				sub->channel_state = CALLENDED;
-				brcm_close_connection(sub);
+				chan_voicemngr_close_connection(sub);
 
 				if (sub_peer->channel_state == CALLWAITING) {
 					ast_log(LOG_WARNING, "R1 call waiting\n");
 					/* Stop call waiting tone on current call */
-					brcm_stop_callwaiting(p);
+					chan_voicemngr_stop_callwaiting(p);
 
 					if (ast_sched_del(sched, sub_peer->cw_timer_id)) {
 						ast_log(LOG_WARNING, "Failed to remove scheduled call waiting timer\n");
@@ -2308,7 +2308,7 @@ static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchan
 					/* Pick up call waiting */
 					if (!sub_peer->connection_init) {
 						ast_debug(9, "create_connection()\n");
-						brcm_create_connection(sub_peer);
+						chan_voicemngr_create_connection(sub_peer);
 					}
 					if (peer_owner) {
 						ast_queue_control(peer_owner, AST_CONTROL_ANSWER);
@@ -2319,7 +2319,7 @@ static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchan
 
 					/* Unhold inactive subchannel */
 					if (peer_owner) {
-						brcm_unmute_connection(sub_peer);
+						chan_voicemngr_unmute_connection(sub_peer);
 						ast_queue_unhold(peer_owner);
 						sub_peer->channel_state = INCALL;
 					}
@@ -2330,7 +2330,7 @@ static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchan
 		case '2':
 			if (sub->channel_state == INCALL && (sub_peer->channel_state == CALLWAITING || sub_peer->channel_state == ONHOLD)) {
 
-				brcm_mute_connection(sub);
+				chan_voicemngr_mute_connection(sub);
 				if (owner) {
 					ast_queue_hold(owner, NULL);
 				}
@@ -2339,7 +2339,7 @@ static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchan
 					ast_log(LOG_WARNING, "R2 Call waiting\n");
 
 					/* Stop call waiting tone on current call */
-					brcm_stop_callwaiting(p);
+					chan_voicemngr_stop_callwaiting(p);
 
 					/* Cancel timer */
 					if (ast_sched_del(sched, sub_peer->cw_timer_id)) {
@@ -2355,7 +2355,7 @@ static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchan
 					/* Pick up call waiting */
 					if (!sub_peer->connection_init) {
 						ast_debug(9, "create_connection()\n");
-						brcm_create_connection(sub_peer);
+						chan_voicemngr_create_connection(sub_peer);
 					}
 					if (peer_owner) {
 						ast_queue_control(peer_owner, AST_CONTROL_ANSWER);
@@ -2366,7 +2366,7 @@ static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchan
 
 					/* Unhold inactive subchannel */
 					if (peer_owner) {
-						brcm_unmute_connection(sub_peer);
+						chan_voicemngr_unmute_connection(sub_peer);
 						ast_queue_unhold(peer_owner);
 						sub_peer->channel_state = INCALL;
 					}
@@ -2379,15 +2379,15 @@ static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchan
 		case '3':
 			if (sub->channel_state == INCALL && sub_peer->channel_state == ONHOLD) {
 				ast_debug(2, "DTMF3 after HF\n");
-				brcm_create_conference(p);
+				chan_voicemngr_create_conference(p);
 			}
 			break;
 		/* Remote transfer held call to active call */
 		case '4':
-			brcm_attended_call_transfer(sub, sub_peer, owner, peer_owner);
+			chan_voicemngr_attended_call_transfer(sub, sub_peer, owner, peer_owner);
 			break;
 		case '5':
-			brcm_unattended_call_transfer(sub, sub_peer, owner, peer_owner);
+			chan_voicemngr_unattended_call_transfer(sub, sub_peer, owner, peer_owner);
 			break;
 		default:
 			ast_log(LOG_NOTICE, "Unhandled DTMF %c\n", p->dtmfbuf[0]);
@@ -2395,17 +2395,17 @@ static void handle_Rnumber_etsi(struct brcm_subchannel *sub, struct brcm_subchan
 	}
 }
 
-static void handle_Rnumber_uk(struct brcm_subchannel *sub, struct brcm_subchannel *sub_peer,
+static void handle_Rnumber_uk(struct chan_voicemngr_subchannel *sub, struct chan_voicemngr_subchannel *sub_peer,
 		struct ast_channel *owner, struct ast_channel *peer_owner)
 {
-	struct brcm_pvt *p = sub->parent;
+	struct chan_voicemngr_pvt *p = sub->parent;
 
 	switch (p->dtmf_first) {
 		case '4':
-			brcm_attended_call_transfer(sub, sub_peer, owner, peer_owner);
+			chan_voicemngr_attended_call_transfer(sub, sub_peer, owner, peer_owner);
 			break;
 		case '5':
-			brcm_unattended_call_transfer(sub, sub_peer, owner, peer_owner);
+			chan_voicemngr_unattended_call_transfer(sub, sub_peer, owner, peer_owner);
 			break;
 		default:
 			ast_log(LOG_ERROR, "Unhandled DTMF %c\n", p->dtmfbuf[0]);
@@ -2413,13 +2413,13 @@ static void handle_Rnumber_uk(struct brcm_subchannel *sub, struct brcm_subchanne
 	}
 }
 
-static void handle_Rkey_uk(struct brcm_subchannel *sub, struct brcm_subchannel *sub_peer,
+static void handle_Rkey_uk(struct chan_voicemngr_subchannel *sub, struct chan_voicemngr_subchannel *sub_peer,
 		struct ast_channel *owner, struct ast_channel *peer_owner)
 {
-	struct brcm_pvt *p = sub->parent;
+	struct chan_voicemngr_pvt *p = sub->parent;
 
 	if (sub->channel_state == INCALL && (sub_peer->channel_state == CALLWAITING || sub_peer->channel_state == ONHOLD)) {
-		brcm_mute_connection(sub);
+		chan_voicemngr_mute_connection(sub);
 		if (sub_peer->channel_state == CALLWAITING) {
 			if (owner) {
 				ast_queue_hold(owner, NULL);
@@ -2437,7 +2437,7 @@ static void handle_Rkey_uk(struct brcm_subchannel *sub, struct brcm_subchannel *
 			/* Pick up call waiting */
 			if (!sub_peer->connection_init) {
 				ast_debug(9, "create_connection()\n");
-				brcm_create_connection(sub_peer);
+				chan_voicemngr_create_connection(sub_peer);
 			}
 			if (peer_owner) {
 				ast_queue_control(peer_owner, AST_CONTROL_ANSWER);
@@ -2452,11 +2452,11 @@ static void handle_Rkey_uk(struct brcm_subchannel *sub, struct brcm_subchannel *
 				sub->channel_state = INCALL;
 				sub->conf_timer_id = ast_sched_add(sched, dtmf_wait_timer, setup_conference_call_cb, p);
 			} else if (sub->call_direction == INCOMING_CALL){
-				brcm_unmute_connection(sub_peer);
+				chan_voicemngr_unmute_connection(sub_peer);
 				ast_queue_unhold(peer_owner);
 				sub_peer->channel_state = INCALL;
 
-				brcm_mute_connection(sub);
+				chan_voicemngr_mute_connection(sub);
 				ast_queue_hold(owner, NULL);
 				sub->channel_state = ONHOLD;
 			}
@@ -2464,8 +2464,8 @@ static void handle_Rkey_uk(struct brcm_subchannel *sub, struct brcm_subchannel *
 	} else if ((sub->channel_state == DIALING || sub->channel_state == OFFHOOK || sub->channel_state == RINGBACK) &&
 			sub_peer->channel_state != ONHOLD) {
 		ast_log(LOG_NOTICE, "R while offhook/dialing\n");
-		brcm_cancel_dialing_timeouts(p);
-		brcm_reset_dtmf_buffer(p);
+		chan_voicemngr_cancel_dialing_timeouts(p);
+		chan_voicemngr_reset_dtmf_buffer(p);
 		p->hf_detected = 0;
 	}
 }
@@ -2474,12 +2474,12 @@ static void handle_Rkey_uk(struct brcm_subchannel *sub, struct brcm_subchannel *
  * Preconditions: One subchannel should be in CALLWAITING or ONHOLD,
  * 		  One subchannel should be in INCALL.
  * 		  channel locks are held
- *		  brcm_pvt->lock is held
+ *		  chan_voicemngr_pvt->lock is held
  */
-static void handle_hookflash(struct brcm_subchannel *sub, struct brcm_subchannel *sub_peer,
+static void handle_hookflash(struct chan_voicemngr_subchannel *sub, struct chan_voicemngr_subchannel *sub_peer,
 		struct ast_channel *owner, struct ast_channel *peer_owner)
 {
-	struct brcm_pvt *p = sub->parent;
+	struct chan_voicemngr_pvt *p = sub->parent;
 	struct ast_bridge *bridge;
 	struct ast_bridge_channel *bridge_channel;
 
@@ -2524,8 +2524,8 @@ static void handle_hookflash(struct brcm_subchannel *sub, struct brcm_subchannel
 		if (sub->channel_state == INCALL && (sub_peer->channel_state == ONHOOK || sub_peer->channel_state == CALLENDED)) {
 			ast_debug(2, "R while in call and idle peer subchannel\n");
 
-			brcm_cancel_dialing_timeouts(p);
-			brcm_reset_dtmf_buffer(p);
+			chan_voicemngr_cancel_dialing_timeouts(p);
+			chan_voicemngr_reset_dtmf_buffer(p);
 			p->hf_detected = 0;
 
 			/* Put current call on hold */
@@ -2536,15 +2536,15 @@ static void handle_hookflash(struct brcm_subchannel *sub, struct brcm_subchannel
 					}
 				}
 
-				brcm_send_ubus_event("CALL_HOLD",p->line_id);
-				brcm_mute_connection(sub);
+				chan_voicemngr_send_ubus_event("CALL_HOLD",p->line_id);
+				chan_voicemngr_mute_connection(sub);
 				sub->channel_state = ONHOLD;
 				ast_queue_hold(owner, NULL);
 			}
 
 			/* Provide new line */
 			p->dialtone = DIALTONE_ON;
-			brcm_signal_dialtone(p);
+			chan_voicemngr_signal_dialtone(p);
 			sub_peer->channel_state = OFFHOOK;
 			sub_peer->call_direction = OUTGOING_CALL;
 		/* If offhook/dialing/calling and peer subchannel is on hold, switch call */
@@ -2556,12 +2556,12 @@ static void handle_hookflash(struct brcm_subchannel *sub, struct brcm_subchannel
 
 			ast_debug(2, "R while offhook/dialing and peer subchannel on hold\n");
 
-			brcm_cancel_dialing_timeouts(p);
-			brcm_reset_dtmf_buffer(p);
+			chan_voicemngr_cancel_dialing_timeouts(p);
+			chan_voicemngr_reset_dtmf_buffer(p);
 			p->hf_detected = 0;
 
 			if (sub->channel_state == OFFHOOK || sub->channel_state == AWAITONHOOK) {
-				brcm_stop_dialtone(p);
+				chan_voicemngr_stop_dialtone(p);
 			}
 			sub->channel_state = ONHOOK;
 
@@ -2578,8 +2578,8 @@ static void handle_hookflash(struct brcm_subchannel *sub, struct brcm_subchannel
 						ast_log(LOG_NOTICE,"Pick up old unhold\n");
 					}
 				}
-				brcm_send_ubus_event("CALL_UNHOLD",p->line_id);
-				brcm_unmute_connection(sub_peer);
+				chan_voicemngr_send_ubus_event("CALL_UNHOLD",p->line_id);
+				chan_voicemngr_unmute_connection(sub_peer);
 				ast_queue_unhold(peer_owner);
 				sub_peer->channel_state = INCALL;
 			}
@@ -2587,11 +2587,11 @@ static void handle_hookflash(struct brcm_subchannel *sub, struct brcm_subchannel
 		} else if ((sub->channel_state == ONHOOK || sub->channel_state == CALLENDED) && sub_peer->channel_state == ONHOLD) {
 			ast_debug(2, "R when idle and peer subchannel on hold\n");
 
-			brcm_cancel_dialing_timeouts(p);
+			chan_voicemngr_cancel_dialing_timeouts(p);
 			p->hf_detected = 0;
 			if(sub->channel_state == RINGBACK) {
-				brcm_reset_dtmf_buffer(p);
-				brcm_stop_dialtone(p);
+				chan_voicemngr_reset_dtmf_buffer(p);
+				chan_voicemngr_stop_dialtone(p);
 			}
 
 			/* Hang up current */
@@ -2601,9 +2601,9 @@ static void handle_hookflash(struct brcm_subchannel *sub, struct brcm_subchannel
 
 			/* Pick up old */
 			if (peer_owner) {
-				brcm_unmute_connection(sub_peer);
+				chan_voicemngr_unmute_connection(sub_peer);
 				ast_queue_unhold(peer_owner);
-				brcm_send_ubus_event("CALL_UNHOLD",p->line_id);
+				chan_voicemngr_send_ubus_event("CALL_UNHOLD",p->line_id);
 				sub_peer->channel_state = INCALL;
 			}
 		} else if (sub->channel_state == RINGBACK && sub_peer->channel_state == ONHOLD) {
@@ -2622,13 +2622,13 @@ static void handle_hookflash(struct brcm_subchannel *sub, struct brcm_subchannel
 		else
 			handle_Rnumber_uk(sub, sub_peer, owner, peer_owner);
 	}
-	brcm_reset_dtmf_buffer(p);
+	chan_voicemngr_reset_dtmf_buffer(p);
 }
 
-static void handle_dect_event(struct brcm_subchannel *sub, struct brcm_subchannel *sub_peer,
+static void handle_dect_event(struct chan_voicemngr_subchannel *sub, struct chan_voicemngr_subchannel *sub_peer,
 		struct ast_channel *owner, struct ast_channel *peer_owner, enum LINE_EVENT event)
 {
-	struct brcm_pvt *p = sub->parent;
+	struct chan_voicemngr_pvt *p = sub->parent;
 
 	ast_log(LOG_NOTICE, "%s sub->channel_state = %d, sub_peer->channel_state = %d\n", __func__, sub->channel_state, sub_peer->channel_state);
 	if (event == EVENT_JOIN) {
@@ -2642,11 +2642,11 @@ static void handle_dect_event(struct brcm_subchannel *sub, struct brcm_subchanne
 		ast_log(LOG_NOTICE, "Switch detected for phone line %d\n", sub->parent->line_id);
 		// Toggle calls
 		if (sub->channel_state == INCALL && sub_peer->channel_state == ONHOLD) {
-			brcm_unmute_connection(sub_peer);
+			chan_voicemngr_unmute_connection(sub_peer);
 			ast_queue_unhold(peer_owner);
 			sub_peer->channel_state = INCALL;
 
-			brcm_mute_connection(sub);
+			chan_voicemngr_mute_connection(sub);
 			ast_queue_hold(owner, NULL);
 			sub->channel_state = ONHOLD;
 		}
@@ -2659,24 +2659,24 @@ static void handle_dect_event(struct brcm_subchannel *sub, struct brcm_subchanne
 		} else if ((sub->channel_state == RINGBACK || sub->channel_state == CALLENDED) && sub_peer->channel_state == ONHOLD) {
 			endpt_signal(sub->parent->line_id, "ringback", "off", NULL);
 			ast_queue_control(owner, AST_CONTROL_HANGUP);
-			brcm_unmute_connection(sub_peer);
+			chan_voicemngr_unmute_connection(sub_peer);
 			ast_queue_unhold(peer_owner);
 			sub_peer->channel_state = INCALL;
 		} else if (sub->channel_state == AWAITONHOOK && sub_peer->channel_state == ONHOLD) {
 			sub->channel_state = ONHOOK;
-			brcm_unmute_connection(sub_peer);
+			chan_voicemngr_unmute_connection(sub_peer);
 			ast_queue_unhold(peer_owner);
 			sub_peer->channel_state = INCALL;
 		}
 	}
-	brcm_reset_dtmf_buffer(p);
+	chan_voicemngr_reset_dtmf_buffer(p);
 }
 
 static void handle_dtmf(enum LINE_EVENT event,
-		struct brcm_subchannel *sub, struct brcm_subchannel *sub_peer,
+		struct chan_voicemngr_subchannel *sub, struct chan_voicemngr_subchannel *sub_peer,
 		struct ast_channel *owner, struct ast_channel *peer_owner)
 {
-	struct brcm_pvt *p;
+	struct chan_voicemngr_pvt *p;
 	const DTMF_CHARNAME_MAP *dtmfMap = dtmf_to_charname;
 	struct timeval tim;
 
@@ -2697,7 +2697,7 @@ static void handle_dtmf(enum LINE_EVENT event,
 	if (p->dtmf_first < 0) {
 		p->dtmf_first = dtmf_button;
 		ast_debug(9,"Pressed DTMF %s\n", dtmfMap->name);
-		if (owner && brcm_should_relay_dtmf(sub)) {
+		if (owner && chan_voicemngr_should_relay_dtmf(sub)) {
 			// INCALL
 			send_outgoing_dtmf(owner, dtmf_button, AST_FRAME_DTMF_BEGIN);
 		}
@@ -2712,7 +2712,7 @@ static void handle_dtmf(enum LINE_EVENT event,
 			ast_debug(2, "DTMF after HF\n");
 			p->hf_detected = 0;
 			if (sub->channel_state == INCALL &&
-				(brcm_in_callwaiting(p) || brcm_in_onhold(p) || brcm_in_conference(p))) {
+				(chan_voicemngr_in_callwaiting(p) || chan_voicemngr_in_onhold(p) || chan_voicemngr_in_conference(p))) {
 				handle_hookflash(sub, sub_peer, owner, peer_owner);
 			} else {
 				/* HF while not in a call doesn't make sense */
@@ -2722,9 +2722,9 @@ static void handle_dtmf(enum LINE_EVENT event,
 						onhold: %d, \
 						conference: %d\n",
 					sub->channel_state,
-					brcm_in_callwaiting(p),
-					brcm_in_onhold(p),
-					brcm_in_conference(p));
+					chan_voicemngr_in_callwaiting(p),
+					chan_voicemngr_in_onhold(p),
+					chan_voicemngr_in_conference(p));
 			}
 		} else {
 			//ast_debug(5,"DTMF %s in state %s.\n", dtmfMap->name, state2str(sub->channel_state));
@@ -2778,7 +2778,7 @@ static void send_outgoing_dtmf(struct ast_channel *owner, char dtmf_button, int
 
 	memset(&frame, 0, sizeof frame);
 	ast_debug(2, "Sending DTMF %c %s\n", dtmf_button, ast_channel_name(owner));
-	frame.src = brcm_tech.type;
+	frame.src = chan_voicemngr_tech.type;
 	frame.frametype = frametype;
 	frame.subclass.integer = dtmf_button;
 
@@ -2802,27 +2802,27 @@ static struct ast_format *map_rtptype_to_format(uint8_t payload_type) {
 
 /* Handle audio packets from voicemngr. */
 static void audio_packet_handler(pe_packet_t *p) {
-	struct brcm_subchannel *sub;
-	int packet_type  = BRCM_UNKNOWN, drop_frame = 0;
+	struct chan_voicemngr_subchannel *sub;
+	int packet_type  = CHAN_VOICEMNGR_UNKNOWN, drop_frame = 0;
 	audio_packet_t *ap = (audio_packet_t *)p->data;
 	uint8_t payload_type = ap->rtp[1];
 	struct ast_frame frame = { .src = "TELCHAN", };
-	struct brcm_pvt *pvt;
+	struct chan_voicemngr_pvt *pvt;
 
 	// Clear the RTP marker bit
 	if ((payload_type & RTP_MARKER_BIT) && payload_type < RTCP_SR)
 		payload_type &= (~RTP_MARKER_BIT);
 
-	packet_type = brcm_classify_rtp_packet(payload_type);
-	pvt = brcm_get_pvt_from_lineid(iflist, ap->line);
-	sub = brcm_get_active_subchannel(pvt);
+	packet_type = chan_voicemngr_classify_rtp_packet(payload_type);
+	pvt = chan_voicemngr_get_pvt_from_lineid(iflist, ap->line);
+	sub = chan_voicemngr_get_active_subchannel(pvt);
 	if (!pvt || !sub) {
 		ast_log(LOG_ERROR, "Failed to find subchannel for %s/%d/%d\n", frame.src, ap->line, ap->cnx_id);
 		endpt_connection(ap->line, ap->cnx_id, "destroy"); // Request line close
 		return;
 	}
 
-	//pvt_lock(sub->parent, "brcm monitor packets");
+	//pvt_lock(sub->parent, "chan_voicemngr monitor packets");
 	//ast_mutex_lock(&sub->parent->lock);
 	struct ast_channel *owner = NULL;
 	if (sub->owner) {
@@ -2832,7 +2832,7 @@ static void audio_packet_handler(pe_packet_t *p) {
 
 	// We seem to get packets from DSP even if connection is muted (perhaps muting only affects packet callback).
 	// Drop packets if subchannel is on hold. Handle rtp packet according to classification.
-	if (sub->channel_state != ONHOLD && packet_type == BRCM_AUDIO && (ap->rtp[0] & 0x80) && ap->rtp_size) {
+	if (sub->channel_state != ONHOLD && packet_type == CHAN_VOICEMNGR_AUDIO && (ap->rtp[0] & 0x80) && ap->rtp_size) {
 		frame.frametype = AST_FRAME_VOICE;
 		frame.offset = 0;
 		frame.data.ptr = ap->rtp + 12;
@@ -2847,11 +2847,11 @@ static void audio_packet_handler(pe_packet_t *p) {
 				frame.samples = ast_codec_samples_count(&frame);
 			}
 		}
-	} else if (packet_type == BRCM_RTCP_SR || packet_type == BRCM_RTCP_RR) {
+	} else if (packet_type == CHAN_VOICEMNGR_RTCP_SR || packet_type == CHAN_VOICEMNGR_RTCP_RR) {
 		frame.frametype = AST_FRAME_RTCP;
 		frame.data.ptr = ap->rtp;
 		frame.datalen = ap->rtp_size;
-		frame.subclass.integer = (packet_type == BRCM_RTCP_SR ? RTCP_SR : RTCP_RR);
+		frame.subclass.integer = (packet_type == CHAN_VOICEMNGR_RTCP_SR ? RTCP_SR : RTCP_RR);
 	} else {
 		//ast_debug(5, "Dropping RTP frame of type %d.\n", packet_type);
 		drop_frame=1;
@@ -2868,7 +2868,7 @@ static void audio_packet_handler(pe_packet_t *p) {
 	}
 }
 
-static void brcm_cancel_dialing_timeouts(struct brcm_pvt *p)
+static void chan_voicemngr_cancel_dialing_timeouts(struct chan_voicemngr_pvt *p)
 {
 	//If we have interdigit timeout, cancel it
 	if (p->interdigit_timer_id > 0) {
@@ -2886,7 +2886,7 @@ static void brcm_cancel_dialing_timeouts(struct brcm_pvt *p)
 	}
 }
 
-static int brcm_should_relay_dtmf(const struct brcm_subchannel *sub)
+static int chan_voicemngr_should_relay_dtmf(const struct chan_voicemngr_subchannel *sub)
 {
 	if (sub->channel_state == INCALL && sub->parent->hf_detected == 0) {
 		return 1;
@@ -2906,7 +2906,7 @@ static int brcm_should_relay_dtmf(const struct brcm_subchannel *sub)
 static int call_cli_command(const char *cmd, int (*check_output)(const char *, const char *data), const char *data)
 {
         int res = 0;
-        char template[] = "/tmp/ast-brcm-XXXXXX";     /* template for temporary file */
+        char template[] = "/tmp/ast-chan_voicemngr-XXXXXX";     /* template for temporary file */
         char line[160];
         int fd_temp = -1;
         FILE *fp = NULL;
@@ -3053,11 +3053,11 @@ static int getLineState(const char *sip_account, char *lineCallStatus)
 	return call_cli_command(cmd, &check_endpoint_status, sip_account);
 }
 
-static void brcm_process_event(struct endpt_event *ev)
+static void chan_voicemngr_process_event(struct endpt_event *ev)
 {
-	struct brcm_pvt *p = NULL;
-	struct brcm_subchannel *sub = NULL;
-	struct brcm_subchannel *sub_peer = NULL;
+	struct chan_voicemngr_pvt *p = NULL;
+	struct chan_voicemngr_subchannel *sub = NULL;
+	struct chan_voicemngr_subchannel *sub_peer = NULL;
 	struct ast_channel *owner = NULL;
 	struct ast_channel *peer_owner = NULL;
 
@@ -3069,15 +3069,15 @@ static void brcm_process_event(struct endpt_event *ev)
 		return;
 	}
 
-	p = brcm_get_pvt_from_lineid(iflist, ev->line);
+	p = chan_voicemngr_get_pvt_from_lineid(iflist, ev->line);
 	if (!p) {
 		ast_debug(3, "No pvt with the correct line_id %d found!\n", ev->line);
 		return;
 	}
 
-	pvt_lock(p, "brcm monitor events");
-	sub = brcm_get_active_subchannel(p);
-	sub_peer = brcm_subchannel_get_peer(sub);
+	pvt_lock(p, "chan_voicemngr monitor events");
+	sub = chan_voicemngr_get_active_subchannel(p);
+	sub_peer = chan_voicemngr_subchannel_get_peer(sub);
 	if (!sub || !sub_peer) {
 		ast_debug(3, "sub-channels are not found\n");
 		pvt_unlock(p);
@@ -3111,7 +3111,7 @@ static void brcm_process_event(struct endpt_event *ev)
 		ast_channel_lock(peer_owner);
 	}
 
-	pvt_lock(p, "brcm monitor events");
+	pvt_lock(p, "chan_voicemngr monitor events");
 	if (sub) {
 		switch (ev->event) {
 		case EVENT_OFFHOOK: {
@@ -3130,8 +3130,8 @@ static void brcm_process_event(struct endpt_event *ev)
 			if (owner) {
 				if (!sub->connection_init) {
 					ast_debug(9, "create_connection()\n");
-					brcm_stop_dialtone(p);
-					brcm_create_connection(sub);
+					chan_voicemngr_stop_dialtone(p);
+					chan_voicemngr_create_connection(sub);
 				}
 
 				if (sub->cw_timer_id > -1) {
@@ -3150,7 +3150,7 @@ static void brcm_process_event(struct endpt_event *ev)
 
 				sub->channel_state = INCALL;
 				ast_queue_control(owner, AST_CONTROL_ANSWER);
-				brcm_send_ubus_event("ANSWERED_CALL",p->line_id);
+				chan_voicemngr_send_ubus_event("ANSWERED_CALL",p->line_id);
 			} else if (sub_peer->channel_state == ONHOLD) {
 				/* Picking up during reminder ringing for call on hold */
 				if (ast_sched_del(sched, sub_peer->onhold_hangup_timer_id) < 0) {
@@ -3160,18 +3160,18 @@ static void brcm_process_event(struct endpt_event *ev)
 				sub->channel_state = CALLENDED;
 				sub_peer->channel_state = INCALL;
 				ast_queue_control(peer_owner, AST_CONTROL_ANSWER);
-				brcm_unmute_connection(sub_peer);
+				chan_voicemngr_unmute_connection(sub_peer);
 				endpt_connection(sub_peer->parent->line_id, sub_peer->call_id, "create");
 				ast_queue_unhold(peer_owner);
-				brcm_send_ubus_event("CALL_UNHOLD", p->line_id);
+				chan_voicemngr_send_ubus_event("CALL_UNHOLD", p->line_id);
 			} else if (sub->channel_state == OFFHOOK) {
 				/* EVENT_OFFHOOK changed endpoint state to OFFHOOK, apply dialtone */
 				if ( p->context[0] != '\0' && is_sip_account_registered(p->context)) {
 					ast_debug(9, "Resetting dial tones.\n");
 					channel_settings *s = &channel_config[p->line_id];
 					p->dialtone = voicemail_messages_waiting(p->context) ? mwi_dialtone_state : s->mwi_enabled ? DIALTONE_SPECIAL_CONDITION: DIALTONE_ON;
-					brcm_signal_dialtone(p);
-					brcm_send_ubus_event("DIALTONE_ON", p->line_id);
+					chan_voicemngr_signal_dialtone(p);
+					chan_voicemngr_send_ubus_event("DIALTONE_ON", p->line_id);
 
 					if (strlen(s->autodial_ext)) {
 						/* Schedule autodial timeout if autodial extension is set */
@@ -3191,14 +3191,14 @@ static void brcm_process_event(struct endpt_event *ev)
 			strncpy(p->extensionCallStatus, "Idle", CALL_STATUS_MAX_LEN);
 			if (sub->channel_state == OFFHOOK || sub->channel_state == AWAITONHOOK) {
 				/* Received EVENT_ONHOOK in state OFFHOOK/AWAITONHOOK, stop dial/congestion tone */
-				brcm_stop_dialtone(p);
+				chan_voicemngr_stop_dialtone(p);
 			} else if (sub->channel_state == RINGBACK) {
 				/* Outgoing unanswered call - rtp stats need to be collected */
-				brcm_getRtpStats(owner);
+				chan_voicemngr_getRtpStats(owner);
 			}
 
 			sub->channel_state = ONHOOK;
-			brcm_cancel_dialing_timeouts(p);
+			chan_voicemngr_cancel_dialing_timeouts(p);
 			p->hf_detected = 0;
 
 			if (sub_peer->channel_state  == CALLENDED)
@@ -3218,7 +3218,7 @@ static void brcm_process_event(struct endpt_event *ev)
 				/* Remind user of waiting call */
 				sub_peer->channel_state = RINGING;
 				p->tech->signal_ringing(p);
-				brcm_send_ubus_event("RINGING",p->line_id);
+				chan_voicemngr_send_ubus_event("RINGING",p->line_id);
 			} else if (sub_peer->channel_state == ONHOLD) {
 				/* Remind user of call on hold */
 				sub_peer->onhold_hangup_timer_id = ast_sched_add(sched, onholdhanguptimeout * 1000, onholdhanguptimeout_cb, sub_peer);
@@ -3229,7 +3229,7 @@ static void brcm_process_event(struct endpt_event *ev)
 				p->tech->signal_callerid(sub_peer->owner, sub_peer);
 				sub->channel_state = RINGING;
 				ast_queue_control(peer_owner, AST_CONTROL_RINGING);
-				brcm_send_ubus_event("RINGING",p->line_id);
+				chan_voicemngr_send_ubus_event("RINGING",p->line_id);
 			} else if (peer_owner && sub_peer->channel_state != TRANSFERING) {
 				/* Hangup peer subchannels in call or on hold */
 				ast_debug(2, "Hanging up call (not transfering)\n");
@@ -3254,14 +3254,14 @@ static void brcm_process_event(struct endpt_event *ev)
 		case EVENT_DTMFS:
 		case EVENT_DTMFH:
 			{
-				brcm_cancel_dialing_timeouts(p);
+				chan_voicemngr_cancel_dialing_timeouts(p);
 
 				unsigned int old_state = sub->channel_state;
 				handle_dtmf(ev->event, sub, sub_peer, owner, peer_owner);
 				if (sub->channel_state == DIALING && old_state != sub->channel_state) {
 					/* DTMF event took channel state to DIALING. Stop dial tone. */
 					ast_debug(2, "Dialing. Stop dialtone.\n");
-					brcm_stop_dialtone(p);
+					chan_voicemngr_stop_dialtone(p);
 				}
 
 				if (sub->channel_state == DIALING) {
@@ -3280,7 +3280,7 @@ static void brcm_process_event(struct endpt_event *ev)
 			if (sub->channel_state == RINGING || (sub->channel_state == INCALL && sub_peer->channel_state == CALLWAITING)) {
 				const char *linkedid = ast_channel_linkedid(owner);
 				const char *peer_linkedid;
-				struct brcm_pvt *pvt = iflist;
+				struct chan_voicemngr_pvt *pvt = iflist;
 				int i;
 
 				if (peer_owner)
@@ -3291,7 +3291,7 @@ static void brcm_process_event(struct endpt_event *ev)
 					pvt_lock(pvt, "lock pvt for call reject");
 
 					for (i = 0; i < NUM_SUBCHANNELS; i++) {
-						struct brcm_subchannel *sc = pvt->sub[i];
+						struct chan_voicemngr_subchannel *sc = pvt->sub[i];
 						if ((sc->channel_state == RINGING || sc->channel_state == CALLWAITING) && sc->owner) {
 							const char *link = ast_channel_linkedid(sc->owner);
 
@@ -3312,10 +3312,10 @@ static void brcm_process_event(struct endpt_event *ev)
 					}
 
 					pvt_unlock(pvt);
-					pvt = brcm_get_next_pvt(pvt);
+					pvt = chan_voicemngr_get_next_pvt(pvt);
 				}
 
-				brcm_send_ubus_event("CALL_REJECTED", ev->line);
+				chan_voicemngr_send_ubus_event("CALL_REJECTED", ev->line);
 			} else if (sub->channel_state == CALLENDED && owner) {
 					ast_queue_control(owner, AST_CONTROL_HANGUP);
 			}
@@ -3347,7 +3347,7 @@ static void brcm_process_event(struct endpt_event *ev)
 }
 
 /* Load settings for each line */
-static void brcm_initialize_pvt(struct brcm_pvt *p)
+static void chan_voicemngr_initialize_pvt(struct chan_voicemngr_pvt *p)
 {
 	channel_settings *s = &channel_config[p->line_id];
 
@@ -3358,14 +3358,14 @@ static void brcm_initialize_pvt(struct brcm_pvt *p)
 	ast_copy_string(p->cid_name, s->cid_name, sizeof(p->cid_name));
 }
 
-static struct brcm_pvt *brcm_allocate_pvt(void)
+static struct chan_voicemngr_pvt *chan_voicemngr_allocate_pvt(void)
 {
-	/* Make a brcm_pvt structure for this interface */
-	struct brcm_pvt *tmp;
+	/* Make a chan_voicemngr_pvt structure for this interface */
+	struct chan_voicemngr_pvt *tmp;
 
 	tmp = ast_calloc(1, sizeof(*tmp));
 	if (tmp) {
-		struct brcm_subchannel *sub;
+		struct chan_voicemngr_subchannel *sub;
 		int i;
 
 		for (i=0; i<NUM_SUBCHANNELS; i++) {
@@ -3415,13 +3415,13 @@ static struct brcm_pvt *brcm_allocate_pvt(void)
 }
 
 
-static void brcm_create_pvts(struct brcm_pvt *p, int mode) {
+static void chan_voicemngr_create_pvts(struct chan_voicemngr_pvt *p, int mode) {
 	int i;
-	struct brcm_pvt *tmp = iflist;
-	struct brcm_pvt *tmp_next;
+	struct chan_voicemngr_pvt *tmp = iflist;
+	struct chan_voicemngr_pvt *tmp_next;
 
 	for (i=0; i<num_endpoints ; i++) {
-		tmp_next = brcm_allocate_pvt();
+		tmp_next = chan_voicemngr_allocate_pvt();
 		if (tmp == NULL) {
 			iflist = tmp_next; //First loop round, set iflist to point at first pvt
 			tmp    = tmp_next;
@@ -3434,14 +3434,14 @@ static void brcm_create_pvts(struct brcm_pvt *p, int mode) {
 	}
 }
 
-static void brcm_assign_line_id(struct brcm_pvt *p)
+static void chan_voicemngr_assign_line_id(struct chan_voicemngr_pvt *p)
 {
-	struct brcm_pvt *tmp = p;
+	struct chan_voicemngr_pvt *tmp = p;
 	int i;
 	/* Assign line_id's */
 	for (i=0 ; i<num_endpoints ; i++) {
 		tmp->line_id = i;
-		brcm_initialize_pvt(tmp);
+		chan_voicemngr_initialize_pvt(tmp);
 		int j;
 		for (j=0; j<NUM_SUBCHANNELS; j++) {
 			tmp->sub[j]->channel_state = ONHOOK;
@@ -3450,7 +3450,7 @@ static void brcm_assign_line_id(struct brcm_pvt *p)
 	}
 }
 
-static int brcm_in_dialing(const struct brcm_pvt *p)
+static int chan_voicemngr_in_dialing(const struct chan_voicemngr_pvt *p)
 {
 	int i;
 	for (i=0; i<NUM_SUBCHANNELS; i++) {
@@ -3462,7 +3462,7 @@ static int brcm_in_dialing(const struct brcm_pvt *p)
 	return 0;
 }
 
-static int brcm_in_ringback(const struct brcm_pvt *p)
+static int chan_voicemngr_in_ringback(const struct chan_voicemngr_pvt *p)
 {
 	int i;
 	for (i=0; i<NUM_SUBCHANNELS; i++) {
@@ -3474,7 +3474,7 @@ static int brcm_in_ringback(const struct brcm_pvt *p)
 	return 0;
 }
 
-static int brcm_in_call(const struct brcm_pvt *p)
+static int chan_voicemngr_in_call(const struct chan_voicemngr_pvt *p)
 {
 	int i;
 	for (i=0; i<NUM_SUBCHANNELS; i++) {
@@ -3486,7 +3486,7 @@ static int brcm_in_call(const struct brcm_pvt *p)
 	return 0;
 }
 
-static int brcm_in_callwaiting(const struct brcm_pvt *p)
+static int chan_voicemngr_in_callwaiting(const struct chan_voicemngr_pvt *p)
 {
 	int i;
 	for (i=0; i<NUM_SUBCHANNELS; i++) {
@@ -3498,7 +3498,7 @@ static int brcm_in_callwaiting(const struct brcm_pvt *p)
 	return 0;
 }
 
-static int brcm_in_transferring(const struct brcm_pvt *p)
+static int chan_voicemngr_in_transferring(const struct chan_voicemngr_pvt *p)
 {
 	int i;
 	for (i=0; i<NUM_SUBCHANNELS; i++) {
@@ -3510,7 +3510,7 @@ static int brcm_in_transferring(const struct brcm_pvt *p)
 	return 0;
 }
 
-static int brcm_in_onhold(const struct brcm_pvt *p)
+static int chan_voicemngr_in_onhold(const struct chan_voicemngr_pvt *p)
 {
 	int i;
 	for (i=0; i<NUM_SUBCHANNELS; i++) {
@@ -3522,7 +3522,7 @@ static int brcm_in_onhold(const struct brcm_pvt *p)
 	return 0;
 }
 
-static int brcm_in_conference(const struct brcm_pvt *p)
+static int chan_voicemngr_in_conference(const struct chan_voicemngr_pvt *p)
 {
 	return (p->sub[0]->channel_state == INCALL && 
 		p->sub[1]->channel_state == INCALL) ||
@@ -3533,7 +3533,7 @@ static int brcm_in_conference(const struct brcm_pvt *p)
 /*
  * Return idle subchannel
  */
-struct brcm_subchannel *brcm_get_idle_subchannel(const struct brcm_pvt *p)
+struct chan_voicemngr_subchannel *chan_voicemngr_get_idle_subchannel(const struct chan_voicemngr_pvt *p)
 {
 	int i;
 	for (i=0; i<NUM_SUBCHANNELS; i++) {
@@ -3544,10 +3544,10 @@ struct brcm_subchannel *brcm_get_idle_subchannel(const struct brcm_pvt *p)
 	return NULL;
 }
 
-static struct ast_channel *brcm_request(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *dest, int *cause)
+static struct ast_channel *chan_voicemngr_request(const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *dest, int *cause)
 {
-	struct brcm_pvt *p;
-	struct brcm_subchannel *sub = NULL;
+	struct chan_voicemngr_pvt *p;
+	struct chan_voicemngr_subchannel *sub = NULL;
 	struct ast_channel *tmp = NULL;
 	struct ast_str * buf = ast_str_create(256);
 	int line_id = -1;
@@ -3567,10 +3567,10 @@ static struct ast_channel *brcm_request(const char *type, struct ast_format_cap
 
 	/* Get line id */
 	line_id = atoi((char*)dest);
-	//ast_debug(1, "brcm_request = %s, line_id=%d, format %x\n", (char*) data, line_id, (unsigned int) format);
+	//ast_debug(1, "chan_voicemngr_request = %s, line_id=%d, format %x\n", (char*) data, line_id, (unsigned int) format);
 
 	/* Map id to the correct pvt */
-	p = brcm_get_pvt_from_lineid(iflist, line_id);
+	p = chan_voicemngr_get_pvt_from_lineid(iflist, line_id);
 
 	/* If the id doesn't exist (p==NULL) use 0 as default */
 	if (!p) {
@@ -3578,10 +3578,10 @@ static struct ast_channel *brcm_request(const char *type, struct ast_format_cap
 		p = iflist;
 	}
 
-	pvt_lock(p, "brcm request");
+	pvt_lock(p, "chan_voicemngr request");
 	//ast_mutex_lock(&p->lock);
 
-	sub = brcm_get_idle_subchannel(p);
+	sub = chan_voicemngr_get_idle_subchannel(p);
 
 	/* Check that the request has an allowed format */
 	if (!(ast_format_cap_has_type(cap, AST_MEDIA_TYPE_AUDIO))) {
@@ -3590,7 +3590,7 @@ static struct ast_channel *brcm_request(const char *type, struct ast_format_cap
 	} else if (sub) {
 		sub->channel_state = ALLOCATED;
 		sub->connection_id = ast_atomic_fetchadd_int((int *)&current_connection_id, +1);
-		tmp = brcm_new(sub, AST_STATE_DOWN, sub->parent->ext, sub->parent->context, assignedids, requestor ? requestor : NULL, cap);
+		tmp = chan_voicemngr_new(sub, AST_STATE_DOWN, sub->parent->ext, sub->parent->context, assignedids, requestor ? requestor : NULL, cap);
 	} else {
 		*cause = AST_CAUSE_BUSY;
 		ast_log(LOG_NOTICE, "Idle subchannel not found\n");
@@ -3606,29 +3606,29 @@ static struct ast_channel *brcm_request(const char *type, struct ast_format_cap
 }
 
 
-static void brcm_lock_pvts(void)
+static void chan_voicemngr_lock_pvts(void)
 {
-	struct brcm_pvt *p = iflist;
+	struct chan_voicemngr_pvt *p = iflist;
 	while(p) {
-		pvt_lock(p, "brcm lock pvts");
+		pvt_lock(p, "chan_voicemngr lock pvts");
 		//ast_mutex_lock(&p->lock);
-		p = brcm_get_next_pvt(p);
+		p = chan_voicemngr_get_next_pvt(p);
 	}
 }
 
-static void brcm_unlock_pvts(void)
+static void chan_voicemngr_unlock_pvts(void)
 {
-	struct brcm_pvt *p = iflist;
+	struct chan_voicemngr_pvt *p = iflist;
 	while(p) {
 		pvt_unlock(p);
 		//ast_mutex_unlock(&p->lock);
-		p = brcm_get_next_pvt(p);
+		p = chan_voicemngr_get_next_pvt(p);
 	}
 }
 
-static void brcm_show_subchannels(struct ast_cli_args *a, struct brcm_pvt *p)
+static void chan_voicemngr_show_subchannels(struct ast_cli_args *a, struct chan_voicemngr_pvt *p)
 {
-	struct brcm_subchannel *sub;
+	struct chan_voicemngr_subchannel *sub;
 
 	/* Output status for sub channels */
 	int i;
@@ -3640,7 +3640,7 @@ static void brcm_show_subchannels(struct ast_cli_args *a, struct brcm_pvt *p)
 		ast_cli(a->fd, "  Owner               : %p\n", sub->owner);
 		ast_cli(a->fd, "  Channel state       : %s\n", state2str(sub->channel_state));
 		ast_cli(a->fd, "  Connection init     : %d\n", sub->connection_init);
-		ast_cli(a->fd, "  Codec used          : %s\n", brcm_get_codec_string(sub->codec));
+		ast_cli(a->fd, "  Codec used          : %s\n", chan_voicemngr_get_codec_string(sub->codec));
 		ast_cli(a->fd, "  RTP sequence number : %d\n", sub->sequence_number);
 		ast_cli(a->fd, "  RTP SSRC            : %d\n", sub->ssrc);
 		ast_cli(a->fd, "  RTP timestamp       : %d\n", sub->time_stamp);
@@ -3652,13 +3652,13 @@ static void brcm_show_subchannels(struct ast_cli_args *a, struct brcm_pvt *p)
 	}
 }
 
-static void brcm_show_pvts(struct ast_cli_args *a)
+static void chan_voicemngr_show_pvts(struct ast_cli_args *a)
 {
-	struct brcm_pvt *p = iflist;
+	struct chan_voicemngr_pvt *p = iflist;
 	int i = 0;
 
 	while(p) {
-		pvt_lock(p, "brcm show pvts");
+		pvt_lock(p, "chan_voicemngr show pvts");
 		//ast_mutex_lock(&p->lock);
 		ast_cli(a->fd, "\nPvt nr: %d\n",i);
 		ast_cli(a->fd, "Line id             : %d\n", p->line_id);
@@ -3691,24 +3691,24 @@ static void brcm_show_pvts(struct ast_cli_args *a)
 		ast_cli(a->fd, "Dialtone Timer id   : %d\n", p->dialtone_timeout_timer_id);
 
 		/* Print status for subchannels */
-		brcm_show_subchannels(a, p);
+		chan_voicemngr_show_subchannels(a, p);
 
 		ast_cli(a->fd, "\n");
 
 		i++;
 		pvt_unlock(p);
 		//ast_mutex_unlock(&p->lock);
-		p = brcm_get_next_pvt(p);
+		p = chan_voicemngr_get_next_pvt(p);
 	}
 }
 
-/*! \brief CLI for showing brcm status.
+/*! \brief CLI for showing chan_voicemngr status.
  * This is a new-style CLI handler so a single function contains
  * the prototype for the function, the 'generator' to produce multiple
  * entries in case it is required, and the actual handler for the command.
  */
 
-static char *brcm_show_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+static char *chan_voicemngr_show_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
 	char buffer[AST_MAX_EXTENSION];
 
@@ -3716,37 +3716,37 @@ static char *brcm_show_status(struct ast_cli_entry *e, int cmd, struct ast_cli_a
 		e->command = "telephony show status";
 		e->usage =
 			"Usage: telephony show status\n"
-			"       Shows the current chan_brcm status.\n";
+			"       Shows the current chan_voicemngr status.\n";
 		return NULL;
 	} else if (cmd == CLI_GENERATE)
 		return NULL;
 
-	/* print chan brcm status information */
+	/* print chan chan_voicemngr status information */
 	ast_cli(a->fd, "Channel version: %s\n\n", CHANNEL_VERSION);
 	ast_cli(a->fd, "Number of endpoints: %d\n", num_endpoints);
 	ast_cli(a->fd, "FAC list      : %s\n", feature_access_code_string(buffer, AST_MAX_EXTENSION));
 
 	/* print status for individual pvts */
-	brcm_show_pvts(a);
+	chan_voicemngr_show_pvts(a);
 
 	return CLI_SUCCESS;
 }
 
-/*! \brief CLI for showing brcm dialtone status. */
-static char *brcm_show_dialtone_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+/*! \brief CLI for showing chan_voicemngr dialtone status. */
+static char *chan_voicemngr_show_dialtone_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
 	if (cmd == CLI_INIT) {
-		e->command = "brcm show dialtone status";
+		e->command = "chan_voicemngr show dialtone status";
 		e->usage =
-			"Usage: brcm show dialtone status\n"
-			"       Shows the current chan_brcm dialtone status.\n";
+			"Usage: chan_voicemngr show dialtone status\n"
+			"       Shows the current chan_voicemngr dialtone status.\n";
 		return NULL;
 	}
 	else if (cmd == CLI_GENERATE) {
 		return NULL;
 	}
 
-	struct brcm_pvt *p = iflist;
+	struct chan_voicemngr_pvt *p = iflist;
 	int i = 0;
 
 	ast_cli(a->fd, "Pvt nr\tDialtone\n\n");
@@ -3761,21 +3761,21 @@ static char *brcm_show_dialtone_status(struct ast_cli_entry *e, int cmd, struct
 		ast_cli(a->fd, "%d\t%s\n", i, dialtone->str);
 
 		i++;
-		p = brcm_get_next_pvt(p);
+		p = chan_voicemngr_get_next_pvt(p);
 	}
 
 	return CLI_SUCCESS;
 }
 
-/*! \brief CLI for reloading brcm config. */
-static char *brcm_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+/*! \brief CLI for reloading chan_voicemngr config. */
+static char *chan_voicemngr_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
 	struct ast_config *cfg = NULL;
 	if (cmd == CLI_INIT) {
 		e->command = "telephony reload";
 		e->usage =
 			"Usage: telephony reload\n"
-			"       Reload chan_brcm configuration.\n";
+			"       Reload chan_voicemngr configuration.\n";
 		return NULL;
 	} else if (cmd == CLI_GENERATE) {
 		return NULL;
@@ -3784,25 +3784,25 @@ static char *brcm_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *
 	ast_mutex_lock(&iflock);
 
 	/* Acquire locks for all pvt:s to prevent nasty things from happening */
-	brcm_lock_pvts();
+	chan_voicemngr_lock_pvts();
 
 	feature_access_code_clear();
 
 	/* Reload configuration */
         if (load_common_settings(&cfg)) {
-		brcm_unlock_pvts();
+		chan_voicemngr_unlock_pvts();
 		ast_mutex_unlock(&iflock);
 		return CLI_FAILURE;
 	}
 
 	load_settings(cfg);
-	struct brcm_pvt *p = iflist;
+	struct chan_voicemngr_pvt *p = iflist;
 	while(p) {
-		brcm_initialize_pvt(p);
-		p = brcm_get_next_pvt(p);
+		chan_voicemngr_initialize_pvt(p);
+		p = chan_voicemngr_get_next_pvt(p);
 	}
 
-	brcm_unlock_pvts();
+	chan_voicemngr_unlock_pvts();
 	ast_mutex_unlock(&iflock);
 
 	ast_verbose("TELCHAN reload done\n");
@@ -3810,14 +3810,14 @@ static char *brcm_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *
 	return CLI_SUCCESS;
 }
 
-static char *brcm_set_parameters_on_off(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+static char *chan_voicemngr_set_parameters_on_off(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
 	int on_off = 0;
 
 	if (cmd == CLI_INIT) {
-		e->command = "brcm set {echocancel|ringsignal} {on|off}";
+		e->command = "chan_voicemngr set {echocancel|ringsignal} {on|off}";
 		e->usage =
-			"Usage: brcm set {echocancel|ringsignal} {on|off} PvtNr\n"
+			"Usage: chan_voicemngr set {echocancel|ringsignal} {on|off} PvtNr\n"
 			"       echocancel, echocancel mode.\n"
 			"       ringsignal, ring signal mode.\n"
 			"       PvtNr, the Pvt to modify.\n";
@@ -3848,12 +3848,12 @@ static char *brcm_set_parameters_on_off(struct ast_cli_entry *e, int cmd, struct
 	return CLI_SUCCESS;
 }
 
-static char *brcm_set_parameters_value(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+static char *chan_voicemngr_set_parameters_value(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
 	if (cmd == CLI_INIT) {
-		e->command = "brcm set dialout_msecs";
+		e->command = "chan_voicemngr set dialout_msecs";
 		e->usage =
-			"Usage: brcm set dialout_msecs 4000 PvtNr\n"
+			"Usage: chan_voicemngr set dialout_msecs 4000 PvtNr\n"
 			"       dialout_msecs, dialout delay in msecs.\n"
 			"       PvtNr, the Pvt to modify.\n";
 		return NULL;
@@ -3874,15 +3874,15 @@ static char *brcm_set_parameters_value(struct ast_cli_entry *e, int cmd, struct
 	return CLI_SUCCESS;
 }
 
-static char *brcm_set_autodial_extension(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
+static char *chan_voicemngr_set_autodial_extension(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 {
-	struct brcm_pvt *p;
+	struct chan_voicemngr_pvt *p;
 
 	if (cmd == CLI_INIT) {
-		e->command = "brcm set autodial";
+		e->command = "chan_voicemngr set autodial";
 		e->usage =
-			"Usage: brcm set autodial 0 1234\n"
-			"       brcm set autodial 0 \"\"\n"
+			"Usage: chan_voicemngr set autodial 0 1234\n"
+			"       chan_voicemngr set autodial 0 \"\"\n"
 			"       autodial, extension to autodial on of hook.\n";
 		return NULL;
 	} else if (cmd == CLI_GENERATE)
@@ -3900,7 +3900,7 @@ static char *brcm_set_autodial_extension(struct ast_cli_entry *e, int cmd, struc
 			ast_copy_string(s->autodial_ext, a->argv[4], sizeof(s->autodial_ext));
 			break;
 		}
-		p = brcm_get_next_pvt(p);
+		p = chan_voicemngr_get_next_pvt(p);
 	}
 
 	return CLI_SUCCESS;
@@ -3908,19 +3908,19 @@ static char *brcm_set_autodial_extension(struct ast_cli_entry *e, int cmd, struc
 
 
 /*! \brief Channel CLI commands definition */
-static struct ast_cli_entry cli_brcm[] = {
-	AST_CLI_DEFINE(brcm_show_status, "Show chan_brcm status"),
-	AST_CLI_DEFINE(brcm_show_dialtone_status, "Show chan_brcm dialtone status"),
-	AST_CLI_DEFINE(brcm_set_parameters_on_off,  "Set chan_brcm parameters"),
-	AST_CLI_DEFINE(brcm_set_parameters_value,  "Set chan_brcm dialout msecs"),
-	AST_CLI_DEFINE(brcm_set_autodial_extension,  "Set chan_brcm autodial extension"),
-	AST_CLI_DEFINE(brcm_reload, "Reload chan_brcm configuration"),
+static struct ast_cli_entry cli_chan_voicemngr[] = {
+	AST_CLI_DEFINE(chan_voicemngr_show_status, "Show chan_voicemngr status"),
+	AST_CLI_DEFINE(chan_voicemngr_show_dialtone_status, "Show chan_voicemngr dialtone status"),
+	AST_CLI_DEFINE(chan_voicemngr_set_parameters_on_off,  "Set chan_voicemngr parameters"),
+	AST_CLI_DEFINE(chan_voicemngr_set_parameters_value,  "Set chan_voicemngr dialout msecs"),
+	AST_CLI_DEFINE(chan_voicemngr_set_autodial_extension,  "Set chan_voicemngr autodial extension"),
+	AST_CLI_DEFINE(chan_voicemngr_reload, "Reload chan_voicemngr configuration"),
 };
 
 
 static int unload_module(void)
 {
-	struct brcm_pvt *p, *pl;
+	struct chan_voicemngr_pvt *p, *pl;
 
 	//ast_sched_dump(sched);
 
@@ -3932,7 +3932,7 @@ static int unload_module(void)
 		p = iflist;
 		while(p) {
 			int i;
-			pvt_lock(p, "brcm unload module");
+			pvt_lock(p, "chan_voicemngr unload module");
 			//ast_mutex_lock(&p->lock);
 			for (i=0; i<NUM_SUBCHANNELS; i++) {
 				struct ast_channel *owner = p->sub[i]->owner;
@@ -3989,7 +3989,7 @@ static int unload_module(void)
 	}
 
 	/* Unregister CLI commands */
-	ast_cli_unregister_multiple(cli_brcm, ARRAY_LEN(cli_brcm));
+	ast_cli_unregister_multiple(cli_chan_voicemngr, ARRAY_LEN(cli_chan_voicemngr));
 
 	feature_access_code_clear();
 	ast_sched_context_destroy(sched);
@@ -4341,8 +4341,8 @@ static int endpt_get_count(void) {
 static void ubus_call_answer_rtp_stats(struct ubus_request *req, int type, struct blob_attr *msg) {
 	struct blob_attr *tb[__MAX_RTP_STATS];
 	uint16_t lineId = 0;
-	struct brcm_pvt *p = NULL;
-	struct brcm_subchannel *sub = NULL;
+	struct chan_voicemngr_pvt *p = NULL;
+	struct chan_voicemngr_subchannel *sub = NULL;
 
 	ast_log(LOG_DEBUG, "thread %d: got answer from voicemngr on rtp_stats ubus call.\n", ast_get_tid());
 	blobmsg_parse(endpt_rtp_stats_policy, __MAX_RTP_STATS, tb, blob_data(msg), blob_len(msg));
@@ -4350,13 +4350,13 @@ static void ubus_call_answer_rtp_stats(struct ubus_request *req, int type, struc
 	if (tb[RTP_STATS_LINE_ID])
 		lineId = blobmsg_get_u16(tb[RTP_STATS_LINE_ID]);
 
-	p = brcm_get_pvt_from_lineid(iflist, lineId);
+	p = chan_voicemngr_get_pvt_from_lineid(iflist, lineId);
 	if (!p) {
 		ast_log(LOG_ERROR, "No pvt with the line_id %d found!\n", lineId);
 		return;
 	}
 
-	sub = brcm_get_active_subchannel(p);
+	sub = chan_voicemngr_get_active_subchannel(p);
 	if (!sub) {
 		ast_log(LOG_ERROR, "No active subchannel to write rtp stats!\n");
 		return;
@@ -4436,21 +4436,21 @@ static int endpt_get_rtp_stats(int line) {
 	struct ubus_context *local_ctx;
 	struct blob_buf bb;
 	int ret;
-	struct brcm_pvt *p = NULL;
-	struct brcm_subchannel *sub = NULL;
+	struct chan_voicemngr_pvt *p = NULL;
+	struct chan_voicemngr_subchannel *sub = NULL;
 
 	/*
 	 * Reset rtp_stats first because ubus_call_answer_rtp_stats() will not be called if "ubus call endpt rtp_stats" fails,
 	 * e.g. an unanswered incoming call on which the connection is not created. In this case, all RTP statistics counters
 	 * shall be zeros.
 	 */
-	p = brcm_get_pvt_from_lineid(iflist, line);
+	p = chan_voicemngr_get_pvt_from_lineid(iflist, line);
 	if (!p) {
 		ast_log(LOG_ERROR, "No pvt with the line %d found!\n", line);
 		return -1;
 	}
 
-	sub = brcm_get_active_subchannel(p);
+	sub = chan_voicemngr_get_active_subchannel(p);
 	if (!sub) {
 		ast_log(LOG_ERROR, "No active subchannel to get rtp stats!\n");
 		return -1;
@@ -4522,7 +4522,7 @@ static int asterisk_event(struct ubus_context *ctx, struct ubus_object *obj,
 
 	ast_log(LOG_DEBUG, "event: %s, line: %d\n", ev->name, ev->line);
 	if(iflist && cur_tech)
-		brcm_process_event(ev);
+		chan_voicemngr_process_event(ev);
 
 	return UBUS_STATUS_OK;
 }
@@ -4549,7 +4549,7 @@ static int asterisk_call_status(struct ubus_context *ctx, struct ubus_object *ob
 
 	if (tb[CALL_STATUS_EXTENSION_ID]) {
 		extension = blobmsg_get_u32(tb[CALL_STATUS_EXTENSION_ID]);
-		struct brcm_pvt *p = iflist;
+		struct chan_voicemngr_pvt *p = iflist;
 
 		while(p) {
 			if (extension == p->line_id) {
@@ -4558,7 +4558,7 @@ static int asterisk_call_status(struct ubus_context *ctx, struct ubus_object *ob
 				res = UBUS_STATUS_OK;
 				break;
 			}
-			p = brcm_get_next_pvt(p);
+			p = chan_voicemngr_get_next_pvt(p);
 		}
 	} else if (tb[CALL_STATUS_LINE_ID]) {
 		line = blobmsg_get_u32(tb[CALL_STATUS_LINE_ID]);
@@ -4677,12 +4677,12 @@ static int load_module(void)
 		return AST_MODULE_LOAD_DECLINE;
 	}
 
-	if (!(brcm_tech.capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
+	if (!(chan_voicemngr_tech.capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
 		ao2_ref(default_cap, -1);
 		return AST_MODULE_LOAD_DECLINE;
 	}
 
-	ast_format_cap_append_by_type(brcm_tech.capabilities, AST_MEDIA_TYPE_AUDIO);
+	ast_format_cap_append_by_type(chan_voicemngr_tech.capabilities, AST_MEDIA_TYPE_AUDIO);
 	ast_format_cap_append(default_cap, ast_format_alaw, 0);
 	
 	// Init UBUS and wait for voicemngr to start
@@ -4748,22 +4748,22 @@ static int load_module(void)
 	}
 
 	load_settings(cfg);
-	brcm_create_pvts(iflist, 0);
-	brcm_assign_line_id(iflist);
+	chan_voicemngr_create_pvts(iflist, 0);
+	chan_voicemngr_assign_line_id(iflist);
 
 	ast_mutex_unlock(&iflock);
 
 	/* Make sure we can register our channel */
-	cur_tech = (struct ast_channel_tech *) &brcm_tech;
+	cur_tech = (struct ast_channel_tech *) &chan_voicemngr_tech;
 	if (ast_channel_register(cur_tech)) { 
-		ast_log(LOG_ERROR, "Unable to register channel class 'Brcm'\n");
+		ast_log(LOG_ERROR, "Unable to register channel class 'chan_voicemngr'\n");
 		ast_config_destroy(cfg);
 		unload_module();
 		goto err;
 	}
 
 	/* Register all channel CLI functions */
-	ast_cli_register_multiple(cli_brcm, ARRAY_LEN(cli_brcm));
+	ast_cli_register_multiple(cli_chan_voicemngr, ARRAY_LEN(cli_chan_voicemngr));
 	ast_config_destroy(cfg);
 
     if (ast_sched_start_thread(sched)) {
@@ -4780,21 +4780,21 @@ static int load_module(void)
 	return AST_MODULE_LOAD_FAILURE;
 }
 
-static int brcm_signal_callwaiting(const struct brcm_pvt *p)
+static int chan_voicemngr_signal_callwaiting(const struct chan_voicemngr_pvt *p)
 {
 	endpt_signal(p->line_id, "callwt", "on", NULL);
-	brcm_send_ubus_event("CALLWAITING",p->line_id);
+	chan_voicemngr_send_ubus_event("CALLWAITING",p->line_id);
 	return 0;
 }
 
-static int brcm_stop_callwaiting(const struct brcm_pvt *p)
+static int chan_voicemngr_stop_callwaiting(const struct chan_voicemngr_pvt *p)
 {
 	endpt_signal(p->line_id, "callwt", "off", NULL);
-	brcm_send_ubus_event("CALLWAITING_STOPPED", p->line_id);
+	chan_voicemngr_send_ubus_event("CALLWAITING_STOPPED", p->line_id);
 	return 0;
 }
 
-static int brcm_signal_ringing(struct brcm_pvt *p)
+static int chan_voicemngr_signal_ringing(struct chan_voicemngr_pvt *p)
 {
 	if (channel_config[p->line_id].ringsignal) {
 		endpt_signal(p->line_id, "ringing", "on", NULL);
@@ -4803,9 +4803,9 @@ static int brcm_signal_ringing(struct brcm_pvt *p)
 }
 
 
-static int brcm_stop_ringing(struct brcm_pvt *p)
+static int chan_voicemngr_stop_ringing(struct chan_voicemngr_pvt *p)
 {
-	ast_log(LOG_ERROR, "brcm_stop_ringing()\n");
+	ast_log(LOG_ERROR, "chan_voicemngr_stop_ringing()\n");
 	if (channel_config[p->line_id].ringsignal) {
 		endpt_signal(p->line_id, "ringing", "off", NULL);
 	}
@@ -4814,7 +4814,7 @@ static int brcm_stop_ringing(struct brcm_pvt *p)
 }
 
 /* Prepare endpoint for ringing. Caller ID signal pending. */
-static int brcm_signal_ringing_callerid_pending(struct brcm_pvt *p)
+static int chan_voicemngr_signal_ringing_callerid_pending(struct chan_voicemngr_pvt *p)
 {
 	if (channel_config[p->line_id].ringsignal) {
 		endpt_signal(p->line_id, "callid_ringing", "on", NULL);
@@ -4823,7 +4823,7 @@ static int brcm_signal_ringing_callerid_pending(struct brcm_pvt *p)
 	return 0;
 }
 
-static int brcm_stop_ringing_callerid_pending(struct brcm_pvt *p)
+static int chan_voicemngr_stop_ringing_callerid_pending(struct chan_voicemngr_pvt *p)
 {
 	if (channel_config[p->line_id].ringsignal) {
 		endpt_signal(p->line_id, "callid_ringing", "off", NULL);
@@ -4838,7 +4838,7 @@ static int brcm_stop_ringing_callerid_pending(struct brcm_pvt *p)
  * 'O' in number or name => not available
  * 'P' in number or name => presentation not allowed
  */
-static int brcm_signal_callerid(struct ast_channel *chan, struct brcm_subchannel *sub)
+static int chan_voicemngr_signal_callerid(struct ast_channel *chan, struct chan_voicemngr_subchannel *sub)
 {
 	if (channel_config[sub->parent->line_id].ringsignal) {
 		CLID_STRING clid_string;
@@ -4912,7 +4912,7 @@ static int brcm_signal_callerid(struct ast_channel *chan, struct brcm_subchannel
 	return 0;
 }
 
-static int brcm_create_connection(struct brcm_subchannel *sub) {
+static int chan_voicemngr_create_connection(struct chan_voicemngr_subchannel *sub) {
 	if (!sub->connection_init) {
 		/* generate random nr for rtp header */
 		sub->ssrc = rand();
@@ -4928,7 +4928,7 @@ static int brcm_create_connection(struct brcm_subchannel *sub) {
 			sub->call_id = CALLID_OBTAINING;
 		}
 
-		if(!brcm_in_onhold(sub->parent) && !brcm_in_call(sub->parent)) {		// Is there another connection already?
+		if(!chan_voicemngr_in_onhold(sub->parent) && !chan_voicemngr_in_call(sub->parent)) {		// Is there another connection already?
 			ast_debug(1, "Creating real endpoint connection for pvt line_id=%i, connection_id: %d, call_id: %d\n", sub->parent->line_id, sub->connection_id, sub->call_id);
 			endpt_connection(sub->parent->line_id, sub->call_id, "create");
 		} else if (get_callid_state(sub->call_id) == CALLID_ESTABLISHED) {
@@ -4940,22 +4940,22 @@ static int brcm_create_connection(struct brcm_subchannel *sub) {
 	return 0;
 }
 
-static int brcm_mute_connection(struct brcm_subchannel *sub)
+static int chan_voicemngr_mute_connection(struct chan_voicemngr_subchannel *sub)
 {
 	/* Workaround for AA. Unmuting is not working. Throw away packets in packets thread instead */
 	return 0;
 }
 
-static int brcm_unmute_connection(struct brcm_subchannel *sub)
+static int chan_voicemngr_unmute_connection(struct chan_voicemngr_subchannel *sub)
 {
 	/* Workaround for AA. Unmuting is not working. Throw away packets in packets thread instead */
 	return 0;
 }
 
 /* Put all subchannels in conferencing mode */
-static int brcm_create_conference(struct brcm_pvt *p)
+static int chan_voicemngr_create_conference(struct chan_voicemngr_pvt *p)
 {
-	struct brcm_subchannel *second, *onhold;
+	struct chan_voicemngr_subchannel *second, *onhold;
 	struct ast_bridge *onholdBridge, *secondBridge;
 	struct ast_channel *chanToKick[1];
 	struct ast_frame astFrame;
@@ -4964,7 +4964,7 @@ static int brcm_create_conference(struct brcm_pvt *p)
 	memset(&astFrame, 0, sizeof(astFrame));
 	astFrame.src = "TELCHAN";
 	// Second call from initiator.
-	second = brcm_get_active_subchannel(p);
+	second = chan_voicemngr_get_active_subchannel(p);
 	if(!second || !second->owner) return -1;
 	// Second bridge. Initiator + second remote call.
 	ast_channel_lock(second->owner);
@@ -4973,7 +4973,7 @@ static int brcm_create_conference(struct brcm_pvt *p)
 	if(!secondBridge) return -1;
 
 	// First call from initiator (is onhold).
-	onhold = brcm_get_onhold_subchannel(p);
+	onhold = chan_voicemngr_get_onhold_subchannel(p);
 	if(!onhold || !onhold->owner) return -1;
 
 	ast_log(LOG_NOTICE, "Starting conference for pvt line_id=%i connection_id=%d\n",
@@ -4992,12 +4992,12 @@ static int brcm_create_conference(struct brcm_pvt *p)
 	 * audio only. */
 	second->conference_initiator = 0;
 	second->conference_id = strdup(secondBridge->uniqueid);
-	brcm_mute_connection(second);
+	chan_voicemngr_mute_connection(second);
 	ast_queue_hold(second->owner, NULL);
 	second->channel_state = ONHOLD;
 	onhold->conference_id = strdup(onholdBridge->uniqueid);
 	onhold->conference_initiator = 1;
-	brcm_unmute_connection(onhold);
+	chan_voicemngr_unmute_connection(onhold);
 	ast_queue_unhold(second->owner);
 	onhold->channel_state = INCALL;
 	sched_yield();
@@ -5018,10 +5018,10 @@ static int brcm_create_conference(struct brcm_pvt *p)
 	return res;
 }
 
-static int brcm_stop_conference(struct brcm_subchannel *p)
+static int chan_voicemngr_stop_conference(struct chan_voicemngr_subchannel *p)
 {
 	struct ast_bridge *confBridge;
-	struct brcm_pvt *pvt;
+	struct chan_voicemngr_pvt *pvt;
 
 	pvt = p->parent;
 	if (p->connection_init && p->owner) {
@@ -5038,14 +5038,14 @@ static int brcm_stop_conference(struct brcm_subchannel *p)
 		}
 		ao2_ref(confBridge, -1);
 	}
-	brcm_send_ubus_event("CONFERENCE_STOPPED",pvt->line_id);
+	chan_voicemngr_send_ubus_event("CONFERENCE_STOPPED",pvt->line_id);
 	return 0;
 }
 
-static void brcm_attended_call_transfer(struct brcm_subchannel *sub, struct brcm_subchannel *sub_peer,
+static void chan_voicemngr_attended_call_transfer(struct chan_voicemngr_subchannel *sub, struct chan_voicemngr_subchannel *sub_peer,
 		struct ast_channel *owner, struct ast_channel *peer_owner)
 {
-	struct brcm_pvt *p = sub->parent;
+	struct chan_voicemngr_pvt *p = sub->parent;
 
 	if( channel_config[p->line_id].flashSpec == FLASH_SPEC_ETSI ||
 	    channel_config[p->line_id].flashSpec == FLASH_SPEC_UK && ((sub_peer->conf_timer_id != -1) || (sub->conf_timer_id != -1))) {
@@ -5104,10 +5104,10 @@ static void brcm_attended_call_transfer(struct brcm_subchannel *sub, struct brcm
 		ast_log(LOG_ERROR,"Late R4 ,Ignoring since conference should be set up by now \n");
 }
 
-static void brcm_unattended_call_transfer(struct brcm_subchannel *sub, struct brcm_subchannel *sub_peer,
+static void chan_voicemngr_unattended_call_transfer(struct chan_voicemngr_subchannel *sub, struct chan_voicemngr_subchannel *sub_peer,
 		struct ast_channel *owner, struct ast_channel *peer_owner)
 {
-	struct brcm_pvt *p = sub->parent;
+	struct chan_voicemngr_pvt *p = sub->parent;
 
 	ast_log(LOG_ERROR ,"flashSpec  sub_peer->conf_timer_id: %d, sub->conf_timer_id: %d\n", sub_peer->conf_timer_id, sub->conf_timer_id);
 	if((sub_peer->conf_timer_id != -1) || (sub->conf_timer_id != -1)) {
@@ -5144,13 +5144,13 @@ static void brcm_unattended_call_transfer(struct brcm_subchannel *sub, struct br
 		ast_log(LOG_ERROR,"Late R5 ,Ignoring since conference should be set up by now \n");
 }
 
-static int brcm_close_connection(struct brcm_subchannel *sub)
+static int chan_voicemngr_close_connection(struct chan_voicemngr_subchannel *sub)
 {
-	struct brcm_pvt *p = sub->parent;
+	struct chan_voicemngr_pvt *p = sub->parent;
 
 	if (sub->connection_init) {
-		if (!brcm_in_onhold(p) && !brcm_in_call(p) && !brcm_in_dialing(p) && !brcm_in_ringback(p) &&
-			!brcm_in_callwaiting(p) && !brcm_in_transferring(p)) { // Does the line have another call?
+		if (!chan_voicemngr_in_onhold(p) && !chan_voicemngr_in_call(p) && !chan_voicemngr_in_dialing(p) && !chan_voicemngr_in_ringback(p) &&
+			!chan_voicemngr_in_callwaiting(p) && !chan_voicemngr_in_transferring(p)) { // Does the line have another call?
 			ast_debug(1, "Closing real endpoint connection line_id: %d, connection_id=%d, call_id: %d\n", p->line_id, sub->connection_id, sub->call_id);
 			endpt_connection(p->line_id, sub->call_id, "destroy");
 		} else {
@@ -5168,7 +5168,7 @@ static int brcm_close_connection(struct brcm_subchannel *sub)
 }
 
 /* Generate rtp payload, 12 bytes of header and 160 bytes of ulaw payload */
-static void brcm_generate_rtp_packet(struct brcm_subchannel *sub, uint8_t *packet_buf, int type, int marker, int dtmf_timestamp, int seqno)
+static void chan_voicemngr_generate_rtp_packet(struct chan_voicemngr_subchannel *sub, uint8_t *packet_buf, int type, int marker, int dtmf_timestamp, int seqno)
 {
 	unsigned short* packet_buf16 = (unsigned short*)packet_buf;
 	unsigned int*   packet_buf32 = (unsigned int*)packet_buf;
@@ -5193,7 +5193,7 @@ static void brcm_generate_rtp_packet(struct brcm_subchannel *sub, uint8_t *packe
  * - Accumulate "Interarrival jitter" for farEndInterrivalJitter and jitter_count which are used to calculate
  *   averageFarEndInterarrivalJitter.
  */
-static void brcm_process_rtcp_packet(struct brcm_subchannel *p, uint8_t *rtcp_frame, uint32_t rtcp_size)
+static void chan_voicemngr_process_rtcp_packet(struct chan_voicemngr_subchannel *p, uint8_t *rtcp_frame, uint32_t rtcp_size)
 {
 	struct rtcp_header_t *rtcp_hdr = (struct rtcp_header_t *)rtcp_frame;
 	uint8_t *packet_end = rtcp_frame + rtcp_size;
@@ -5222,7 +5222,7 @@ static void brcm_process_rtcp_packet(struct brcm_subchannel *p, uint8_t *rtcp_fr
 	}
 }
 
-static void brcm_dialtone_set(struct brcm_pvt *p, dialtone_state state)
+static void chan_voicemngr_dialtone_set(struct chan_voicemngr_pvt *p, dialtone_state state)
 {
 	ast_debug(3, "Old dialtone: %s, new dialtone: %s\n",
 			dialtone_map[p->dialtone].str, dialtone_map[state].str);
@@ -5233,7 +5233,7 @@ static void brcm_dialtone_set(struct brcm_pvt *p, dialtone_state state)
 			dialtone_map[p->dialtone].str,
 			dialtone_map[state].str);
 		p->dialtone = state;
-		brcm_signal_dialtone(p);
+		chan_voicemngr_signal_dialtone(p);
 	}
 }
 
diff --git a/src/channels/chan_voicemngr.h b/src/channels/chan_voicemngr.h
index 1d3fdf4708c14542a1a282040fa7dbfb06b1fab7..9e80a168ddf3f710b14c78075fe2bf9b250bfc27 100644
--- a/src/channels/chan_voicemngr.h
+++ b/src/channels/chan_voicemngr.h
@@ -1,5 +1,5 @@
-/* Inteno AB, Stockholm, Sweden
- * Channel for Broadcom FXS ports
+/* IOPSYS Software Solutions AB
+ * Asterisk Channel for FXS and DECT
  */
 
 #ifndef CHAN_VOICEMNGR_H
@@ -38,7 +38,7 @@
 #define RTP_VERSION     2
 #define RTP_MARKER_BIT  (1<<7)
 
-enum brcm_channel_state {
+enum chan_voicemngr_channel_state {
 	ONHOOK,
 	OFFHOOK,
 	DIALING,
@@ -132,12 +132,12 @@ struct __attribute__((packed)) rtcp_header_t {
 #define RTCP_GET_VERSION(header)                ((header)->v_p_rc >> 6)
 #define RTCP_SR_GET_INTERARRIVAL_JITTER(header) ntohl(*((uint32_t *)(header) + 10))
 
-struct brcm_subchannel {
+struct chan_voicemngr_subchannel {
 	int id;
 	int call_id;			/* The call_id of connection assigned by pjsip */
 	struct ast_channel *owner;	/* Channel we belong to, possibly NULL */
 	int connection_id;		/* Current connection id, may be -1 */
-	enum brcm_channel_state channel_state;	/* Channel states */
+	enum chan_voicemngr_channel_state channel_state;	/* Channel states */
 	enum CALL_DIRECTION call_direction;		// Direction of call for the subchannel : 0 = incoming, 1 = outgoing
 	unsigned int connection_init;	/* State for endpoint id connection initialization */
 	struct ast_frame fr;		/* Frame */
@@ -146,7 +146,7 @@ struct brcm_subchannel {
 	unsigned int period;		/* Endpoint RTP period */
 	unsigned int ssrc;		/* Endpoint RTP synchronization source */
 	int codec;			/* Used codec */
-	struct brcm_pvt *parent;	/* brcm_line owning this subchannel */
+	struct chan_voicemngr_pvt *parent;	/* chan_voicemngr_line owning this subchannel */
 	int cw_timer_id;		/* Current call waiting timer id, -1 if no active timer */
 	int cwBeep_timer_id;		/* Current call waiting beep timer id, -1 if no active timer */
 	int r4_hangup_timer_id;		/* Current R4 hangup timer id, -1 if no active timer */
@@ -160,16 +160,16 @@ struct brcm_subchannel {
 	char blind_xfer_target[32];	/* Transfer target for unattended call transfer */
 };
 
-struct brcm_channel_tech {
-	int (* signal_ringing)(struct brcm_pvt *p);
-	int (* signal_ringing_callerid_pending)(struct brcm_pvt *p);
-	int (* signal_callerid)(struct ast_channel *chan, struct brcm_subchannel *s);
-	int (* stop_ringing)(struct brcm_pvt *p);
-	int (* stop_ringing_callerid_pending)(struct brcm_pvt *p);
-	int (* release)(struct brcm_pvt *p);
+struct chan_voicemngr_channel_tech {
+	int (* signal_ringing)(struct chan_voicemngr_pvt *p);
+	int (* signal_ringing_callerid_pending)(struct chan_voicemngr_pvt *p);
+	int (* signal_callerid)(struct ast_channel *chan, struct chan_voicemngr_subchannel *s);
+	int (* stop_ringing)(struct chan_voicemngr_pvt *p);
+	int (* stop_ringing_callerid_pending)(struct chan_voicemngr_pvt *p);
+	int (* release)(struct chan_voicemngr_pvt *p);
 };
 
-struct brcm_pvt {
+struct chan_voicemngr_pvt {
 	ast_mutex_t lock;
 	int fd;							/* Raw file descriptor for this device */
 	int line_id;				/* Maps to the correct port */
@@ -178,7 +178,7 @@ struct brcm_pvt {
 	int dtmf_first;					/* DTMF control state, button pushes generate 2 events, one on button down and one on button up */
 	struct ast_format_cap * lastformat;            /* Last output format */
 	struct ast_format_cap * lastinput;             /* Last input format */
-	struct brcm_pvt *next;			/* Next channel in list */
+	struct chan_voicemngr_pvt *next;			/* Next channel in list */
 	char offset[AST_FRIENDLY_OFFSET];
 	char buf[PHONE_MAX_BUF];					/* Static buffer for reading frames */
 	char context_direct[AST_MAX_EXTENSION];
@@ -190,10 +190,10 @@ struct brcm_pvt {
 	char cid_name[AST_MAX_EXTENSION];
 	char extensionCallStatus[CALL_STATUS_MAX_LEN];
 
-	struct brcm_subchannel *sub[NUM_SUBCHANNELS];	/* List of sub-channels, needed for callwaiting and 3-way support */
+	struct chan_voicemngr_subchannel *sub[NUM_SUBCHANNELS];	/* List of sub-channels, needed for callwaiting and 3-way support */
 	int hf_detected;			/* Hook flash detected */
 	dialtone_state dialtone;		/* Set by manager command */
-	struct brcm_channel_tech *tech;
+	struct chan_voicemngr_channel_tech *tech;
 
 	int interdigit_timer_id;		/* Id of timer that tracks interdigit timeout */
 	int autodial_timer_id;			/* Id of timer that tracks autodial timeout */
@@ -203,10 +203,10 @@ struct brcm_pvt {
 };
 
 enum rtp_type {
-	BRCM_UNKNOWN,
-	BRCM_AUDIO,
-	BRCM_RTCP_SR,
-	BRCM_RTCP_RR
+	CHAN_VOICEMNGR_UNKNOWN,
+	CHAN_VOICEMNGR_AUDIO,
+	CHAN_VOICEMNGR_RTCP_SR,
+	CHAN_VOICEMNGR_RTCP_RR
 };
 
 /* Mapping of DTMF to char/name/intval */
diff --git a/src/configs/brcm.conf.sample b/src/configs/brcm.conf.sample
deleted file mode 100644
index fb80497c1abb8737671599b1ec13c29e6c6a38de..0000000000000000000000000000000000000000
--- a/src/configs/brcm.conf.sample
+++ /dev/null
@@ -1,50 +0,0 @@
-;
-; Linux Telephony Interface
-;
-; Configuration file
-;
-[interfaces]
-;
-; Select a mode, either the phone jack provides dialtone, reads digits,
-; then starts PBX with the given extension (dialtone mode), or
-; immediately provides the PBX without reading any digits or providing
-; any dialtone (this is the immediate mode, the default).  Also, you
-; can set the mode to "fxo" if you have a linejack to make it operate
-; properly.
-;
-mode=immediate
-;mode=dialtone
-;mode=fxo
-;
-; You can decide which format to use by default, "g723.1" or "slinear".
-; XXX Be careful, sometimes the card causes kernel panics when running
-; in signed linear mode for some reason... XXX
-;
-;format=slinear
-format=g723.1
-;
-; And set the echo cancellation to "off", "low", "medium", and "high".
-; This is not supported on all phones.
-;
-echocancel=medium
-;
-; You can optionally use VAD/CNG silence supression
-;
-;silencesupression=yes
-;
-; List all devices we can use.  Contexts may also be specified
-;
-;context=local
-;
-; You can set txgain and rxgain for each device in the same way as context.
-; If you want to change default gain value (1.0 =~ 100%) for device, simple
-; add txgain or rxgain line before device line. But rememeber, if you change
-; volume all cards listed below will be affected by these values. You can
-; use float values (1.0, 0.5, 2.0) or percentage values (100%, 150%, 50%).
-;
-;txgain=100%
-;rxgain=1.0
-device => /dev/bcmendpoint0
-
-
-