summaryrefslogtreecommitdiff
path: root/cesar/ce/rx/bitloading/doc/bitloading.rst
blob: 53339453803b73e78dd0abd86f8da45f5feeb15d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
=================================
Channel Estimation Implementation
=================================

.. |title| replace:: Channel Estimation Implementation
.. |version| vcs-version::

.. include:: header.rst

Introduction
************

Forewords
=========

This document describes the implementation of the Channel Estimation (CE) done
by the software team in Cesar.

Its purpose is twofold:

- to give an overview of the current CE implementation
- to allow the understanding of the differences between this implementation
  and the implementation done by the TNS team in its Matlab simulation chain


The CE is divided into two parts:

- the CE TX, which sends and receives Management Message Entries (MME)
- the CE RX, which estimates the channel, generates an adequate tone map and
  tracks its changes

Acronyms
========

+------+---------------------------------------------------------------------+
| Term | Definition                                                          |
+======+=====================================================================+
| BER  | Bit Error Rate, considered before turbo-decoding                    |
+------+---------------------------------------------------------------------+
| BL   | Bit-Loading                                                         |
+------+---------------------------------------------------------------------+
| CE   | Channel Estimation                                                  |
+------+---------------------------------------------------------------------+
| CP   | Control Plane                                                       |
+------+---------------------------------------------------------------------+
| FEC  | Forward Error Correction                                            |
+------+---------------------------------------------------------------------+
| FSM  | Finite-State Machine                                                |
+------+---------------------------------------------------------------------+
| MME  | Management Message Entry                                            |
+------+---------------------------------------------------------------------+
| NSR  | Noise to Signal Ratio                                               |
+------+---------------------------------------------------------------------+
| PB   | PHY Block                                                           |
+------+---------------------------------------------------------------------+
| PBER | PB Error Rate                                                       |
+------+---------------------------------------------------------------------+
| SAR  | Segmentation And Reassembly                                         |
+------+---------------------------------------------------------------------+
| TM   | Tone Map, i.e. a list giving the modulation for each carrier of the |
|      | tone mask                                                           |
+------+---------------------------------------------------------------------+
| TMI  | TM Index (not TM Intervals)                                         |
+------+---------------------------------------------------------------------+

Notation
========

For performance reasons, floating point numbers must be converted to fixed
point numbers.

To do so, 3 information are required for each number:

- the number of fractional bits used: it can be seen as the number of decimals
  for a number expressed in a base 2
- the sign of the number: it can be signed or unsigned
- the number of bits required to store this fixed point number, including the
  sign bit

For example, Q7S13 represents a number which:

- is multiplied by :math:`2^7`, in order to keep only the 7 fractional bits
- is signed
- requires at least 13 bits: the number can grow at most to :math:`2^{12}` but
  requires one more bit for the sign

Channel Estimation in RX
************************

General principles
==================

The CE RX runs in its own thread with the lowest priority, i.e. all the other
threads take precedence over it. This is required because the CE does a lot of
calculations.

The Segmentation And Reassembly (SAR) gives to the CE RX some measurements for
each frame it receives. There are two kinds of measurements:

- channel data: they are collected on the sound frames only, and consist in
  the Noise to Signal Ratio (NSR)
- RX parameters: they are collected on the data frames only, and consist in:

  - the Tone Map Index (TMI) used to decode the frame
  - the number of PHY Blocks (PB)
  - the number of PBs with a false CRC
  - the Bit Error Rate (BER) of the PBs with a good CRC

When it receives these measurements, the CE stores them in a queue, but does
not process them yet, since this is done on the critical path. The CE will
wake up later to process them. If the CE starts becoming late, i.e. if it has
too many measures piled up in the queue, it can decide to drop the oldest RX
parameters. But the channel data are kept, since they are necessary to make
the CE evolve.

The CE is implemented as a Finite-State Machine (FSM).

.. figure:: bitloading.png
   :width: 100%

   Bit-loading FSM

NSR mean computation
====================

General principles
------------------

In order to estimate the noise on the channel, the RX uses the NSR based on
sound frames, which is more accurate than the NSR computed on data, simply
because the RX knows exactly the content of the sound frames.

For each sound frame received, the RX adds it to a table of NSR sum, each entry
in the table representing a carrier.

When the RX has received enough sound frames, it computes the NSR mean as
following::

  nsr_count // Number of NSR accumulated (number of sound frames received).
               It is usally set to 21
  nsr_rescale = 2

  for each unmasked carrier
        nsr_mean[carrier] = (nsr_sum[carrier] / nsr_count) * nsr_rescale

Note that the division is done using a `multiplication and a shifting
<http://pessac/cesar/trac/wiki/HintMulForDiv>`_ with the following
configuration::

  nsr_count < 40
  k = 2^m / nsr_count
  m = 29

Quantification
--------------

The NSR is a Q0U18.

Bit-loading initial
===================

General principles
------------------

The Bit-Loading (BL) algorithm is the main part of the CE.
Its purpose is to generate a tone map adapted to the actual channel
characteristics.

It can be divided as following:

1. compute a Bit Error Rate (BER) target
2. build a non-optimized tone map with each carrier respecting the BER target
3. sort the optimization table by impact on the BER target: the first entry of
   the table must have the lowest impact on the overall BER if its modulation
   was increased of one bit
4. increase each carrier of the tone map using the optimization table until
   the overall BER takes over the BER target
5. repeat steps 1 to 4 for each Forward Correction Error (FEC) rate
6. select the best tone map depending on the FEC rate

Compute the BER target
----------------------

General principles
^^^^^^^^^^^^^^^^^^

TNS provides a set of polynomials giving the BER target depending on the
average number of bits per tone.
This BER target normally guarantees an average PB Error Rate (PBER) lower than
1%. The polynomials are different for the 2 FEC rates, and are different in AV
and in EoC.
These polynomials are detailed in § 3.2 of the TNS specification.

To determine the BER target, the CE RX applies the adequate polynomial to an
average number of 10 bits per tone.

Quantification
^^^^^^^^^^^^^^

The number of bits per tone is expressed by a Q8U12.

The BER is expressed by a Q53U53.

Build a non optimized tone map
------------------------------

General principle
^^^^^^^^^^^^^^^^^

TNS provides a set of polynomials, one for each modulation, giving the BER
depending on the NSR::

  // The BER weighted sum corresponds to the sum of the BER of each carrier
  // pondered by the number of bits of the modulation used by this carrier.
  tm.ber_weighted_sum_q49 = 0
  tm.bits_per_symbol = 0

  for each unmasked carrier
    // Get the modulation which will be under the BER target for the current
    // NSR.
    modulation = modulation_which_respect (ber_target_q53, nsr_mean[carrier],
                        ber_reached_q53, ber_reached_upper_q53)

    // Store it into the tone map.
    tm.modulation[carrier] = modulation

    // Store additional information for the optimization process.
    // Actual BER respected by this carrier (converted to Q49U49).
    opti[carrier].ber_reached_q49 = ber_reached_q53 >> 4
    // Impact on BER if we increase the modulation by one.
    // If we are already at maximum, ignore it.
    if (modulation == QAM1024)
      opti[carrier].impact_q21 = 2^21
    else
      opti[carrier].impact_q21 = (ber_reached_upper_q53 – ber_reached_q53) >> 32
    // Store the carrier index (it will be used after sorting the table).
    opti[carrier].carrier = carrier

    // Store BER respected by the tone map (we weight it with the number of
    // bits of the modulation).
    tm.ber_weighted_sum_q49 += (ber_reached_q53 >> 4) * BIT_PER_MOD[modulation]
    tm.bits_per_symbol += BIT_PER_MOD[modulation]

::

  // Function to get the modulation which respect a given target of BER
  // - [in]ber_target_q53: BER target to respect.
  // - [in]nsr: NSR of the carrier.
  // - [out]ber_reached_q53: BER respected by this carrier.
  // - [out]ber_reached_upper_q53: BER respected by the next higher
  //                               modulation.
  // - return: the modulation to use if you want to respect the BER target.

  function modulation_which_respect (ber_target, nsr, ber_reached, ber_reached_upper)

It uses a dichotomy search to find the best modulation.
It relies on the fact that, for a given NSR, the higher the modulation is, the
higher the BER is.
The purpose of this dichotomy search is to prevent from evaluating the
polynomials for each modulation, which is time consuming.
The modulation is found in maximum 5 evaluations, which is better than
evaluating the 8 polynomials.

At the end of this part, the tone map guarantees an overall BER below the BER
target, since the BER of each carrier is below the BER target.

The next step of the BL algorithm is to improve the tone map in order to get
an overall BER as close as possible to the BER target.

Quantification
^^^^^^^^^^^^^^

The impact_q21 of the optimization table is a Q21U21. It represents the impact
on the BER if this carrier is increased to the upper modulation.
For memory size reason, the BER is stored on 21 bits.

The ber_weighted_sum_q49 is a Q49U49. It corresponds to the sum of BER
weighted by the number of bits of a tone:

- BER is a Q53U53
- bits of a tone is a Q0U4
- tone by symbol is a Q0U11.

To prevent overflow when computing ber_weighted_sum_q49, we need to reduce the
BER to a Q49U49 by removing 4 bits.

Sort the optimization table
---------------------------

The BER impact on the overall BER is not the same for all carriers.

This step simply sorts the optimization table by BER impact: the first entry
of the table must have the lowest impact on the overall BER if its modulation
was increased of one bit.

At the end of this table, there are the entries with the biggest impact on the
overall BER, including the ones where the modulation is already at the
maximum.

Optimize the tone map
---------------------
This step consists in increasing the modulation of each carrier using the
order defined by the sorted optimization table until we reach the BER target::

  // pos represent the position in the optimization table.
  pos = 0

  // Convert to prevent overflow.
  ber_target_q49 = ber_target_q53 >> 4

  // While we are not out of the optimization table and we are not over the
  // BER target.
  while ((pos < carrier_enabled)
          && (tm.bits_per_symbol * ber_target_q49 >= tm.ber_weighted_sum_q49))

    // Get the index of the carrier to increase.
    carrier = opti[pos].carrier
    // Get actual modulation.
    mod = tm.modulation[carrier]

    // If modulation is the maximum one, all other remaining entries in the table
    // are going to be the same. We can stop this step.
    if (mod == QAM1024)
      return

    // Decrease BER weighted sum & bits per symbol.
    tm.ber_weighted_sum_q49 -= opti[pos].ber_reached_q49 * BIT_PER_MOD[mod]
    tm.bits_per_symbol -= BIT_PER_MOD[mod]

    // Increase tone of the desired carrier.
    mod += 1
    tm.modulation[carrier] = mod

    // Increase back BER weighted sum & bits per symbol with new values.
    tm.ber_weighted_sum_q49 += BIT_PER_MOD[mod]
                    * (opti[pos].ber_reached_q49 + (opti[pos].impact << 32))
    tm.bits_per_symbol += BIT_PER_MOD[mod]

    // Go to the next position in the optimization table.
    pos += 1

  // Decrease last carrier if we are over target.
  if (tm.bits_per_symbol * ber_target_q49 < tm.ber_weighted_sum_q49)

    pos -= 1
    tm.ber_weighted_sum_q49 -= BIT_PER_MOD[mod]
                    * (opti[pos].ber_reached_q49 + (opti[pos].impact << 32))
    tm.bits_per_symbol -= BIT_PER_MOD[mod]
    mod -= 1
    tm.modulation[carrier] = mod
    tm.ber_weighted_sum_q49 += opti[pos].ber_reached_q49 * BIT_PER_MOD[mod]
    tm.bits_per_symbol += BIT_PER_MOD[mod]

At the end of this part, the tone map still guarantees an overall BER below
the BER target.
And the next carrier cannot be improved, otherwise the BER would take over the
BER target.

Repeat previous steps for each FEC rate
---------------------------------------

In fact, the only thing that changes between those steps is the BER target:
the polynomials are different for each FEC rate.

Select the best tone map depending on the FEC rate
--------------------------------------------------
To compare the 2 tone maps obtained with the 2 different FEC rate values, the
CE RX uses the following algorithm::

  // This table corresponds to the tone maps generated for each FEC rate.
  tm[fec_rate]

  // We can not directly compare the bits per symbol of those two tone maps
  // because they do not use the same FEC rate. We need to rescale each FEC
  // rate to make them comparable.
  // We need to multiply:
  //   - 1/2 by 21 (1/2 * 42 = 21),
  //   - 16/21 by 32 (16/21 * 42 = 32).

  if (tm[1/2].bits_per_symbol[1/2] * 21 > tm[16/21].bits_per_symbol * 32)
    best = 1/2
    worst = 16/21
  else
    best = 16/21
    worst = 1/2

  // Make the default tone map for the best one.
  default_tm = tm[best]
  // Remove the worst one.
  tonemap_free (tm[worst])

Initialize the channel information
----------------------------------

In order to prepare the 'tracking' state, the RX initializes some of the
parameters:

- the frame counters are reset to 0
- the deadlines after which the RX is allowed to restart the CE are computed
- the PBER sliding mean is set to a predefined value
- the BER sliding means are initialized to invalid values, in order to
  initialize them to the BER of the first frame received

Tracking
========

General principles
------------------
In the 'tracking' state, for compliance with the HomePlugAV standard, the CE
RX restarts when it receives a frame sound without the flag 'completed'.
It is used when a new channel estimation has been initiated by the TX
peer.

The CE RX can receive several sound frames with the flag 'completed', since
some 'sound ACK' may have been lost, and therefore ignore them.

In the 'tracking' state, the RX tracks information about the characteristics
of the channel in order to be able to make the decision to restart the CE.

First of all, the RX ignores all data received but not based on its default
TMI.
This can typically happen in the following situation:

- the TX has decided to communicate using the ROBO tone map and this is not
  the default TMI
- the RX has not sent the default TMI yet or the TX has not received it yet

For each data received and based on the default TMI, the RX updates:

- the BER sliding means (slow & fast)
- the PBER sliding mean
- the statistics on the CE, i.e. the results sent by the CE when it receives
  MMEs of statistics requests


Information maintained about actual channel characteristics
-----------------------------------------------------------


BER sliding means
^^^^^^^^^^^^^^^^^

The hardware returns the number of bits which have been corrected on PBs with a
good CRC.
This is what is called the BER sum.

To quantify the BER, the following formula is used::

  // pb_size can be 136 or 520
  div = good_crc_pb_count * pb_size

  ber_q53 = ber_sum * ((2^53 + div / 2) / div)

The BER sliding means are computed using the following algorithm (see §
2.2.1.2.1 of TNS specification)::

  // BER fast is 0, BER slow is 1.
  // BER division factor.
  ber_factor_div = 256
  // Table of factors for previous BER sliding mean, different for slow & fast.
  ber_factor_prev[2] = {122 * 2, 253}

  if (ber_sliding_mean_q53[slow] == -1 && ber_sliding_mean_q53[fast] == -1)
    // Initialize BER sliding means to first BER received.
    ber_sliding_mean_q53[slow] = ber_sliding_mean_q53[fast] = ber_q53
  else
    // Update each sliding means.
    for each slow & fast
      ber_sliding_mean_q53[i]
              = (ber_factor_prev[i] * ber_sliding_mean_q53[i]
              + (ber_factor_div – ber_factor_prev[i]) * ber_q53)
                / ber_factor_div

PB error rate sliding means
^^^^^^^^^^^^^^^^^^^^^^^^^^^

The PB Error Rate (PBER) sliding mean is used for the BER margin update.
It is not used to decide to restart the CE when the PBER is too high (`PBER
too high`_).

The hardware returns the number of PBs with a CRC false in the frame and the
number of PBs in the frame.

To quantify the PBER (Q16U32), the following formula is used::

  pber_q16 = pb_with_crc_false * 2^16 / pb_count

The PBER sliding mean is now computed by PB and not by frame anymore.
To avoid wasting time, the computation will be done as if all PB's with false
CRC are received first. So, instead of computing PBER sliding mean at each new
PB by using a for loop, an approximation is done to compute it at each new
frame.

The following is defined: :math:`M_{t}` is the PBER sliding mean,
:math:`M_{t-1}` is the previous PBER sliding mean, :math:`m` is the PBER mean
of the frame, :math:`n` is the number of PB in the frame and :math:`k` is the
number of PBs with CRC false.

For a frame of one PB, we have:

.. math::

  M_{t} = M_{t-1} (1 - \alpha) + \alpha m \textit{ (with m = 0 or 1)}

For a frame with more than one PB, we can generalize to:

.. math::

   M_{t} = M_{t-1} (1 - \alpha)^n + \alpha \sum_{p=0}^{n-1} (1 - \alpha)^p m_{p}
   \textit{ (with } m_{p} \textit{ the } p^{th}  \textit{ PB CRC value)}

We know that:

.. math::

   \sum_{p=0}^{n-1} (1 - \alpha)^p = \frac{1-(1-\alpha)^n}{1-(1-\alpha)}

Then:

.. math::

   \sum_{p=0}^{n-1} (1 - \alpha)^p m_{p} = \frac{1-(1-\alpha)^k}{1-(1-\alpha)}

If we replace it, we can obtain:

.. math::

   M_{t} = M_{t-1} (1 - \alpha)^n + \alpha (\frac{1-(1-\alpha)^k}{1-(1-\alpha)})

It can be simplified to obtain:

.. math::

   M_{t} = M_{t-1} (1 - \alpha)^n + (1-(1-\alpha)^k)

If :math:`\alpha` is near 0, we can assume that:

.. math::

   (1-\alpha)^n = 1 - n \alpha

We obtain:

.. math::

   M_{t} = (1 - n \alpha) M_{t-1} + k \alpha

Let's assume:

.. math::

   \alpha = \frac{1}{D}

We can now write:

.. math::

   M_{t} = (1 - \frac{n}{D}) M_{t-1} + \frac{k}{D}

.. math::

   M_{t} = \frac{(D - n) M_{t-1} + k}{D}

:math:`D` need to fit on a 16 bits value in order to prevent overflow. TNS has
selected 6912 as good value (see `PBER evaluation for BMU algorithm
<http://stestephe/svn/spidcom_digital_svn/projects/DSP_GESSICA/DSP_chain/SW/Bit_Loading/Documentation/Study/PBER%20evaluation%20for%20BMU%20Algoriothm.pdf>`_).

Statistics
^^^^^^^^^^

Each time the RX receives a frame, it updates the statistics of the CE.
These statistics are detailed in the specification of the corresponding MMEs
(cleopatre_mme_specs.odt).

Conditions required to restart the CE
-------------------------------------

There are 2 conditions which lead to a CE restart:

- PBER too high
- BER too low

PBER too high
^^^^^^^^^^^^^

First of all, the RX does not use the PBER sliding mean to evaluate this
criteria.
Also, the RX does not evaluate this criteria on ROBO tone maps::

  // A measure based on a received data frame. It contains:
  //   - tmi: the TMI used to decoded the frame,
  //   - pb_count: total number of PB in the frame (all CRC flags included),
  //   - crc_false_pb_count: total number of PB in the frame with the CRC false.
  measure

  // Configuration of the PBER criteria:
  // Frame with not many PB are ignored.
  min_pb_per_frame = 2
  // Ratio to consider the frame with a high PBER
  pber_false_factor = 1
  pber_total_factor = 4
  pber_min_consecutive_frame = 4
  pber_restart_ms = 3000

  // Only examine PBER on tone map we have generated (not on ROBO).
  // PBER too high.
  if ((measure.tmi >= 4) && (measure.pb_count >= min_pb_per_frame)
     && (pber_total_factor * measure.crc_false_pb_count
         > pber_false_factor * measure.pb_count))

    // We consider the frame with a high PBER.
    // Increase high PBER frame counter.
    pber_high_frame_counter += 1

    // If we have reached the threshold of consecutive high PBER frame
    // and we have not restarted a few moments ago.
    if ((pber_high_frame_counter >= pber_min_consecutive_frame)
            && (next_pber_high_restart < current_time ()))

      // Reset CE in RX & CE TX.

    else
      // The PBER was not high (or ROBO tone map).
      // Reset PBER high consecutive frame counter.
      pber_high_frame_counter = 0

  // Examine BER criteria, see next section.

BER sliding means too low
^^^^^^^^^^^^^^^^^^^^^^^^^

BER sliding means are only evaluated when PBER is not considered as high::

  // The previous if assumes PBER is not too high or frame's TMI is ROBO.
  // Configuration of BER too low criteria.
  // BER lower bound, under which we restart (expressed in 128th of BER).
  ber_lower_bound = 70

  // Evaluate BER only if:
  //   - TMI is ROBO or tone map is not at maximum,
  //   - it is not too soon.
  if (((measure.tmi >= 4)
       || (tm->bits_per_symbol < tone_mask->carrier_enabled * 10))
     && (next_ber_low_restart < current_time ()))

    // Get BER target.
    if (measure.tmi >= 4)
      // On non ROBO tone map, BER target is BER target reached by BL initial.
      ber_target_q53 = tm.ber_target_reached_q53
    else
      // ROBO tone map. It corresponds to the BER target for 1/2 and aims for
      // 2 bits per tone. See section `Compute the BER target`_ for more
      // information on this computation).
      ber_target_q53 = ber_target (1/2, carrier_enabled, 2 * 28)

    // Compute BER lower bound.
    lower_bound = ber_target_q53 - (ber_target_q53 * ber_lower / 128)

    // Restart if both sliding means are under BER lower bound.
    if ((ber_sliding_mean_q53[slow] < lower_bound)
       && (ber_sliding_mean_q53[fast] < lower_bound))
       // Reset CE RX & CE TX.

Channel Estimation in TX
************************

The CE TX runs in the context of the Control Plane (CP).
Its purpose is to:

- encode and decode CE MME (CM_CHAN_EST.IND and CM_TM_UPDATE.IND)
- manage expiration of tone maps in TX

It also provides a mailbox system to the CE RX to enable request for sending
CE MME.