1 files changed, 117 insertions, 45 deletions

diff --git a/src/tbf_ul.cpp b/src/tbf_ul.cpp
index 9e763f4..9de1b6b 100644
--- a/src/tbf_ul.cpp
+++ b/src/tbf_ul.cpp
@@ -42,15 +42,16 @@ extern "C" {
 
 extern void *tall_pcu_ctx;
 
+
 /*
  * Store received block data in LLC message(s) and forward to SGSN
  * if complete.
  */
 int gprs_rlcmac_ul_tbf::assemble_forward_llc(const gprs_rlc_data *_data)
 {
-	const uint8_t *data = _data->block;
-	uint8_t len = _data->len;
-	const struct gprs_rlc_data_block_info *rdbi = &_data->block_info;
+	const uint8_t *data = _data->complete_blk;
+	uint8_t len = _data->completed_block_len;
+	const struct gprs_rlc_ul_data_block_info *rdbi = &_data->block_info;
 	GprsCodingScheme cs = _data->cs;
 
 	Decoding::RlcData frames[16], *frame;
@@ -87,48 +88,49 @@ int gprs_rlcmac_ul_tbf::assemble_forward_llc(const gprs_rlc_data *_data)
 }
 
 
-struct msgb *gprs_rlcmac_ul_tbf::create_ul_ack(uint32_t fn, uint8_t ts)
+struct msgb *gprs_rlcmac_ul_tbf::create_ul_ack(uint32_t fn)
 {
 	int final = (state_is(GPRS_RLCMAC_FINISHED));
 	struct msgb *msg;
-	int rc;
-	unsigned int rrbp = 0;
-	uint32_t new_poll_fn = 0;
 
 	if (final) {
-		if (poll_state == GPRS_RLCMAC_POLL_SCHED &&
-			ul_ack_state == GPRS_RLCMAC_UL_ACK_WAIT_ACK) {
+		if (poll_state != GPRS_RLCMAC_POLL_NONE) {
 			LOGP(DRLCMACUL, LOGL_DEBUG, "Polling is already "
-				"scheduled for %s, so we must wait for "
-				"the final uplink ack...\n", tbf_name(this));
+				"sheduled for %s, so we must wait for "
+				"final uplink ack...\n", tbf_name(this));
 			return NULL;
 		}
-
-		rc = check_polling(fn, ts, &new_poll_fn, &rrbp);
-		if (rc < 0)
+		if (bts->sba()->find(trx->trx_no, control_ts, (fn + 13) % 2715648)) {
+			LOGP(DRLCMACUL, LOGL_DEBUG, "Polling is already "
+				"scheduled for single block allocation...\n");
 			return NULL;
+		}
 	}
 
 	msg = msgb_alloc(23, "rlcmac_ul_ack");
 	if (!msg)
 		return NULL;
+
 	bitvec *ack_vec = bitvec_alloc(23);
 	if (!ack_vec) {
 		msgb_free(msg);
 		return NULL;
 	}
+
 	bitvec_unhex(ack_vec,
 		"2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b");
-	Encoding::write_packet_uplink_ack(bts_data(), ack_vec, this, final, rrbp);
+	Encoding::write_packet_uplink_ack(bts_data(), ack_vec, this, final);
 	bitvec_pack(ack_vec, msgb_put(msg, 23));
 	bitvec_free(ack_vec);
 
+
 	/* now we must set this flag, so we are allowed to assign downlink
 	 * TBF on PACCH. it is only allowed when TLLI is acknowledged. */
 	m_contention_resolution_done = 1;
 
 	if (final) {
-		set_polling(new_poll_fn, ts);
+		poll_state = GPRS_RLCMAC_POLL_SCHED;
+		poll_fn = (fn + 13) % 2715648;
 		/* waiting for final acknowledge */
 		ul_ack_state = GPRS_RLCMAC_UL_ACK_WAIT_ACK;
 		m_final_ack_sent = 1;
@@ -138,13 +140,81 @@ struct msgb *gprs_rlcmac_ul_tbf::create_ul_ack(uint32_t fn, uint8_t ts)
 	return msg;
 }
 
+egprs_rlc_ul_reseg_bsn_state gprs_rlcmac_ul_tbf::assemble_rlc_block_frm_segmented_blks(
+	const struct gprs_rlc_ul_header_generic *rlc, struct gprs_rlc_data *block,
+	uint8_t *data, const uint8_t block_idx )
+{
+	const struct gprs_rlc_ul_data_block_info *rdbi =
+			&rlc->block_info[block_idx];
+
+	uint8_t *rlc_data = 0;
+
+	if(rdbi->spb == 2){
+		rlc_data = &(block->complete_blk[0]);
+		
+		block->completed_block_len	= rlc->block_info[block_idx].data_len ;
+
+		memcpy(rlc_data, data + rlc->data_offs_bytes[block_idx], 
+				rlc->block_info[block_idx].data_len);
+
+		if(block->block_status_ul & EGPRS_RESEG_SECOND_BLOCK_RXD){
+			LOGP(DRLCMACUL, LOGL_DEBUG,
+				" first part is received"
+				" second part is already present set the status to complete\n");
+			block->block_status_ul = EGPRS_RESEG_DEFAULT;	
+
+			block->completed_block_len += Decoding::rlc_copy_to_aligned_buffer(rlc, block_idx, data,
+                                                rlc_data);
+			/* Assembling the resegmented split blocks */
+			memcpy(rlc_data + block->completed_block_len, &(block->block2[0]), block->len_block2);
+
+			block->completed_block_len +=block->len_block2;
+
+		}else{
+			LOGP(DRLCMACUL, LOGL_DEBUG,
+				" first part is received"
+				" second part is not received set the status to first block received\n");
+			block->block_status_ul = EGPRS_RESEG_FIRST_BLOCK_RXD;	
+			return EGPRS_RESEG_FIRST_BLOCK_RXD;
+		}
+				 
+	}else if(rdbi->spb == 3){
+		rlc_data = &(block->block2[0]);
+		block->len_block2 = Decoding::rlc_copy_to_aligned_buffer(rlc, block_idx, data,
+                                                rlc_data);
+		if(block->block_status_ul & EGPRS_RESEG_FIRST_BLOCK_RXD){
+			LOGP(DRLCMACUL, LOGL_DEBUG,
+			" second part is received"
+			" first part is already present set the status to complete\n");
+			block->block_status_ul = EGPRS_RESEG_DEFAULT;	
+
+			memcpy( &(block->complete_blk[0]) + block->completed_block_len, rlc_data, block->len_block2);
+			block->completed_block_len += block->len_block2;
+					
+		}else{
+			LOGP(DRLCMACUL, LOGL_DEBUG,
+				" second part is received"
+				" first part is not received set the status to second block received\n");
+			block->block_status_ul = EGPRS_RESEG_SECOND_BLOCK_RXD;	
+			return EGPRS_RESEG_SECOND_BLOCK_RXD;
+		}
+				 
+	}else{
+		LOGP(DRLCMACUL, LOGL_ERROR ,
+			" Not supported SPB for this EGPRS configuration \n");
+			OSMO_ASSERT(true);
+	}
+	return EGPRS_RESEG_DEFAULT;
+}
+
 int gprs_rlcmac_ul_tbf::rcv_data_block_acknowledged(
-	const struct gprs_rlc_data_info *rlc,
-	uint8_t *data, struct pcu_l1_meas *meas)
+	const struct gprs_rlc_ul_header_generic *rlc,
+	uint8_t *data, uint8_t len, struct pcu_l1_meas *meas)
 {
 	int8_t rssi = meas->have_rssi ? meas->rssi : 0;
 
 	const uint16_t ws = m_window.ws();
+	egprs_rlc_ul_reseg_bsn_state re_assemble_status;
 
 	this->state_flags |= (1 << GPRS_RLCMAC_FLAG_UL_DATA);
 
@@ -172,7 +242,7 @@ int gprs_rlcmac_ul_tbf::rcv_data_block_acknowledged(
 	for (block_idx = 0; block_idx < rlc->num_data_blocks; block_idx++) {
 		int num_chunks;
 		uint8_t *rlc_data;
-		const struct gprs_rlc_data_block_info *rdbi =
+		const struct gprs_rlc_ul_data_block_info *rdbi =
 			&rlc->block_info[block_idx];
 		bool need_rlc_data = false;
 		struct gprs_rlc_data *block;
@@ -180,11 +250,11 @@ int gprs_rlcmac_ul_tbf::rcv_data_block_acknowledged(
 		LOGP(DRLCMACUL, LOGL_DEBUG,
 			"%s: Got %s RLC data block: "
 			"CV=%d, BSN=%d, SPB=%d, "
-			"PI=%d, E=%d, TI=%d, bitoffs=%d\n",
+			"PI=%d, E=%d, TI=%d\n",
 			name(), rlc->cs.name(),
 			rdbi->cv, rdbi->bsn, rdbi->spb,
-			rdbi->pi, rdbi->e, rdbi->ti,
-			rlc->data_offs_bits[block_idx]);
+			rdbi->pi, rdbi->e, rdbi->ti
+			);
 
 		/* Check whether the block needs to be decoded */
 
@@ -221,38 +291,39 @@ int gprs_rlcmac_ul_tbf::rcv_data_block_acknowledged(
 		block = m_rlc.block(rdbi->bsn);
 		block->block_info = *rdbi;
 		block->cs = rlc->cs;
-		OSMO_ASSERT(rdbi->data_len < sizeof(block->block));
-		rlc_data = &(block->block[0]);
-		/* TODO: Handle SPB != 0 -> Set length to 2*len, add offset if
-		 * 2nd part. Note that resegmentation is currently disabled
-		 * within the UL assignment.
-		 */
+		OSMO_ASSERT(rdbi->data_len < sizeof(block->complete_blk));
+		rlc_data = &(block->complete_blk[0]);
+
+
 		if (rdbi->spb) {
 			LOGP(DRLCMACUL, LOGL_NOTICE,
-				"Got SPB != 0 but resegmentation has been "
-				"disabled, skipping %s data block with BSN %d, "
-				"TFI=%d.\n", rlc->cs.name(), rdbi->bsn,
+				"Got SPB(%d)  "
+				"cs(%s) data block with BSN (%d), "
+				"TFI(%d).\n",rdbi->spb,  rlc->cs.name(), rdbi->bsn,
 				rlc->tfi);
-			continue;
-		}
 
-		block->len =
-			Decoding::rlc_copy_to_aligned_buffer(rlc, block_idx, data,
-				rlc_data);
+			re_assemble_status = this->assemble_rlc_block_frm_segmented_blks(rlc, block, data , block_idx);
+			if(EGPRS_RESEG_DEFAULT != re_assemble_status){
+				continue;
+			}
+			 
+		}else{
+
+			block->completed_block_len	= rlc->block_info[block_idx].data_len ;
 
+			block->block_status_ul = EGPRS_RESEG_DEFAULT;	
+
+			memcpy(rlc_data, data + rlc->data_offs_bytes[block_idx] , 
+				rlc->block_info[block_idx].data_len); 
+		}
 		LOGP(DRLCMACUL, LOGL_DEBUG,
 			"%s: data_length=%d, data=%s\n",
-			name(), block->len, osmo_hexdump(rlc_data, block->len));
-
-		/* TODO: Handle SPB != 0 -> set state to partly received
-		 * (upper/lower) and continue with the loop, unless the other
-		 * part is already present.
-		 */
+			name(), block->completed_block_len, osmo_hexdump(rlc_data, block->completed_block_len));
 
 		/* Get/Handle TLLI */
 		if (rdbi->ti) {
 			num_chunks = Decoding::rlc_data_from_ul_data(
-				rdbi, rlc->cs, rlc_data, NULL, 0, &new_tlli);
+				&block->block_info, rlc->cs, rlc_data, NULL, 0, &new_tlli);
 
 			if (num_chunks < 0) {
 				bts->decode_error();
@@ -303,7 +374,7 @@ int gprs_rlcmac_ul_tbf::rcv_data_block_acknowledged(
 	 && this->m_window.v_q() == this->m_window.v_r()) { /* if complete */
 		struct gprs_rlc_data *block =
 			m_rlc.block(m_window.mod_sns(m_window.v_r() - 1));
-		const struct gprs_rlc_data_block_info *rdbi =
+		const struct gprs_rlc_ul_data_block_info *rdbi =
 			&block->block_info;
 
 		LOGP(DRLCMACUL, LOGL_DEBUG, "- No gaps in received block, "
@@ -323,10 +394,11 @@ int gprs_rlcmac_ul_tbf::rcv_data_block_acknowledged(
 	maybe_schedule_uplink_acknack(rlc);
 
 	return 0;
+
 }
 
 void gprs_rlcmac_ul_tbf::maybe_schedule_uplink_acknack(
-	const gprs_rlc_data_info *rlc)
+	const gprs_rlc_ul_header_generic *rlc)
 {
 	bool have_ti = rlc->block_info[0].ti ||
 		(rlc->num_data_blocks > 1 && rlc->block_info[1].ti);