diff --git a/src/abis_rsl.c b/src/abis_rsl.c
index 0fa32ed..1c78bf7 100644
--- a/src/abis_rsl.c
+++ b/src/abis_rsl.c
@@ -220,7 +220,7 @@
 }
 
 /* Send a BCCH_INFO message as per Chapter 8.5.1 */
-int rsl_bcch_info(struct gsm_bts *bts, u_int8_t type,
+int rsl_bcch_info(struct gsm_bts_trx *trx, u_int8_t type,
 		  const u_int8_t *data, int len)
 {
 	struct abis_rsl_dchan_hdr *dh;
@@ -233,12 +233,12 @@
 	msgb_tv_put(msg, RSL_IE_SYSINFO_TYPE, type);
 	msgb_tlv_put(msg, RSL_IE_FULL_BCCH_INFO, len, data);
 
-	msg->trx = bts->c0;
+	msg->trx = trx;
 
 	return abis_rsl_sendmsg(msg);
 }
 
-int rsl_sacch_filling(struct gsm_bts *bts, u_int8_t type, 
+int rsl_sacch_filling(struct gsm_bts_trx *trx, u_int8_t type, 
 		      const u_int8_t *data, int len)
 {
 	struct abis_rsl_common_hdr *ch;
@@ -251,13 +251,13 @@
 	msgb_tv_put(msg, RSL_IE_SYSINFO_TYPE, type);
 	msgb_tl16v_put(msg, RSL_IE_L3_INFO, len, data);
 
-	msg->trx = bts->c0;
+	msg->trx = trx;
 
 	return abis_rsl_sendmsg(msg);
 }
 
 /* Chapter 8.4.1 */
-int rsl_chan_activate(struct gsm_bts *bts, u_int8_t chan_nr,
+int rsl_chan_activate(struct gsm_bts_trx *trx, u_int8_t chan_nr,
 		      u_int8_t act_type,
 		      struct rsl_ie_chan_mode *chan_mode,
 		      struct rsl_ie_chan_ident *chan_ident,
@@ -286,6 +286,8 @@
 	msgb_tv_put(msg, RSL_IE_MS_POWER, ms_power);
 	msgb_tv_put(msg, RSL_IE_TIMING_ADVANCE, ta);
 
+	msg->trx = trx;
+
 	return abis_rsl_sendmsg(msg);
 }
 
@@ -349,6 +351,8 @@
 	msgb_tv_put(msg, RSL_IE_MS_POWER, ms_power);
 	msgb_tv_put(msg, RSL_IE_TIMING_ADVANCE, ta);
 
+	msg->trx = lchan->ts->trx;
+
 	return abis_rsl_sendmsg(msg);
 }
 
diff --git a/src/bsc_hack.c b/src/bsc_hack.c
index cadf41c..7fa12e7 100644
--- a/src/bsc_hack.c
+++ b/src/bsc_hack.c
@@ -584,17 +584,17 @@
 static_assert(sizeof(si6) >= sizeof(struct gsm48_system_information_type_6), type6)
 
 /* set all system information types */
-static int set_system_infos(struct gsm_bts *bts)
+static int set_system_infos(struct gsm_bts_trx *trx)
 {
 	int i;
 
 	for (i = 0; i < ARRAY_SIZE(bcch_infos); i++) {
-		rsl_bcch_info(bts, bcch_infos[i].type,
+		rsl_bcch_info(trx, bcch_infos[i].type,
 			      bcch_infos[i].data,
 			      bcch_infos[i].len);
 	}
-	rsl_sacch_filling(bts, RSL_SYSTEM_INFO_5, si5, sizeof(si5));
-	rsl_sacch_filling(bts, RSL_SYSTEM_INFO_6, si6, sizeof(si6));
+	rsl_sacch_filling(trx, RSL_SYSTEM_INFO_5, si5, sizeof(si5));
+	rsl_sacch_filling(trx, RSL_SYSTEM_INFO_6, si6, sizeof(si6));
 
 	return 0;
 }
@@ -648,10 +648,10 @@
 }
 
 
-static void bootstrap_rsl(struct gsm_bts *bts)
+static void bootstrap_rsl(struct gsm_bts_trx *trx)
 {
 	fprintf(stdout, "bootstrapping RSL MCC=%u MNC=%u\n", MCC, MNC);
-	set_system_infos(bts);
+	set_system_infos(trx);
 }
 
 static void mi_cb(int event, struct gsm_bts *bts)
@@ -661,7 +661,7 @@
 		bootstrap_om(bts);
 		break;
 	case EVT_E1_RSL_UP:
-		bootstrap_rsl(bts);
+		bootstrap_rsl(bts->c0);
 		break;
 	default:
 		/* FIXME: deal with TEI or L1 link loss */
