src/host/layer23/src/gsm48_rr.c

   1 #warning rr on MDL error handling (as specified in 04.08 / 04.06)
   2 /*
   3  * (C) 2010 by Andreas Eversberg <jolly@eversberg.eu>
   4  *
   5  * All Rights Reserved
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  */
  22
  23 /* Very short description of some of the procedures:
  24  *
  25  * A radio ressource request causes sendig a channel request on RACH.
  26  * After receiving of an immediate assignment the link will be establised.
  27  * After the link is established, the dedicated mode is entered and confirmed.
  28  *
  29  * A Paging request also triggers the channel request as above...
  30  * After the link is established, the dedicated mode is entered and indicated.
  31  *
  32  * During dedicated mode, messages are transferred.
  33  *
  34  * When an assignment command or a handover command is received, the current
  35  * link is released. After release, the new channel is activated and the
  36  * link is established again. After link is establised, pending messages from
  37  * radio ressource are sent.
  38  *
  39  * When the assignment or handover fails, the old channel is activate and the
  40  * link is established again. Also pending messages are sent.
  41  *
  42  */
  43
  44 #include <stdint.h>
  45 #include <errno.h>
  46 #include <stdio.h>
  47 #include <string.h>
  48 #include <stdlib.h>
  49 #include <arpa/inet.h>
  50
  51 #include <osmocore/msgb.h>
  52 #include <osmocore/utils.h>
  53 #include <osmocore/rsl.h>
  54 #include <osmocore/gsm48.h>
  55 #include <osmocore/bitvec.h>
  56
  57 #include <osmocom/osmocom_data.h>
  58 #include <osmocom/l1l2_interface.h>
  59 #include <osmocom/logging.h>
  60 #include <osmocom/networks.h>
  61 #include <osmocom/l1ctl.h>
  62
  63 static int gsm48_rcv_rsl(struct osmocom_ms *ms, struct msgb *msg);
  64 static int gsm48_rr_dl_est(struct osmocom_ms *ms);
  65
  66 /*
  67  * support
  68  */
  69
  70 #define MIN(a, b) ((a < b) ? a : b)
  71
  72 int gsm48_decode_lai(struct gsm48_loc_area_id *lai, uint16_t *mcc,
  73         uint16_t *mnc, uint16_t *lac)
  74 {
  75         *mcc = ((lai->digits[0] & 0x0f) << 8)
  76              | (lai->digits[0] & 0xf0)
  77              | (lai->digits[1] & 0x0f);
  78         *mnc = ((lai->digits[2] & 0x0f) << 8)
  79              | (lai->digits[2] & 0xf0)
  80              | ((lai->digits[1] & 0xf0) >> 4);
  81         *lac = ntohs(lai->lac);
  82
  83         return 0;
  84 }
  85
  86 static int gsm48_encode_chan_h0(struct gsm48_chan_desc *cd, uint8_t tsc,
  87         uint16_t arfcn)
  88 {
  89         cd->h0.tsc = tsc;
  90         cd->h0.h = 0;
  91         cd->h0.arfcn_low = arfcn & 0xff;
  92         cd->h0.arfcn_high = arfcn >> 8;
  93
  94         return 0;
  95 }
  96
  97 static int gsm48_encode_chan_h1(struct gsm48_chan_desc *cd, uint8_t tsc,
  98         uint8_t maio, uint8_t hsn)
  99 {
 100         cd->h1.tsc = tsc;
 101         cd->h1.h = 1;
 102         cd->h1.maio_low = maio & 0x03;
 103         cd->h1.maio_high = maio >> 2;
 104         cd->h1.hsn = hsn;
 105
 106         return 0;
 107 }
 108
 109
 110 static int gsm48_decode_chan_h0(struct gsm48_chan_desc *cd, uint8_t *tsc,
 111         uint16_t *arfcn)
 112 {
 113         *tsc = cd->h0.tsc;
 114         *arfcn = cd->h0.arfcn_low | (cd->h0.arfcn_high << 8);
 115
 116         return 0;
 117 }
 118
 119 static int gsm48_decode_chan_h1(struct gsm48_chan_desc *cd, uint8_t *tsc,
 120         uint8_t *maio, uint8_t *hsn)
 121 {
 122         *tsc = cd->h1.tsc;
 123         *maio = cd->h1.maio_low | (cd->h1.maio_high << 2);
 124         *hsn = cd->h1.hsn;
 125
 126         return 0;
 127 }
 128
 129 /* 10.5.2.38 decode Starting time IE */
 130 static int gsm48_decode_start_time(struct gsm48_rr_cd *cd,
 131         struct gsm48_start_time *st)
 132 {
 133         cd->start_t1 = st->t1;
 134         cd->start_t2 = st->t2;
 135         cd->start_t3 = (st->t3_high << 3) | st->t3_low;
 136
 137         return 0;
 138 }
 139
 140 /* decode "BA Range" (10.5.2.1a) */
 141 static int gsm48_decode_ba_range(const uint8_t *ba, uint8_t ba_len,
 142         uint32_t *range, uint8_t *ranges, int max_ranges)
 143 {
 144         /* ba = pointer to IE without IE type and length octets
 145          * ba_len = number of octets
 146          * range = pointer to store decoded range
 147          * ranges = number of ranges decoded
 148          * max_ranges = maximum number of decoded ranges that can be stored
 149          */
 150         uint16_t lower, higher;
 151         int i, n, required_octets;
 152
 153         /* find out how much ba ranges will be decoded */
 154         n = *ba++;
 155         ba_len --;
 156         required_octets = 5 * (n >> 1) + 3 * (n & 1);
 157         if (required_octets > ba_len) {
 158                 LOGP(DRR, LOGL_NOTICE, "BA range IE too short: %d ranges "
 159                         "require %d octets, but only %d octets remain.\n",
 160                         n, required_octets, ba_len);
 161                 *ranges = 0;
 162                 return -EINVAL;
 163         }
 164         if (max_ranges > n)
 165                 LOGP(DRR, LOGL_NOTICE, "BA range %d exceed the maximum number "
 166                         "of ranges supported by this mobile (%d).\n",
 167                         n, max_ranges);
 168                 n = max_ranges;
 169
 170         /* decode ranges */
 171         for (i = 0; i < n; i++) {
 172                 if (!(i & 1)) {
 173                         /* decode even range number */
 174                         lower = *ba++ << 2;
 175                         lower |= (*ba >> 6);
 176                         higher = (*ba++ & 0x3f) << 4;
 177                         higher |= *ba >> 4;
 178                 } else {
 179                         lower = (*ba++ & 0x0f) << 6;
 180                         lower |= *ba >> 2;
 181                         higher = (*ba++ & 0x03) << 8;
 182                         higher |= *ba++;
 183                         /* decode odd range number */
 184                 }
 185                 *range++ = (higher << 16) | lower;
 186         }
 187         *ranges = n;
 188
 189         return 0;
 190 }
 191
 192 /*
 193  * state transition
 194  */
 195
 196 const char *gsm48_rr_state_names[] = {
 197         "idle",
 198         "connection pending",
 199         "dedicated",
 200         "release pending",
 201 };
 202
 203 static void new_rr_state(struct gsm48_rrlayer *rr, int state)
 204 {
 205         if (state < 0 || state >=
 206                 (sizeof(gsm48_rr_state_names) / sizeof(char *)))
 207                 return;
 208
 209         LOGP(DRR, LOGL_INFO, "new state %s -> %s\n",
 210                 gsm48_rr_state_names[rr->state], gsm48_rr_state_names[state]);
 211
 212         rr->state = state;
 213
 214         if (state == GSM48_RR_ST_IDLE) {
 215                 struct msgb *msg, *nmsg;
 216
 217                 /* release dedicated mode, if any */
 218 //              tx_ph_dm_rel_req(rr->ms);
 219                 l1ctl_tx_reset_req(rr->ms, L1CTL_RES_T_FULL);
 220                 /* free establish message, if any */
 221                 rr->rr_est_req = 0;
 222                 if (rr->rr_est_msg) {
 223                         msgb_free(rr->rr_est_msg);
 224                         rr->rr_est_msg = NULL;
 225                 }
 226                 /* free all pending messages */
 227                 while((msg = msgb_dequeue(&rr->downqueue)))
 228                         msgb_free(msg);
 229                 /* clear all descriptions of last channel */
 230                 memset(&rr->cd_now, 0, sizeof(rr->cd_now));
 231                 /* reset cipering */
 232                 rr->cipher_on = 0;
 233                 /* tell cell selection process to return to idle mode
 234                  * NOTE: this must be sent unbuffered, because it will
 235                  * leave camping state, so it locks against subsequent
 236                  * establishment of dedicated channel, before the
 237                  * cell selection process returned to camping state
 238                  * again. (after cell reselection)
 239                  */
 240                 nmsg = gsm322_msgb_alloc(GSM322_EVENT_RET_IDLE);
 241                 if (!nmsg)
 242                         return;
 243                 gsm322_c_event(rr->ms, nmsg);
 244                 msgb_free(nmsg);
 245                 /* reset any BA range */
 246                 rr->ba_ranges = 0;
 247         }
 248 }
 249
 250 /*
 251  * messages
 252  */
 253
 254 /* names of RR-SAP */
 255 static const struct value_string gsm48_rr_msg_names[] = {
 256         { GSM48_RR_EST_REQ,             "RR_EST_REQ" },
 257         { GSM48_RR_EST_IND,             "RR_EST_IND" },
 258         { GSM48_RR_EST_CNF,             "RR_EST_CNF" },
 259         { GSM48_RR_REL_IND,             "RR_REL_IND" },
 260         { GSM48_RR_SYNC_IND,            "RR_SYNC_IND" },
 261         { GSM48_RR_DATA_REQ,            "RR_DATA_REQ" },
 262         { GSM48_RR_DATA_IND,            "RR_DATA_IND" },
 263         { GSM48_RR_UNIT_DATA_IND,       "RR_UNIT_DATA_IND" },
 264         { GSM48_RR_ABORT_REQ,           "RR_ABORT_REQ" },
 265         { GSM48_RR_ABORT_IND,           "RR_ABORT_IND" },
 266         { GSM48_RR_ACT_REQ,             "RR_ACT_REQ" },
 267         { 0,                            NULL }
 268 };
 269
 270 const char *get_rr_name(int value)
 271 {
 272         return get_value_string(gsm48_rr_msg_names, value);
 273 }
 274
 275 /* allocate GSM 04.08 layer 3 message */
 276 struct msgb *gsm48_l3_msgb_alloc(void)
 277 {
 278         struct msgb *msg;
 279
 280         msg = msgb_alloc_headroom(L3_ALLOC_SIZE+L3_ALLOC_HEADROOM,
 281                 L3_ALLOC_HEADROOM, "GSM 04.08 L3");
 282         if (!msg)
 283                 return NULL;
 284         msg->l3h = msg->data;
 285
 286         return msg;
 287 }
 288
 289 /* allocate GSM 04.08 message (RR-SAP) */
 290 struct msgb *gsm48_rr_msgb_alloc(int msg_type)
 291 {
 292         struct msgb *msg;
 293         struct gsm48_rr_hdr *rrh;
 294
 295         msg = msgb_alloc_headroom(RR_ALLOC_SIZE+RR_ALLOC_HEADROOM,
 296                 RR_ALLOC_HEADROOM, "GSM 04.08 RR");
 297         if (!msg)
 298                 return NULL;
 299
 300         rrh = (struct gsm48_rr_hdr *) msgb_put(msg, sizeof(*rrh));
 301         rrh->msg_type = msg_type;
 302
 303         return msg;
 304 }
 305
 306 /* queue message (RR-SAP) */
 307 int gsm48_rr_upmsg(struct osmocom_ms *ms, struct msgb *msg)
 308 {
 309         struct gsm48_mmlayer *mm = &ms->mmlayer;
 310
 311         msgb_enqueue(&mm->rr_upqueue, msg);
 312
 313         return 0;
 314 }
 315
 316 /* push rsl header and send (RSL-SAP) */
 317 static int gsm48_send_rsl(struct osmocom_ms *ms, uint8_t msg_type,
 318                                 struct msgb *msg)
 319 {
 320         struct gsm48_rrlayer *rr = &ms->rrlayer;
 321
 322         if (!msg->l3h) {
 323                 printf("FIX l3h\n");
 324                 exit (0);
 325         }
 326         rsl_rll_push_l3(msg, msg_type, rr->cd_now.chan_nr,
 327                 rr->cd_now.link_id, 1);
 328
 329         return rslms_recvmsg(msg, ms);
 330 }
 331
 332 /* enqueue messages (RSL-SAP) */
 333 static int gsm48_rx_rll(struct msgb *msg, struct osmocom_ms *ms)
 334 {
 335         struct gsm48_rrlayer *rr = &ms->rrlayer;
 336
 337         msgb_enqueue(&rr->rsl_upqueue, msg);
 338
 339         return 0;
 340 }
 341
 342 /* input function that L2 calls when sending messages up to L3 */
 343 static int gsm48_rx_rsl(struct msgb *msg, struct osmocom_ms *ms)
 344 {
 345         struct abis_rsl_common_hdr *rslh = msgb_l2(msg);
 346         int rc = 0;
 347
 348         switch (rslh->msg_discr & 0xfe) {
 349         case ABIS_RSL_MDISC_RLL:
 350                 rc = gsm48_rx_rll(msg, ms);
 351                 break;
 352         default:
 353                 /* FIXME: implement this */
 354                 LOGP(DRSL, LOGL_NOTICE, "unknown RSLms msg_discr 0x%02x\n",
 355                         rslh->msg_discr);
 356                 msgb_free(msg);
 357                 rc = -EINVAL;
 358                 break;
 359         }
 360
 361         return rc;
 362 }
 363
 364 /* dequeue messages (RSL-SAP) */
 365 int gsm48_rsl_dequeue(struct osmocom_ms *ms)
 366 {
 367         struct gsm48_rrlayer *rr = &ms->rrlayer;
 368         struct msgb *msg;
 369         int work = 0;
 370
 371         while ((msg = msgb_dequeue(&rr->rsl_upqueue))) {
 372                 /* msg is freed there */
 373                 gsm48_rcv_rsl(ms, msg);
 374                 work = 1; /* work done */
 375         }
 376
 377         return work;
 378 }
 379
 380 /*
 381  * timers handling
 382  */
 383
 384 /* special timer to ensure that UA is sent before disconnecting channel */
 385 static void timeout_rr_t_rel_wait(void *arg)
 386 {
 387         struct gsm48_rrlayer *rr = arg;
 388
 389         LOGP(DRR, LOGL_INFO, "L2 release timer has fired, done waiting\n");
 390
 391         /* return to idle now */
 392         new_rr_state(rr, GSM48_RR_ST_IDLE);
 393 }
 394
 395 /* 3.4.13.1.1: Timeout of T3110 */
 396 static void timeout_rr_t3110(void *arg)
 397 {
 398         struct gsm48_rrlayer *rr = arg;
 399         struct osmocom_ms *ms = rr->ms;
 400         struct msgb *nmsg;
 401         uint8_t *mode;
 402
 403         LOGP(DRR, LOGL_INFO, "timer T3110 has fired, release locally\n");
 404
 405         new_rr_state(rr, GSM48_RR_ST_REL_PEND);
 406
 407         /* disconnect the main signalling link */
 408         nmsg = gsm48_l3_msgb_alloc();
 409         if (!nmsg)
 410                 return;
 411         mode = msgb_put(nmsg, 2);
 412         mode[0] = RSL_IE_RELEASE_MODE;
 413         mode[1] = 1; /* local release */
 414         gsm48_send_rsl(ms, RSL_MT_REL_REQ, nmsg);
 415
 416         return;
 417 }
 418
 419 static void timeout_rr_t3122(void *arg)
 420 {
 421         LOGP(DRR, LOGL_INFO, "timer T3122 has fired\n");
 422 }
 423
 424 static void timeout_rr_t3126(void *arg)
 425 {
 426         struct gsm48_rrlayer *rr = arg;
 427         struct osmocom_ms *ms = rr->ms;
 428
 429         LOGP(DRR, LOGL_INFO, "timer T3126 has fired\n");
 430         if (rr->rr_est_req) {
 431                 struct msgb *msg = gsm48_rr_msgb_alloc(GSM48_RR_REL_IND);
 432                 struct gsm48_rr_hdr *rrh;
 433
 434                 LOGP(DSUM, LOGL_INFO, "Requesting channel failed\n");
 435                 if (!msg)
 436                         return;
 437                 rrh = (struct gsm48_rr_hdr *)msg->data;
 438                 rrh->cause = RR_REL_CAUSE_RA_FAILURE;
 439                 gsm48_rr_upmsg(ms, msg);
 440         }
 441
 442         new_rr_state(rr, GSM48_RR_ST_IDLE);
 443 }
 444
 445 static void start_rr_t_rel_wait(struct gsm48_rrlayer *rr, int sec, int micro)
 446 {
 447         LOGP(DRR, LOGL_INFO, "starting T_rel_wait with %d seconds\n", sec);
 448         rr->t_rel_wait.cb = timeout_rr_t_rel_wait;
 449         rr->t_rel_wait.data = rr;
 450         bsc_schedule_timer(&rr->t_rel_wait, sec, micro);
 451 }
 452
 453 static void start_rr_t3110(struct gsm48_rrlayer *rr, int sec, int micro)
 454 {
 455         LOGP(DRR, LOGL_INFO, "starting T3110 with %d seconds\n", sec);
 456         rr->t3110.cb = timeout_rr_t3110;
 457         rr->t3110.data = rr;
 458         bsc_schedule_timer(&rr->t3110, sec, micro);
 459 }
 460
 461 static void start_rr_t3122(struct gsm48_rrlayer *rr, int sec, int micro)
 462 {
 463         LOGP(DRR, LOGL_INFO, "starting T3122 with %d seconds\n", sec);
 464         rr->t3122.cb = timeout_rr_t3122;
 465         rr->t3122.data = rr;
 466         bsc_schedule_timer(&rr->t3122, sec, micro);
 467 }
 468
 469 static void start_rr_t3126(struct gsm48_rrlayer *rr, int sec, int micro)
 470 {
 471         LOGP(DRR, LOGL_INFO, "starting T3126 with %d seconds\n", sec);
 472         rr->t3126.cb = timeout_rr_t3126;
 473         rr->t3126.data = rr;
 474         bsc_schedule_timer(&rr->t3126, sec, micro);
 475 }
 476
 477 static void stop_rr_t_rel_wait(struct gsm48_rrlayer *rr)
 478 {
 479         if (bsc_timer_pending(&rr->t_rel_wait)) {
 480                 LOGP(DRR, LOGL_INFO, "stopping pending timer T_rel_wait\n");
 481                 bsc_del_timer(&rr->t_rel_wait);
 482         }
 483 }
 484
 485 static void stop_rr_t3110(struct gsm48_rrlayer *rr)
 486 {
 487         if (bsc_timer_pending(&rr->t3110)) {
 488                 LOGP(DRR, LOGL_INFO, "stopping pending timer T3110\n");
 489                 bsc_del_timer(&rr->t3110);
 490         }
 491 }
 492
 493 static void stop_rr_t3122(struct gsm48_rrlayer *rr)
 494 {
 495         if (bsc_timer_pending(&rr->t3122)) {
 496                 LOGP(DRR, LOGL_INFO, "stopping pending timer T3122\n");
 497                 bsc_del_timer(&rr->t3122);
 498         }
 499 }
 500
 501 static void stop_rr_t3126(struct gsm48_rrlayer *rr)
 502 {
 503         if (bsc_timer_pending(&rr->t3126)) {
 504                 LOGP(DRR, LOGL_INFO, "stopping pending timer T3126\n");
 505                 bsc_del_timer(&rr->t3126);
 506         }
 507 }
 508
 509 /*
 510  * status
 511  */
 512
 513 /* send rr status request */
 514 static int gsm48_rr_tx_rr_status(struct osmocom_ms *ms, uint8_t cause)
 515 {
 516         struct msgb *nmsg;
 517         struct gsm48_hdr *gh;
 518         struct gsm48_rr_status *st;
 519
 520         LOGP(DRR, LOGL_INFO, "RR STATUS (cause #%d)\n", cause);
 521
 522         nmsg = gsm48_l3_msgb_alloc();
 523         if (!nmsg)
 524                 return -ENOMEM;
 525         gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
 526         st = (struct gsm48_rr_status *) msgb_put(nmsg, sizeof(*st));
 527
 528         gh->proto_discr = GSM48_PDISC_RR;
 529         gh->msg_type = GSM48_MT_RR_CIPH_M_COMPL;
 530
 531         /* rr cause */
 532         st->rr_cause = cause;
 533
 534         return gsm48_send_rsl(ms, RSL_MT_DATA_REQ, nmsg);
 535 }
 536
 537 /*
 538  * ciphering
 539  */
 540
 541 /* send chiperhing mode complete */
 542 static int gsm48_rr_tx_cip_mode_cpl(struct osmocom_ms *ms, uint8_t cr)
 543 {
 544         struct gsm_settings *set = &ms->settings;
 545         struct msgb *nmsg;
 546         struct gsm48_hdr *gh;
 547         uint8_t buf[11], *tlv;
 548
 549         LOGP(DRR, LOGL_INFO, "CIPHERING MODE COMPLETE (cr %d)\n", cr);
 550
 551         nmsg = gsm48_l3_msgb_alloc();
 552         if (!nmsg)
 553                 return -ENOMEM;
 554         gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
 555
 556         gh->proto_discr = GSM48_PDISC_RR;
 557         gh->msg_type = GSM48_MT_RR_CIPH_M_COMPL;
 558
 559         /* MI */
 560         if (cr) {
 561                 gsm48_generate_mid_from_imsi(buf, set->imeisv);
 562                 tlv = msgb_put(nmsg, 2 + buf[1]);
 563                 memcpy(tlv, buf, 2 + buf[1]);
 564         }
 565
 566         return gsm48_send_rsl(ms, RSL_MT_DATA_REQ, nmsg);
 567 }
 568
 569 /* receive ciphering mode command */
 570 static int gsm48_rr_rx_cip_mode_cmd(struct osmocom_ms *ms, struct msgb *msg)
 571 {
 572         struct gsm48_rrlayer *rr = &ms->rrlayer;
 573         struct gsm_support *sup = &ms->support;
 574         struct gsm48_hdr *gh = msgb_l3(msg);
 575         struct gsm48_cip_mode_cmd *cm = (struct gsm48_cip_mode_cmd *)gh->data;
 576         int payload_len = msgb_l3len(msg) - sizeof(*gh) - sizeof(*cm);
 577         uint8_t sc, alg_id, cr;
 578
 579         if (payload_len < 0) {
 580                 LOGP(DRR, LOGL_NOTICE, "Short read of CIPHERING MODE COMMAND "
 581                         "message.\n");
 582                 return gsm48_rr_tx_rr_status(ms,
 583                         GSM48_RR_CAUSE_PROT_ERROR_UNSPC);
 584         }
 585
 586         /* cipher mode setting */
 587         sc = cm->sc;
 588         alg_id = cm->alg_id;
 589         /* cipher mode response */
 590         cr = cm->cr;
 591
 592         if (sc)
 593                 LOGP(DRR, LOGL_INFO, "CIPHERING MODE COMMAND (sc=%u, cr=%u)",
 594                         sc, cr);
 595         else
 596                 LOGP(DRR, LOGL_INFO, "CIPHERING MODE COMMAND (sc=%u, "
 597                         "algo=A5/%d cr=%u)", sc, alg_id + 1, cr);
 598
 599         /* 3.4.7.2 */
 600         if (rr->cipher_on && sc) {
 601                 LOGP(DRR, LOGL_INFO, "cipering already applied.\n");
 602                 return gsm48_rr_tx_rr_status(ms,
 603                         GSM48_RR_CAUSE_PROT_ERROR_UNSPC);
 604         }
 605
 606         /* check if we actually support this cipher */
 607         if ((alg_id == GSM_CIPHER_A5_1 && !sup->a5_1)
 608          || (alg_id == GSM_CIPHER_A5_2 && !sup->a5_2)
 609          || (alg_id == GSM_CIPHER_A5_3 && !sup->a5_3)
 610          || (alg_id == GSM_CIPHER_A5_4 && !sup->a5_4)
 611          || (alg_id == GSM_CIPHER_A5_5 && !sup->a5_5)
 612          || (alg_id == GSM_CIPHER_A5_6 && !sup->a5_6)
 613          || (alg_id == GSM_CIPHER_A5_7 && !sup->a5_7))
 614                 return gsm48_rr_tx_rr_status(ms,
 615                         GSM48_RR_CAUSE_CHAN_MODE_UNACCT);
 616
 617         /* change to ciphering */
 618 #ifdef TODO
 619         rsl command to activate ciperhing
 620 #endif
 621         rr->cipher_on = sc, rr->cipher_type = alg_id;
 622
 623         /* response */
 624         return gsm48_rr_tx_cip_mode_cpl(ms, cr);
 625 }
 626
 627 /*
 628  * classmark
 629  */
 630
 631 /* Encode  "Classmark 3" (10.5.1.7) */
 632 static int gsm48_rr_enc_cm3(struct osmocom_ms *ms, uint8_t *buf, uint8_t *len)
 633 {
 634         struct gsm_support *sup = &ms->support;
 635         struct bitvec bv;
 636
 637         memset(&bv, 0, sizeof(bv));
 638         bv.data = buf;
 639         bv.data_len = 12;
 640
 641         /* spare bit */
 642         bitvec_set_bit(&bv, 0);
 643         /* band 3 supported */
 644         if (sup->dcs_1800)
 645                 bitvec_set_bit(&bv, ONE);
 646         else
 647                 bitvec_set_bit(&bv, ZERO);
 648         /* band 2 supported */
 649         if (sup->e_gsm || sup->r_gsm)
 650                 bitvec_set_bit(&bv, ONE);
 651         else
 652                 bitvec_set_bit(&bv, ZERO);
 653         /* band 1 supported */
 654         if (sup->p_gsm && !(sup->e_gsm || sup->r_gsm))
 655                 bitvec_set_bit(&bv, ONE);
 656         else
 657                 bitvec_set_bit(&bv, ZERO);
 658         /* a5 bits */
 659         if (sup->a5_7)
 660                 bitvec_set_bit(&bv, ONE);
 661         else
 662                 bitvec_set_bit(&bv, ZERO);
 663         if (sup->a5_6)
 664                 bitvec_set_bit(&bv, ONE);
 665         else
 666                 bitvec_set_bit(&bv, ZERO);
 667         if (sup->a5_5)
 668                 bitvec_set_bit(&bv, ONE);
 669         else
 670                 bitvec_set_bit(&bv, ZERO);
 671         if (sup->a5_4)
 672                 bitvec_set_bit(&bv, ONE);
 673         else
 674                 bitvec_set_bit(&bv, ZERO);
 675         /* radio capability */
 676         if (sup->dcs_1800 && !sup->p_gsm && !(sup->e_gsm || sup->r_gsm)) {
 677                 /* dcs only */
 678                 bitvec_set_uint(&bv, 0, 4);
 679                 bitvec_set_uint(&bv, sup->dcs_capa, 4);
 680         } else
 681         if (sup->dcs_1800 && (sup->p_gsm || (sup->e_gsm || sup->r_gsm))) {
 682                 /* dcs */
 683                 bitvec_set_uint(&bv, sup->dcs_capa, 4);
 684                 /* low band */
 685                 bitvec_set_uint(&bv, sup->low_capa, 4);
 686         } else {
 687                 /* low band only */
 688                 bitvec_set_uint(&bv, 0, 4);
 689                 bitvec_set_uint(&bv, sup->low_capa, 4);
 690         }
 691         /* r support */
 692         if (sup->r_gsm) {
 693                 bitvec_set_bit(&bv, ONE);
 694                 bitvec_set_uint(&bv, sup->r_capa, 3);
 695         } else {
 696                 bitvec_set_bit(&bv, ZERO);
 697         }
 698         /* multi slot support */
 699         if (sup->ms_sup) {
 700                 bitvec_set_bit(&bv, ONE);
 701                 bitvec_set_uint(&bv, sup->ms_sup, 5);
 702         } else {
 703                 bitvec_set_bit(&bv, ZERO);
 704         }
 705         /* ucs2 treatment */
 706         if (sup->ucs2_treat) {
 707                 bitvec_set_bit(&bv, ONE);
 708         } else {
 709                 bitvec_set_bit(&bv, ZERO);
 710         }
 711         /* support extended measurements */
 712         if (sup->ext_meas) {
 713                 bitvec_set_bit(&bv, ONE);
 714         } else {
 715                 bitvec_set_bit(&bv, ZERO);
 716         }
 717         /* support measurement capability */
 718         if (sup->meas_cap) {
 719                 bitvec_set_bit(&bv, ONE);
 720                 bitvec_set_uint(&bv, sup->sms_val, 4);
 721                 bitvec_set_uint(&bv, sup->sm_val, 4);
 722         } else {
 723                 bitvec_set_bit(&bv, ZERO);
 724         }
 725         /* positioning method capability */
 726         if (sup->loc_serv) {
 727                 bitvec_set_bit(&bv, ONE);
 728                 bitvec_set_bit(&bv, sup->e_otd_ass == 1);
 729                 bitvec_set_bit(&bv, sup->e_otd_based == 1);
 730                 bitvec_set_bit(&bv, sup->gps_ass == 1);
 731                 bitvec_set_bit(&bv, sup->gps_based == 1);
 732                 bitvec_set_bit(&bv, sup->gps_conv == 1);
 733         } else {
 734                 bitvec_set_bit(&bv, ZERO);
 735         }
 736
 737         /* partitial bytes will be completed */
 738         *len = (bv.cur_bit + 7) >> 3;
 739         bitvec_spare_padding(&bv, (*len * 8) - 1);
 740
 741         return 0;
 742 }
 743
 744 /* encode classmark 2 */
 745 int gsm48_rr_enc_cm2(struct osmocom_ms *ms, struct gsm48_classmark2 *cm)
 746 {
 747         struct gsm48_rrlayer *rr = &ms->rrlayer;
 748         struct gsm_support *sup = &ms->support;
 749
 750         if (rr->cd_now.arfcn >= 512 && rr->cd_now.arfcn <= 885)
 751                 cm->pwr_lev = sup->pwr_lev_1800;
 752         else
 753                 cm->pwr_lev = sup->pwr_lev_900;
 754         cm->a5_1 = sup->a5_1;
 755         cm->es_ind = sup->es_ind;
 756         cm->rev_lev = sup->rev_lev;
 757         cm->fc = (sup->r_gsm || sup->e_gsm);
 758         cm->vgcs = sup->vgcs;
 759         cm->vbs = sup->vbs;
 760         cm->sm_cap = sup->sms_ptp;
 761         cm->ss_scr = sup->ss_ind;
 762         cm->ps_cap = sup->ps_cap;
 763         cm->a5_2 = sup->a5_2;
 764         cm->a5_3 = sup->a5_3;
 765         cm->cmsp = sup->cmsp;
 766         cm->solsa = sup->solsa;
 767         cm->lcsva_cap = sup->lcsva;
 768
 769         return 0;
 770 }
 771
 772 /* send classmark change */
 773 static int gsm48_rr_tx_cm_change(struct osmocom_ms *ms)
 774 {
 775         struct gsm_support *sup = &ms->support;
 776         struct msgb *nmsg;
 777         struct gsm48_hdr *gh;
 778         struct gsm48_cm_change *cc;
 779         uint8_t cm3[14], *tlv;
 780
 781         LOGP(DRR, LOGL_INFO, "CLASSMARK CHANGE\n");
 782
 783         nmsg = gsm48_l3_msgb_alloc();
 784         if (!nmsg)
 785                 return -ENOMEM;
 786         gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
 787         cc = (struct gsm48_cm_change *) msgb_put(nmsg, sizeof(*cc));
 788
 789         gh->proto_discr = GSM48_PDISC_RR;
 790         gh->msg_type = GSM48_MT_RR_CLSM_CHG;
 791
 792         /* classmark 2 */
 793         cc->cm2_len = sizeof(cc->cm2);
 794         gsm48_rr_enc_cm2(ms, &cc->cm2);
 795
 796         /* classmark 3 */
 797         if (sup->dcs_1800 || sup->e_gsm || sup->r_gsm
 798          || sup->a5_7 || sup->a5_6 || sup->a5_5 || sup->a5_4
 799          || sup->ms_sup
 800          || sup->ucs2_treat
 801          || sup->ext_meas || sup->meas_cap
 802          || sup->loc_serv) {
 803                 cc->cm2.cm3 = 1;
 804                 cm3[0] = GSM48_IE_CLASSMARK3;
 805                 gsm48_rr_enc_cm3(ms, cm3 + 2, &cm3[1]);
 806                 tlv = msgb_put(nmsg, 2 + cm3[1]);
 807                 memcpy(tlv, cm3, 2 + cm3[1]);
 808         }
 809
 810         return gsm48_send_rsl(ms, RSL_MT_DATA_REQ, nmsg);
 811 }
 812
 813 /* receiving classmark enquiry */
 814 static int gsm48_rr_rx_cm_enq(struct osmocom_ms *ms, struct msgb *msg)
 815 {
 816         /* send classmark */
 817         return gsm48_rr_tx_cm_change(ms);
 818 }
 819
 820 /*
 821  * random access
 822  */
 823
 824 /* temporary timer until we have time control over channnel request */
 825 /* TODO: turn this into a channel activation timeout, later */
 826 #define RSL_MT_CHAN_CNF 0x19
 827 #include <osmocom/l1ctl.h>
 828 static void temp_rach_to(void *arg)
 829 {
 830         struct gsm48_rrlayer *rr = arg;
 831         struct osmocom_ms *ms = rr->ms;
 832         struct msgb *msg = msgb_alloc_headroom(23+10, 10, "LAPDm RR");
 833         struct abis_rsl_rll_hdr *rllh = (struct abis_rsl_rll_hdr *) msgb_put(msg, sizeof(*rllh));
 834
 835         rllh->c.msg_type = RSL_MT_CHAN_CNF;
 836         msg->l2h = (unsigned char *)rllh;
 837         gsm48_rcv_rsl(ms, msg);
 838
 839         return;
 840 }
 841
 842 int gsm48_rr_rach_conf(struct osmocom_ms *ms, uint32_t fn)
 843 {
 844         struct gsm48_rrlayer *rr = &ms->rrlayer;
 845
 846         LOGP(DRR, LOGL_INFO, "RACH confirm framenr=%u\n", fn);
 847         rr->cr_hist[0].valid = 2;
 848         rr->cr_hist[0].fn = fn;
 849
 850         return 0;
 851 }
 852
 853 /* start random access */
 854 static int gsm48_rr_chan_req(struct osmocom_ms *ms, int cause, int paging)
 855 {
 856         struct gsm48_rrlayer *rr = &ms->rrlayer;
 857         struct gsm322_cellsel *cs = &ms->cellsel;
 858         struct gsm48_sysinfo *s = cs->si;
 859         struct msgb *nmsg;
 860         struct gsm48_rr_hdr *nrrh;
 861         uint8_t chan_req_val, chan_req_mask;
 862         int rc;
 863
 864         LOGP(DSUM, LOGL_INFO, "Establish radio link due to %s request\n",
 865                 (paging) ? "paging" : "mobility management");
 866
 867         /* ignore paging, if not camping */
 868         if (paging
 869          && (!cs->selected || (cs->state != GSM322_C3_CAMPED_NORMALLY
 870                             && cs->state != GSM322_C7_CAMPED_ANY_CELL))) {
 871                 LOGP(DRR, LOGL_INFO, "Paging, but not camping, ignore.\n");
 872                 return -EINVAL;
 873         }
 874
 875         /* tell cell selection process to leave idle mode
 876          * NOTE: this must be sent unbuffered, because the state may not
 877          * change until idle mode is left
 878          */
 879         nmsg = gsm322_msgb_alloc(GSM322_EVENT_LEAVE_IDLE);
 880         if (!nmsg)
 881                 return -ENOMEM;
 882         rc = gsm322_c_event(ms, nmsg);
 883         msgb_free(nmsg);
 884         if (rc) {
 885                 if (paging)
 886                         return rc;
 887                 LOGP(DRR, LOGL_INFO, "Failed to leave IDLE mode.\n");
 888                 goto undefined;
 889         }
 890
 891         /* 3.3.1.1.2 */
 892         new_rr_state(rr, GSM48_RR_ST_CONN_PEND);
 893
 894         /* number of retransmissions (with first transmission) */
 895         rr->n_chan_req = s->max_retrans + 1;
 896
 897 #warning HACK: always request SDCCH for test
 898 cause = RR_EST_CAUSE_LOC_UPD;
 899         /* generate CHAN REQ (9.1.8) */
 900         switch (cause) {
 901         case RR_EST_CAUSE_EMERGENCY:
 902                 /* 101xxxxx */
 903                 chan_req_mask = 0x1f;
 904                 chan_req_val = 0xa0;
 905                 LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (Emergency call)\n",
 906                         chan_req_val);
 907                 break;
 908         case RR_EST_CAUSE_REESTAB_TCH_F:
 909                 chan_req_mask = 0x1f;
 910                 chan_req_val = 0xc0;
 911                 LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (re-establish "
 912                         "TCH/F)\n", chan_req_val);
 913                 break;
 914         case RR_EST_CAUSE_REESTAB_TCH_H:
 915                 if (s->neci) {
 916                         chan_req_mask = 0x03;
 917                         chan_req_val = 0x68;
 918                         LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x "
 919                                 "(re-establish TCH/H with NECI)\n",
 920                                 chan_req_val);
 921                 } else {
 922                         chan_req_mask = 0x1f;
 923                         chan_req_val = 0xc0;
 924                         LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x "
 925                                 "(re-establish TCH/H no NECI)\n", chan_req_val);
 926                 }
 927                 break;
 928         case RR_EST_CAUSE_REESTAB_2_TCH_H:
 929                 if (s->neci) {
 930                         chan_req_mask = 0x03;
 931                         chan_req_val = 0x6c;
 932                         LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x "
 933                                 "(re-establish TCH/H+TCH/H with NECI)\n",
 934                                 chan_req_val);
 935                 } else {
 936                         chan_req_mask = 0x1f;
 937                         chan_req_val = 0xc0;
 938                         LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x "
 939                                 "(re-establish TCH/H+TCH/H no NECI)\n",
 940                                 chan_req_val);
 941                 }
 942                 break;
 943         case RR_EST_CAUSE_ANS_PAG_ANY:
 944                 chan_req_mask = 0x1f;
 945                 chan_req_val = 0x80;
 946                 LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (PAGING "
 947                         "Any channel)\n", chan_req_val);
 948                 break;
 949         case RR_EST_CAUSE_ANS_PAG_SDCCH:
 950                 chan_req_mask = 0x0f;
 951                 chan_req_val = 0x10;
 952                 LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (PAGING SDCCH)\n",
 953                         chan_req_val);
 954                 break;
 955         case RR_EST_CAUSE_ANS_PAG_TCH_F:
 956                 /* ms supports no dual rate */
 957                 chan_req_mask = 0x1f;
 958                 chan_req_val = 0x80;
 959                 LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (PAGING TCH/F)\n",
 960                         chan_req_val);
 961                 break;
 962         case RR_EST_CAUSE_ANS_PAG_TCH_ANY:
 963                 /* ms supports no dual rate */
 964                 chan_req_mask = 0x1f;
 965                 chan_req_val = 0x80;
 966                 LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (PAGING TCH/H or "
 967                                 "TCH/F)\n", chan_req_val);
 968                 break;
 969         case RR_EST_CAUSE_ORIG_TCHF:
 970                 /* ms supports no dual rate */
 971                 chan_req_mask = 0x1f;
 972                 chan_req_val = 0xe0;
 973                 LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (Orig TCH/F)\n",
 974                         chan_req_val);
 975                 break;
 976         case RR_EST_CAUSE_LOC_UPD:
 977                 if (s->neci) {
 978                         chan_req_mask = 0x0f;
 979                         chan_req_val = 0x00;
 980                         LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (Location "
 981                                 "Update with NECI)\n", chan_req_val);
 982                 } else {
 983                         chan_req_mask = 0x1f;
 984                         chan_req_val = 0x00;
 985                         LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (Location "
 986                                 "Update no NECI)\n", chan_req_val);
 987                 }
 988                 break;
 989         case RR_EST_CAUSE_OTHER_SDCCH:
 990                 if (s->neci) {
 991                         chan_req_mask = 0x0f;
 992                         chan_req_val = 0x01;
 993                         LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (OHTER "
 994                                 "with NECI)\n", chan_req_val);
 995                 } else {
 996                         chan_req_mask = 0x1f;
 997                         chan_req_val = 0xe0;
 998                         LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: %02x (OTHER "
 999                                 "no NECI)\n", chan_req_val);
1000                 }
1001                 break;
1002         default:
1003                 if (!rr->rr_est_req) /* no request from MM */
1004                         return -EINVAL;
1005
1006                 LOGP(DRR, LOGL_INFO, "CHANNEL REQUEST: with unknown "
1007                         "establishment cause: %d\n", cause);
1008                 undefined:
1009                 LOGP(DSUM, LOGL_INFO, "Requesting channel failed\n");
1010
1011                 nmsg = gsm48_rr_msgb_alloc(GSM48_RR_REL_IND);
1012                 if (!nmsg)
1013                         return -ENOMEM;
1014                 nrrh = (struct gsm48_rr_hdr *)nmsg->data;
1015                 nrrh->cause = RR_REL_CAUSE_UNDEFINED;
1016                 gsm48_rr_upmsg(ms, nmsg);
1017                 new_rr_state(rr, GSM48_RR_ST_IDLE);
1018                 return -EINVAL;
1019         }
1020
1021 // TODO: turn this into the channel activation timer
1022         rr->temp_rach_ti.cb = temp_rach_to;
1023         rr->temp_rach_ti.data = rr;
1024         bsc_schedule_timer(&rr->temp_rach_ti, ms->support.sync_to, 0);
1025
1026         /* store value, mask and history */
1027         rr->chan_req_val = chan_req_val;
1028         rr->chan_req_mask = chan_req_mask;
1029         rr->cr_hist[2].valid = 0;
1030         rr->cr_hist[1].valid = 0;
1031         rr->cr_hist[0].valid = 0;
1032
1033         /* if channel is already active somehow */
1034         if (cs->ccch_state == GSM322_CCCH_ST_DATA)
1035                 return gsm48_rr_tx_rand_acc(ms, NULL);
1036
1037         return 0;
1038 }
1039
1040 /* send first/next channel request in conn pend state */
1041 int gsm48_rr_tx_rand_acc(struct osmocom_ms *ms, struct msgb *msg)
1042 {
1043         struct gsm48_rrlayer *rr = &ms->rrlayer;
1044         struct gsm322_cellsel *cs = &ms->cellsel;
1045         struct gsm48_sysinfo *s = &ms->cellsel.sel_si;
1046         struct msgb *nmsg;
1047         struct l1ctl_info_ul *nul;
1048         struct l1ctl_rach_req *nra;
1049         int slots;
1050         uint8_t chan_req;
1051
1052         if (cs->ccch_state != GSM322_CCCH_ST_DATA) {
1053                 LOGP(DRR, LOGL_INFO, "CCCH channel activation failed.\n");
1054
1055                 if (rr->rr_est_req) {
1056                         struct msgb *msg =
1057                                 gsm48_rr_msgb_alloc(GSM48_RR_REL_IND);
1058                         struct gsm48_rr_hdr *rrh;
1059
1060                         LOGP(DSUM, LOGL_INFO, "Requesting channel failed\n");
1061                         if (!msg)
1062                                 return -ENOMEM;
1063                         rrh = (struct gsm48_rr_hdr *)msg->data;
1064                         rrh->cause = RR_REL_CAUSE_RA_FAILURE;
1065                         gsm48_rr_upmsg(ms, msg);
1066                 }
1067
1068                 new_rr_state(rr, GSM48_RR_ST_IDLE);
1069
1070                 return 0;
1071         }
1072
1073         if (rr->state == GSM48_RR_ST_IDLE) {
1074                 LOGP(DRR, LOGL_INFO, "MM already released RR.\n");
1075
1076                 return 0;
1077         }
1078
1079         LOGP(DRR, LOGL_INFO, "RANDOM ACCESS (requests left %d)\n",
1080                 rr->n_chan_req);
1081
1082         if (!rr->n_chan_req) {
1083                 LOGP(DRR, LOGL_INFO, "Done with sending RANDOM ACCESS "
1084                         "bursts\n");
1085                 if (!bsc_timer_pending(&rr->t3126))
1086                         start_rr_t3126(rr, 5, 0); /* TODO improve! */
1087                 return 0;
1088         }
1089         rr->n_chan_req--;
1090
1091         if (!rr->wait_assign) {
1092                 /* first random acces, without delay of slots */
1093                 slots = 0;
1094                 rr->wait_assign = 1;
1095         } else {
1096                 /* subsequent random acces, with slots from table 3.1 */
1097                 switch(s->tx_integer) {
1098                 case 3: case 8: case 14: case 50:
1099                         if (s->ccch_conf != 1) /* not combined CCCH */
1100                                 slots = 55;
1101                         else
1102                                 slots = 41;
1103                 case 4: case 9: case 16:
1104                         if (s->ccch_conf != 1)
1105                                 slots = 76;
1106                         else
1107                                 slots = 52;
1108                 case 5: case 10: case 20:
1109                         if (s->ccch_conf != 1)
1110                                 slots = 109;
1111                         else
1112                                 slots = 58;
1113                 case 6: case 11: case 25:
1114                         if (s->ccch_conf != 1)
1115                                 slots = 163;
1116                         else
1117                                 slots = 86;
1118                 default:
1119                         if (s->ccch_conf != 1)
1120                                 slots = 217;
1121                         else
1122                                 slots = 115;
1123                 }
1124         }
1125
1126         /* resend chan_req with new randiom */
1127 #ifdef TODO
1128         nmsg = gsm48_rsl_msgb_alloc();
1129 #else
1130         nmsg = msgb_alloc_headroom(64, 48, "RAND_ACC");
1131         struct l1ctl_hdr *l1h;
1132         nmsg->l1h = msgb_put(nmsg, sizeof(*l1h));
1133         l1h = (struct l1ctl_hdr *) nmsg->l1h;
1134         l1h->msg_type = L1CTL_RACH_REQ;
1135         if (!nmsg)
1136                 return -ENOMEM;
1137         nul = (struct l1ctl_info_ul *) msgb_put(nmsg, sizeof(*nul));
1138 #endif
1139         nra = (struct l1ctl_rach_req *) msgb_put(nmsg, sizeof(*nra));
1140         chan_req = random();
1141         chan_req &= rr->chan_req_mask;
1142         chan_req |= rr->chan_req_val;
1143         nra->ra = chan_req;
1144 #ifdef TODO
1145         at this point we require chan req to be sent at a given delay
1146         also we require a confirm from radio part
1147         nra->delay = (random() % s->tx_integer) + slots;
1148
1149         LOGP(DRR, LOGL_INFO, "RANDOM ACCESS (ra 0x%02x delay %d)\n", nra->ra,
1150                 nra->delay);
1151 #else
1152         rr->temp_rach_ti.cb = temp_rach_to;
1153         rr->temp_rach_ti.data = rr;
1154         bsc_schedule_timer(&rr->temp_rach_ti, 0, 900000);
1155
1156         LOGP(DRR, LOGL_INFO, "RANDOM ACCESS (ra 0x%02x)\n", nra->ra);
1157 #endif
1158
1159         /* shift history and store */
1160         memcpy(&(rr->cr_hist[2]), &(rr->cr_hist[1]),
1161                 sizeof(struct gsm48_cr_hist));
1162         memcpy(&(rr->cr_hist[1]), &(rr->cr_hist[0]),
1163                 sizeof(struct gsm48_cr_hist));
1164         rr->cr_hist[0].valid = 1;
1165         rr->cr_hist[0].chan_req = chan_req;
1166
1167 #ifdef TODO
1168         add layer 1 conrols to RSL...
1169         return gsm48_send_rsl(ms, RSL_MT_CHAN_REQ, nmsg);
1170 #else
1171 //#warning disabled!
1172         return osmo_send_l1(ms, nmsg);
1173 #endif
1174 }
1175
1176 /*
1177  * system information
1178  */
1179
1180 /* decode "Cell Channel Description" (10.5.2.1b) and other frequency lists */
1181 static int gsm48_decode_freq_list(struct gsm_support *sup,
1182         struct gsm_sysinfo_freq *f, uint8_t *cd, uint8_t len, uint8_t mask,
1183         uint8_t frqt)
1184 {
1185         int i;
1186
1187         /* NOTES:
1188          *
1189          * The Range format uses "SMOD" computation.
1190          * e.g. "n SMOD m" equals "((n - 1) % m) + 1"
1191          * A cascade of multiple SMOD computations is simpified:
1192          * "(n SMOD m) SMOD o" equals "(((n - 1) % m) % o) + 1"
1193          *
1194          * The Range format uses 16 octets of data in SYSTEM INFORMATION.
1195          * When used in dedicated messages, the length can be less.
1196          * In this case the ranges are decoded for all frequencies that
1197          * fit in the block of given length.
1198          */
1199
1200         /* tabula rasa */
1201         for (i = 0; i < 1024; i++)
1202                 f[i].mask &= ~frqt;
1203
1204         /* 00..XXX. */
1205         if ((cd[0] & 0xc0 & mask) == 0x00) {
1206                 /* Bit map 0 format */
1207                 if (len < 16)
1208                         return -EINVAL;
1209                 for (i = 1; i <= 124; i++)
1210                         if ((cd[15 - ((i-1) >> 3)] & (1 << ((i-1) & 7))))
1211                                 f[i].mask |= frqt;
1212
1213                 return 0;
1214         }
1215
1216         /* only Bit map 0 format for P-GSM */
1217         if (sup->p_gsm && !sup->e_gsm && !sup->r_gsm && !sup->dcs_1800)
1218                 return 0;
1219
1220         /* 10..0XX. */
1221         if ((cd[0] & 0xc8 & mask) == 0x80) {
1222                 /* Range 1024 format */
1223                 uint16_t w[17]; /* 1..16 */
1224                 struct gsm48_range_1024 *r = (struct gsm48_range_1024 *)cd;
1225
1226                 if (len < 2)
1227                         return -EINVAL;
1228                 memset(w, 0, sizeof(w));
1229                 if (r->f0)
1230                         f[0].mask |= frqt;
1231                 w[1] = (r->w1_hi << 8) | r->w1_lo;
1232                 if (len >= 4)
1233                         w[2] = (r->w2_hi << 1) | r->w2_lo;
1234                 if (len >= 5)
1235                         w[3] = (r->w3_hi << 2) | r->w3_lo;
1236                 if (len >= 6)
1237                         w[4] = (r->w4_hi << 2) | r->w4_lo;
1238                 if (len >= 7)
1239                         w[5] = (r->w5_hi << 2) | r->w5_lo;
1240                 if (len >= 8)
1241                         w[6] = (r->w6_hi << 2) | r->w6_lo;
1242                 if (len >= 9)
1243                         w[7] = (r->w7_hi << 2) | r->w7_lo;
1244                 if (len >= 10)
1245                         w[8] = (r->w8_hi << 1) | r->w8_lo;
1246                 if (len >= 10)
1247                         w[9] = r->w9;
1248                 if (len >= 11)
1249                         w[10] = r->w10;
1250                 if (len >= 12)
1251                         w[11] = (r->w11_hi << 6) | r->w11_lo;
1252                 if (len >= 13)
1253                         w[12] = (r->w12_hi << 5) | r->w12_lo;
1254                 if (len >= 14)
1255                         w[13] = (r->w13_hi << 4) | r->w13_lo;
1256                 if (len >= 15)
1257                         w[14] = (r->w14_hi << 3) | r->w14_lo;
1258                 if (len >= 16)
1259                         w[15] = (r->w15_hi << 2) | r->w15_lo;
1260                 if (len >= 16)
1261                         w[16] = r->w16;
1262                 if (w[1])
1263                         f[w[1]].mask |= frqt;
1264                 if (w[2])
1265                         f[((w[1] - 512 + w[2] - 1) % 1023) + 1].mask |= frqt;
1266                 if (w[3])
1267                         f[((w[1]       + w[3] - 1) % 1023) + 1].mask |= frqt;
1268                 if (w[4])
1269                         f[((w[1] - 512 + ((w[2] - 256 + w[4] - 1) % 511)) % 1023) + 1].mask |= frqt;
1270                 if (w[5])
1271                         f[((w[1]       + ((w[3] - 256 - w[5] - 1) % 511)) % 1023) + 1].mask |= frqt;
1272                 if (w[6])
1273                         f[((w[1] - 512 + ((w[2]       + w[6] - 1) % 511)) % 1023) + 1].mask |= frqt;
1274                 if (w[7])
1275                         f[((w[1]       + ((w[3]       + w[7] - 1) % 511)) % 1023) + 1].mask |= frqt;
1276                 if (w[8])
1277                         f[((w[1] - 512 + ((w[2] - 256 + ((w[4] - 128 + w[8] - 1) % 255)) % 511)) % 1023) + 1].mask |= frqt;
1278                 if (w[9])
1279                         f[((w[1]       + ((w[3] - 256 + ((w[5] - 128 + w[9] - 1) % 255)) % 511)) % 1023) + 1].mask |= frqt;
1280                 if (w[10])
1281                         f[((w[1] - 512 + ((w[2]       + ((w[6] - 128 + w[10] - 1) % 255)) % 511)) % 1023) + 1].mask |= frqt;
1282                 if (w[11])
1283                         f[((w[1]       + ((w[3]       + ((w[7] - 128 + w[11] - 1) % 255)) % 511)) % 1023) + 1].mask |= frqt;
1284                 if (w[12])
1285                         f[((w[1] - 512 + ((w[2] - 256 + ((w[4]       + w[12] - 1) % 255)) % 511)) % 1023) + 1].mask |= frqt;
1286                 if (w[13])
1287                         f[((w[1]       + ((w[3] - 256 + ((w[5]       + w[13] - 1) % 255)) % 511)) % 1023) + 1].mask |= frqt;
1288                 if (w[14])
1289                         f[((w[1] - 512 + ((w[2]       + ((w[6]       + w[14] - 1) % 255)) % 511)) % 1023) + 1].mask |= frqt;
1290                 if (w[15])
1291                         f[((w[1]       + ((w[3]       + ((w[7]       + w[15] - 1) % 255)) % 511)) % 1023) + 1].mask |= frqt;
1292                 if (w[16])
1293                         f[((w[1] - 512 + ((w[2] - 256 + ((w[4] - 128 + ((w[8] - 64 + w[16] - 1) % 127)) % 255)) % 511)) % 1023) + 1].mask |= frqt;
1294
1295                 return 0;
1296         }
1297         /* 10..100. */
1298         if ((cd[0] & 0xce & mask) == 0x88) {
1299                 /* Range 512 format */
1300                 uint16_t w[18]; /* 1..17 */
1301                 struct gsm48_range_512 *r = (struct gsm48_range_512 *)cd;
1302
1303                 if (len < 4)
1304                         return -EINVAL;
1305                 memset(w, 0, sizeof(w));
1306                 w[0] = (r->orig_arfcn_hi << 9) | (r->orig_arfcn_mid << 1) | r->orig_arfcn_lo;
1307                 w[1] = (r->w1_hi << 2) | r->w1_lo;
1308                 if (len >= 5)
1309                         w[2] = (r->w2_hi << 2) | r->w2_lo;
1310                 if (len >= 6)
1311                         w[3] = (r->w3_hi << 2) | r->w3_lo;
1312                 if (len >= 7)
1313                         w[4] = (r->w4_hi << 1) | r->w4_lo;
1314                 if (len >= 7)
1315                         w[5] = r->w5;
1316                 if (len >= 8)
1317                         w[6] = r->w6;
1318                 if (len >= 9)
1319                         w[7] = (r->w7_hi << 6) | r->w7_lo;
1320                 if (len >= 10)
1321                         w[8] = (r->w8_hi << 4) | r->w8_lo;
1322                 if (len >= 11)
1323                         w[9] = (r->w9_hi << 2) | r->w9_lo;
1324                 if (len >= 11)
1325                         w[10] = r->w10;
1326                 if (len >= 12)
1327                         w[11] = r->w11;
1328                 if (len >= 13)
1329                         w[12] = (r->w12_hi << 4) | r->w12_lo;
1330                 if (len >= 14)
1331                         w[13] = (r->w13_hi << 2) | r->w13_lo;
1332                 if (len >= 14)
1333                         w[14] = r->w14;
1334                 if (len >= 15)
1335                         w[15] = r->w15;
1336                 if (len >= 16)
1337                         w[16] = (r->w16_hi << 3) | r->w16_lo;
1338                 if (len >= 16)
1339                         w[17] = r->w17;
1340                 f[w[0]].mask |= frqt;
1341                 if (w[1])
1342                         f[(w[0] + w[1]) % 1024].mask |= frqt;
1343                 if (w[2])
1344                         f[(w[0] + ((w[1] - 256 + w[2] - 1) % 511) + 1) % 1024].mask |= frqt;
1345                 if (w[3])
1346                         f[(w[0] + ((w[1]       + w[3] - 1) % 511) + 1) % 1024].mask |= frqt;
1347                 if (w[4])
1348                         f[(w[0] + ((w[1] - 256 + ((w[2] - 128 + w[4] - 1) % 255)) % 511) + 1) % 1024].mask |= frqt;
1349                 if (w[5])
1350                         f[(w[0] + ((w[1]       + ((w[3] - 128 + w[5] - 1) % 255)) % 511) + 1) % 1024].mask |= frqt;
1351                 if (w[6])
1352                         f[(w[0] + ((w[1] - 256 + ((w[2]       + w[6] - 1) % 255)) % 511) + 1) % 1024].mask |= frqt;
1353                 if (w[7])
1354                         f[(w[0] + ((w[1]       + ((w[3]       + w[7] - 1) % 255)) % 511) + 1) % 1024].mask |= frqt;
1355                 if (w[8])
1356                         f[(w[0] + ((w[1] - 256 + ((w[2] - 128 + ((w[4] - 64 + w[8] - 1) % 127)) % 255)) % 511) + 1) % 1024].mask |= frqt;
1357                 if (w[9])
1358                         f[(w[0] + ((w[1]       + ((w[3] - 128 + ((w[5] - 64 + w[9] - 1) % 127)) % 255)) % 511) + 1) % 1024].mask |= frqt;
1359                 if (w[10])
1360                         f[(w[0] + ((w[1] - 256 + ((w[2]       + ((w[6] - 64 + w[10] - 1) % 127)) % 255)) % 511) + 1) % 1024].mask |= frqt;
1361                 if (w[11])
1362                         f[(w[0] + ((w[1]       + ((w[3]       + ((w[7] - 64 + w[11] - 1) % 127)) % 255)) % 511) + 1) % 1024].mask |= frqt;
1363                 if (w[12])
1364                         f[(w[0] + ((w[1] - 256 + ((w[2] - 128 + ((w[4]      + w[12] - 1) % 127)) % 255)) % 511) + 1) % 1024].mask |= frqt;
1365                 if (w[13])
1366                         f[(w[0] + ((w[1]       + ((w[3] - 128 + ((w[5]      + w[13] - 1) % 127)) % 255)) % 511) + 1) % 1024].mask |= frqt;
1367                 if (w[14])
1368                         f[(w[0] + ((w[1] - 256 + ((w[2]       + ((w[6]      + w[14] - 1) % 127)) % 255)) % 511) + 1) % 1024].mask |= frqt;
1369                 if (w[15])
1370                         f[(w[0] + ((w[1]       + ((w[3]       + ((w[7]      + w[15] - 1) % 127)) % 255)) % 511) + 1) % 1024].mask |= frqt;
1371                 if (w[16])
1372                         f[(w[0] + ((w[1] - 256 + ((w[2] - 128 + ((w[4] - 64 + ((w[8] - 32 + w[16] - 1) % 63)) % 127)) % 255)) % 511) + 1) % 1024].mask |= frqt;
1373                 if (w[17])
1374                         f[(w[0] + ((w[1]       + ((w[3] - 128 + ((w[5] - 64 + ((w[9] - 32 + w[17] - 1) % 63)) % 127)) % 255)) % 511) + 1) % 1024].mask |= frqt;
1375
1376                 return 0;
1377         }
1378         /* 10..101. */
1379         if ((cd[0] & 0xce & mask) == 0x8a) {
1380                 /* Range 256 format */
1381                 uint16_t w[22]; /* 1..21 */
1382                 struct gsm48_range_256 *r = (struct gsm48_range_256 *)cd;
1383
1384                 if (len < 4)
1385                         return -EINVAL;
1386                 memset(w, 0, sizeof(w));
1387                 w[0] = (r->orig_arfcn_hi << 9) | (r->orig_arfcn_mid << 1) | r->orig_arfcn_lo;
1388                 w[1] = (r->w1_hi << 1) | r->w1_lo;
1389                 if (len >= 4)
1390                         w[2] = r->w2;
1391                 if (len >= 5)
1392                         w[3] = r->w3;
1393                 if (len >= 6)
1394                         w[4] = (r->w4_hi << 5) | r->w4_lo;
1395                 if (len >= 7)
1396                         w[5] = (r->w5_hi << 3) | r->w5_lo;
1397                 if (len >= 8)
1398                         w[6] = (r->w6_hi << 1) | r->w6_lo;
1399                 if (len >= 8)
1400                         w[7] = r->w7;
1401                 if (len >= 9)
1402                         w[8] = (r->w8_hi << 4) | r->w8_lo;
1403                 if (len >= 10)
1404                         w[9] = (r->w9_hi << 1) | r->w9_lo;
1405                 if (len >= 10)
1406                         w[10] = r->w10;
1407                 if (len >= 11)
1408                         w[11] = (r->w11_hi << 3) | r->w11_lo;
1409                 if (len >= 11)
1410                         w[12] = r->w12;
1411                 if (len >= 12)
1412                         w[13] = r->w13;
1413                 if (len >= 13)
1414                         w[14] = r->w15;
1415                 if (len >= 13)
1416                         w[15] = (r->w14_hi << 2) | r->w14_lo;
1417                 if (len >= 14)
1418                         w[16] = (r->w16_hi << 3) | r->w16_lo;
1419                 if (len >= 14)
1420                         w[17] = r->w17;
1421                 if (len >= 15)
1422                         w[18] = r->w19;
1423                 if (len >= 15)
1424                         w[19] = (r->w18_hi << 3) | r->w18_lo;
1425                 if (len >= 16)
1426                         w[20] = (r->w20_hi << 3) | r->w20_lo;
1427                 if (len >= 16)
1428                         w[21] = r->w21;
1429                 f[w[0]].mask |= frqt;
1430                 if (w[1])
1431                         f[(w[0] + w[1]) % 1024].mask |= frqt;
1432                 if (w[2])
1433                         f[(w[0] + ((w[1] - 128 + w[2] - 1) % 255) + 1) % 1024].mask |= frqt;
1434                 if (w[3])
1435                         f[(w[0] + ((w[1]       + w[3] - 1) % 255) + 1) % 1024].mask |= frqt;
1436                 if (w[4])
1437                         f[(w[0] + ((w[1] - 128 + ((w[2] - 64 + w[4] - 1) % 127)) % 255) + 1) % 1024].mask |= frqt;
1438                 if (w[5])
1439                         f[(w[0] + ((w[1]       + ((w[3] - 64 + w[5] - 1) % 127)) % 255) + 1) % 1024].mask |= frqt;
1440                 if (w[6])
1441                         f[(w[0] + ((w[1] - 128 + ((w[2]      + w[6] - 1) % 127)) % 255) + 1) % 1024].mask |= frqt;
1442                 if (w[7])
1443                         f[(w[0] + ((w[1]       + ((w[3]      + w[7] - 1) % 127)) % 255) + 1) % 1024].mask |= frqt;
1444                 if (w[8])
1445                         f[(w[0] + ((w[1] - 128 + ((w[2] - 64 + ((w[4] - 32 + w[8] - 1) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1446                 if (w[9])
1447                         f[(w[0] + ((w[1]       + ((w[3] - 64 + ((w[5] - 32 + w[9] - 1) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1448                 if (w[10])
1449                         f[(w[0] + ((w[1] - 128 + ((w[2]      + ((w[6] - 32 + w[10] - 1) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1450                 if (w[11])
1451                         f[(w[0] + ((w[1]       + ((w[3]      + ((w[7] - 32 + w[11] - 1) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1452                 if (w[12])
1453                         f[(w[0] + ((w[1] - 128 + ((w[2] - 64 + ((w[4]      + w[12] - 1) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1454                 if (w[13])
1455                         f[(w[0] + ((w[1]       + ((w[3] - 64 + ((w[5]      + w[13] - 1) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1456                 if (w[14])
1457                         f[(w[0] + ((w[1] - 128 + ((w[2]      + ((w[6]      + w[14] - 1) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1458                 if (w[15])
1459                         f[(w[0] + ((w[1]       + ((w[3]      + ((w[7]      + w[15] - 1) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1460                 if (w[16])
1461                         f[(w[0] + ((w[1] - 128 + ((w[2] - 64 + ((w[4] - 32 + ((w[8] - 16 + w[16] - 1) % 31)) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1462                 if (w[17])
1463                         f[(w[0] + ((w[1]       + ((w[3] - 64 + ((w[5] - 32 + ((w[9] - 16 + w[17] - 1) % 31)) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1464                 if (w[18])
1465                         f[(w[0] + ((w[1] - 128 + ((w[2]      + ((w[6] - 32 + ((w[10] - 16 + w[18] - 1) % 31)) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1466                 if (w[19])
1467                         f[(w[0] + ((w[1]       + ((w[3]      + ((w[7] - 32 + ((w[11] - 16 + w[19] - 1) % 31)) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1468                 if (w[20])
1469                         f[(w[0] + ((w[1] - 128 + ((w[2] - 64 + ((w[4]      + ((w[12] - 16 + w[20] - 1) % 31)) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1470                 if (w[21])
1471                         f[(w[0] + ((w[1]       + ((w[3] - 64 + ((w[5]      + ((w[13] - 16 + w[21] - 1) % 31)) % 63)) % 127)) % 255) + 1) % 1024].mask |= frqt;
1472
1473                 return 0;
1474         }
1475         /* 10..110. */
1476         if ((cd[0] & 0xce & mask) == 0x8c) {
1477                 /* Range 128 format */
1478                 uint16_t w[29]; /* 1..28 */
1479                 struct gsm48_range_128 *r = (struct gsm48_range_128 *)cd;
1480
1481                 if (len < 3)
1482                         return -EINVAL;
1483                 memset(w, 0, sizeof(w));
1484                 w[0] = (r->orig_arfcn_hi << 9) | (r->orig_arfcn_mid << 1) | r->orig_arfcn_lo;
1485                 w[1] = r->w1;
1486                 if (len >= 4)
1487                         w[2] = r->w2;
1488                 if (len >= 5)
1489                         w[3] = (r->w3_hi << 4) | r->w3_lo;
1490                 if (len >= 6)
1491                         w[4] = (r->w4_hi << 1) | r->w4_lo;
1492                 if (len >= 6)
1493                         w[5] = r->w5;
1494                 if (len >= 7)
1495                         w[6] = (r->w6_hi << 3) | r->w6_lo;
1496                 if (len >= 7)
1497                         w[7] = r->w7;
1498                 if (len >= 8)
1499                         w[8] = r->w8;
1500                 if (len >= 8)
1501                         w[9] = r->w9;
1502                 if (len >= 9)
1503                         w[10] = r->w10;
1504                 if (len >= 9)
1505                         w[11] = r->w11;
1506                 if (len >= 10)
1507                         w[12] = r->w12;
1508                 if (len >= 10)
1509                         w[13] = r->w13;
1510                 if (len >= 11)
1511                         w[14] = r->w14;
1512                 if (len >= 11)
1513                         w[15] = r->w15;
1514                 if (len >= 12)
1515                         w[16] = r->w16;
1516                 if (len >= 12)
1517                         w[17] = r->w17;
1518                 if (len >= 13)
1519                         w[18] = (r->w18_hi << 1) | r->w18_lo;
1520                 if (len >= 13)
1521                         w[19] = r->w19;
1522                 if (len >= 13)
1523                         w[20] = r->w20;
1524                 if (len >= 14)
1525                         w[21] = (r->w21_hi << 2) | r->w21_lo;
1526                 if (len >= 14)
1527                         w[22] = r->w22;
1528                 if (len >= 14)
1529                         w[23] = r->w23;
1530                 if (len >= 15)
1531                         w[24] = r->w24;
1532                 if (len >= 15)
1533                         w[25] = r->w25;
1534                 if (len >= 16)
1535                         w[26] = (r->w26_hi << 1) | r->w26_lo;
1536                 if (len >= 16)
1537                         w[27] = r->w27;
1538                 if (len >= 16)
1539                         w[28] = r->w28;
1540                 f[w[0]].mask |= frqt;
1541                 if (w[1])
1542                         f[(w[0] + w[1]) % 1024].mask |= frqt;
1543                 if (w[2])
1544                         f[(w[0] + ((w[1] - 64 + w[2] - 1) % 127) + 1) % 1024].mask |= frqt;
1545                 if (w[3])
1546                         f[(w[0] + ((w[1]      + w[3] - 1) % 127) + 1) % 1024].mask |= frqt;
1547                 if (w[4])
1548                         f[(w[0] + ((w[1] - 64 + ((w[2] - 32 + w[4] - 1) % 63)) % 127) + 1) % 1024].mask |= frqt;
1549                 if (w[5])
1550                         f[(w[0] + ((w[1]      + ((w[3] - 32 + w[5] - 1) % 63)) % 127) + 1) % 1024].mask |= frqt;
1551                 if (w[6])
1552                         f[(w[0] + ((w[1] - 64 + ((w[2]      + w[6] - 1) % 63)) % 127) + 1) % 1024].mask |= frqt;
1553                 if (w[7])
1554                         f[(w[0] + ((w[1]      + ((w[3]      + w[7] - 1) % 63)) % 127) + 1) % 1024].mask |= frqt;
1555                 if (w[8])
1556                         f[(w[0] + ((w[1] - 64 + ((w[2] - 32 + ((w[4] - 16 + w[8] - 1) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1557                 if (w[9])
1558                         f[(w[0] + ((w[1]      + ((w[3] - 32 + ((w[5] - 16 + w[9] - 1) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1559                 if (w[10])
1560                         f[(w[0] + ((w[1] - 64 + ((w[2]      + ((w[6] - 16 + w[10] - 1) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1561                 if (w[11])
1562                         f[(w[0] + ((w[1]      + ((w[3]      + ((w[7] - 16 + w[11] - 1) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1563                 if (w[12])
1564                         f[(w[0] + ((w[1] - 64 + ((w[2] - 32 + ((w[4]      + w[12] - 1) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1565                 if (w[13])
1566                         f[(w[0] + ((w[1]      + ((w[3] - 32 + ((w[5]      + w[13] - 1) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1567                 if (w[14])
1568                         f[(w[0] + ((w[1] - 64 + ((w[2]      + ((w[6]      + w[14] - 1) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1569                 if (w[15])
1570                         f[(w[0] + ((w[1]      + ((w[3]      + ((w[7]      + w[15] - 1) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1571                 if (w[16])
1572                         f[(w[0] + ((w[1] - 64 + ((w[2] - 32 + ((w[4] - 16 + ((w[8] - 8 + w[16] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1573                 if (w[17])
1574                         f[(w[0] + ((w[1]      + ((w[3] - 32 + ((w[5] - 16 + ((w[9] - 8 + w[17] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1575                 if (w[18])
1576                         f[(w[0] + ((w[1] - 64 + ((w[2]      + ((w[6] - 16 + ((w[10] - 8 + w[18] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1577                 if (w[19])
1578                         f[(w[0] + ((w[1]      + ((w[3]      + ((w[7] - 16 + ((w[11] - 8 + w[19] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1579                 if (w[20])
1580                         f[(w[0] + ((w[1] - 64 + ((w[2] - 32 + ((w[4]      + ((w[12] - 8 + w[20] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1581                 if (w[21])
1582                         f[(w[0] + ((w[1]      + ((w[3] - 32 + ((w[5]      + ((w[13] - 8 + w[21] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1583                 if (w[22])
1584                         f[(w[0] + ((w[1] - 64 + ((w[2]      + ((w[6]      + ((w[14] - 8 + w[22] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1585                 if (w[23])
1586                         f[(w[0] + ((w[1]      + ((w[3]      + ((w[7]      + ((w[15] - 8 + w[23] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1587                 if (w[24])
1588                         f[(w[0] + ((w[1] - 64 + ((w[2] - 32 + ((w[4] - 16 + ((w[8]     + w[24] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1589                 if (w[25])
1590                         f[(w[0] + ((w[1]      + ((w[3] - 32 + ((w[5] - 16 + ((w[9]     + w[25] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1591                 if (w[26])
1592                         f[(w[0] + ((w[1] - 64 + ((w[2]      + ((w[6] - 16 + ((w[10]     + w[26] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1593                 if (w[27])
1594                         f[(w[0] + ((w[1]      + ((w[3]      + ((w[7] - 16 + ((w[11]     + w[27] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1595                 if (w[28])
1596                         f[(w[0] + ((w[1] - 64 + ((w[2] - 32 + ((w[4]      + ((w[12]     + w[28] - 1) % 15)) % 31)) % 63)) % 127) + 1) % 1024].mask |= frqt;
1597
1598                 return 0;
1599         }
1600         /* 10..111. */
1601         if ((cd[0] & 0xce & mask) == 0x8e) {
1602                 /* Variable bitmap format (can be any length >= 3) */
1603                 uint16_t orig = 0;
1604                 struct gsm48_var_bit *r = (struct gsm48_var_bit *)cd;
1605
1606                 if (len < 3)
1607                         return -EINVAL;
1608                 orig = (r->orig_arfcn_hi << 9) | (r->orig_arfcn_mid << 1) | r->orig_arfcn_lo;
1609                 f[orig].mask |= frqt;
1610                 for (i = 1; 2 + (i >> 3) < len; i++)
1611                         if ((cd[2 + (i >> 3)] & (0x80 >> (i & 7))))
1612                                 f[(orig + i) % 1024].mask |= frqt;
1613
1614                 return 0;
1615         }
1616
1617         return 0;
1618 }
1619
1620 /* decode "Cell Selection Parameters" (10.5.2.4) */
1621 static int gsm48_decode_cell_sel_param(struct gsm48_sysinfo *s,
1622         struct gsm48_cell_sel_par *cs)
1623 {
1624 #ifdef TODO
1625         convert ms_txpwr_max_ccch dependant on the current frequenc and support
1626         to the right powe level
1627 #endif
1628         s->ms_txpwr_max_ccch = cs->ms_txpwr_max_ccch;
1629         s->cell_resel_hyst_db = cs->cell_resel_hyst * 2;
1630         s->rxlev_acc_min_db = cs->rxlev_acc_min - 110;
1631         s->neci = cs->neci;
1632         s->acs = cs->acs;
1633
1634         return 0;
1635 }
1636
1637 /* decode "Cell Options (BCCH)" (10.5.2.3) */
1638 static int gsm48_decode_cellopt_bcch(struct gsm48_sysinfo *s,
1639         struct gsm48_cell_options *co)
1640 {
1641         s->bcch_radio_link_timeout = (co->radio_link_timeout + 1) * 4;
1642         s->bcch_dtx = co->dtx;
1643         s->bcch_pwrc = co->pwrc;
1644
1645         return 0;
1646 }
1647
1648 /* decode "Cell Options (SACCH)" (10.5.2.3a) */
1649 static int gsm48_decode_cellopt_sacch(struct gsm48_sysinfo *s,
1650         struct gsm48_cell_options *co)
1651 {
1652         s->sacch_radio_link_timeout = (co->radio_link_timeout + 1) * 4;
1653         s->sacch_dtx = co->dtx;
1654         s->sacch_pwrc = co->pwrc;
1655
1656         return 0;
1657 }
1658
1659 /* decode "Control Channel Description" (10.5.2.11) */
1660 static int gsm48_decode_ccd(struct gsm48_sysinfo *s,
1661         struct gsm48_control_channel_descr *cc)
1662 {
1663         s->ccch_conf = cc->ccch_conf;
1664         s->bs_ag_blks_res = cc->bs_ag_blks_res;
1665         s->att_allowed = cc->att;
1666         s->pag_mf_periods = cc->bs_pa_mfrms + 2;
1667         s->t3212 = cc->t3212 * 360; /* convert deci-hours to seconds */
1668
1669         return 0;
1670 }
1671
1672 /* decode "Mobile Allocation" (10.5.2.21) */
1673 static int gsm48_decode_mobile_alloc(struct gsm48_sysinfo *s,
1674         uint8_t *ma, uint8_t len)
1675 {
1676         int i, j = 0;
1677         uint16_t f[len << 3];
1678
1679         /* not more than 64 hopping indexes allowed in IE */
1680         if (len > 8)
1681                 return -EINVAL;
1682
1683         /* tabula rasa */
1684         s->hopp_len = 0;
1685         for (i = 0; i < 1024; i++)
1686                 s->freq[i].mask &= ~FREQ_TYPE_HOPP;
1687
1688         /* generating list of all frequencies (1..1023,0) */
1689         for (i = 1; i <= 1024; i++) {
1690                 if ((s->freq[i & 1023].mask & FREQ_TYPE_SERV)) {
1691                         f[j++] = i & 1023;
1692                         if (j == (len << 3))
1693                                 break;
1694                 }
1695         }
1696
1697         /* fill hopping table with frequency index given by IE
1698          * and set hopping type bits
1699          */
1700         for (i = 0; i < (len << 3); i++) {
1701                 /* if bit is set, this frequency index is used for hopping */
1702                 if ((ma[len - 1 - (i >> 3)] & (1 << (i & 7)))) {
1703                         /* index higher than entries in list ? */
1704                         if (i >= j) {
1705                                 LOGP(DRR, LOGL_NOTICE, "Mobile Allocation "
1706                                         "hopping index %d exceeds maximum "
1707                                         "number of cell frequencies. (%d)\n",
1708                                         i + 1, j);
1709                                 break;
1710                         }
1711                         s->hopping[s->hopp_len++] = f[i];
1712                         s->freq[f[i]].mask |= FREQ_TYPE_HOPP;
1713                 }
1714         }
1715
1716         return 0;
1717 }
1718
1719 /* Rach Control decode tables */
1720 static uint8_t gsm48_max_retrans[4] = {
1721         1, 2, 4, 7
1722 };
1723 static uint8_t gsm48_tx_integer[16] = {
1724         3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 20, 25, 32, 50
1725 };
1726
1727 /* decode "RACH Control Parameter" (10.5.2.29) */
1728 static int gsm48_decode_rach_ctl_param(struct gsm48_sysinfo *s,
1729         struct gsm48_rach_control *rc)
1730 {
1731         s->reest_denied = rc->re;
1732         s->cell_barr = rc->cell_bar;
1733         s->tx_integer = gsm48_tx_integer[rc->tx_integer];
1734         s->max_retrans = gsm48_max_retrans[rc->max_trans];
1735         s->class_barr = (rc->t2 << 8) | rc->t3;
1736
1737         return 0;
1738 }
1739 static int gsm48_decode_rach_ctl_neigh(struct gsm48_sysinfo *s,
1740         struct gsm48_rach_control *rc)
1741 {
1742         s->nb_reest_denied = rc->re;
1743         s->nb_cell_barr = rc->cell_bar;
1744         s->nb_tx_integer = gsm48_tx_integer[rc->tx_integer];
1745         s->nb_max_retrans = gsm48_max_retrans[rc->max_trans];
1746         s->nb_class_barr = (rc->t2 << 8) | rc->t3;
1747
1748         return 0;
1749 }
1750
1751 /* decode "SI 1 Rest Octets" (10.5.2.32) */
1752 static int gsm48_decode_si1_rest(struct gsm48_sysinfo *s, uint8_t *si,
1753         uint8_t len)
1754 {
1755         return 0;
1756 }
1757
1758 /* decode "SI 3 Rest Octets" (10.5.2.34) */
1759 static int gsm48_decode_si3_rest(struct gsm48_sysinfo *s, uint8_t *si,
1760         uint8_t len)
1761 {
1762         struct bitvec bv;
1763
1764         memset(&bv, 0, sizeof(bv));
1765         bv.data_len = len;
1766         bv.data = si;
1767
1768         /* Optional Selection Parameters */
1769         if (bitvec_get_bit_high(&bv) == H) {
1770                 s->sp = 1;
1771                 s->sp_cbq = bitvec_get_uint(&bv, 1);
1772                 s->sp_cro = bitvec_get_uint(&bv, 6);
1773                 s->sp_to = bitvec_get_uint(&bv, 3);
1774                 s->sp_pt = bitvec_get_uint(&bv, 5);
1775         }
1776         /* Optional Power Offset */
1777         if (bitvec_get_bit_high(&bv) == H) {
1778                 s->po = 1;
1779                 s->po_value = bitvec_get_uint(&bv, 3);
1780         }
1781         /* System Onformation 2ter Indicator */
1782         if (bitvec_get_bit_high(&bv) == H)
1783                 s->si2ter_ind = 1;
1784         /* Early Classark Sending Control */
1785         if (bitvec_get_bit_high(&bv) == H)
1786                 s->ecsm = 1;
1787         /* Scheduling if and where */
1788         if (bitvec_get_bit_high(&bv) == H) {
1789                 s->sched = 1;
1790                 s->sched_where = bitvec_get_uint(&bv, 3);
1791         }
1792         /* GPRS Indicator */
1793         s->gi_ra_colour = bitvec_get_uint(&bv, 3);
1794         s->gi_si13_pos = bitvec_get_uint(&bv, 1);
1795         return 0;
1796 }
1797
1798 /* decode "SI 4 Rest Octets" (10.5.2.35) */
1799 static int gsm48_decode_si4_rest(struct gsm48_sysinfo *s, uint8_t *si,
1800         uint8_t len)
1801 {
1802         return 0;
1803 }
1804
1805 /* decode "SI 6 Rest Octets" (10.5.2.35a) */
1806 static int gsm48_decode_si6_rest(struct gsm48_sysinfo *s, uint8_t *si,
1807         uint8_t len)
1808 {
1809         return 0;
1810 }
1811
1812 /* send sysinfo event to other layers */
1813 static int gsm48_send_sysinfo(struct osmocom_ms *ms, uint8_t type)
1814 {
1815         struct msgb *nmsg;
1816         struct gsm322_msg *em;
1817
1818         nmsg = gsm322_msgb_alloc(GSM322_EVENT_SYSINFO);
1819         if (!nmsg)
1820                 return -ENOMEM;
1821         em = (struct gsm322_msg *) nmsg->data;
1822         em->sysinfo = type;
1823         gsm322_cs_sendmsg(ms, nmsg);
1824
1825         /* send timer info to location update process */
1826         nmsg = gsm48_mmevent_msgb_alloc(GSM48_MM_EVENT_SYSINFO);
1827         if (!nmsg)
1828                 return -ENOMEM;
1829         gsm48_mmevent_msg(ms, nmsg);
1830
1831         return 0;
1832 }
1833
1834 /* receive "SYSTEM INFORMATION 1" message (9.1.31) */
1835 static int gsm48_rr_rx_sysinfo1(struct osmocom_ms *ms, struct msgb *msg)
1836 {
1837         struct gsm48_system_information_type_1 *si = msgb_l3(msg);
1838         struct gsm48_sysinfo *s = ms->cellsel.si;
1839         int payload_len = msgb_l3len(msg) - sizeof(*si);
1840
1841         if (!s) {
1842                 LOGP(DRR, LOGL_INFO, "No cell selected, SYSTEM INFORMATION 1 "
1843                         "ignored\n");
1844                 return -EINVAL;
1845         }
1846
1847         if (payload_len < 0) {
1848                 LOGP(DRR, LOGL_NOTICE, "Short read of SYSTEM INFORMATION 1 "
1849                         "message.\n");
1850                 return -EINVAL;
1851         }
1852
1853         if (!memcmp(si, s->si1_msg, MIN(msgb_l3len(msg), sizeof(s->si1_msg))))
1854                 return 0;
1855         memcpy(s->si1_msg, si, MIN(msgb_l3len(msg), sizeof(s->si1_msg)));
1856
1857         LOGP(DRR, LOGL_INFO, "New SYSTEM INFORMATION 1\n");
1858
1859         /* Cell Channel Description */
1860         gsm48_decode_freq_list(&ms->support, s->freq,
1861                 si->cell_channel_description,
1862                 sizeof(si->cell_channel_description), 0xce, FREQ_TYPE_SERV);
1863         /* RACH Control Parameter */
1864         gsm48_decode_rach_ctl_param(s, &si->rach_control);
1865         /* SI 1 Rest Octets */
1866         if (payload_len)
1867                 gsm48_decode_si1_rest(s, si->rest_octets, payload_len);
1868
1869         s->si1 = 1;
1870
1871         return gsm48_send_sysinfo(ms, si->header.system_information);
1872 }
1873
1874 /* receive "SYSTEM INFORMATION 2" message (9.1.32) */
1875 static int gsm48_rr_rx_sysinfo2(struct osmocom_ms *ms, struct msgb *msg)
1876 {
1877         struct gsm48_system_information_type_2 *si = msgb_l3(msg);
1878         struct gsm48_sysinfo *s = ms->cellsel.si;
1879         int payload_len = msgb_l3len(msg) - sizeof(*si);
1880
1881         if (!s) {
1882                 LOGP(DRR, LOGL_INFO, "No cell selected, SYSTEM INFORMATION 2 "
1883                         "ignored\n");
1884                 return -EINVAL;
1885         }
1886
1887         if (payload_len < 0) {
1888                 LOGP(DRR, LOGL_NOTICE, "Short read of SYSTEM INFORMATION 2 "
1889                         "message.\n");
1890                 return -EINVAL;
1891         }
1892 //printf("len = %d\n", MIN(msgb_l3len(msg), sizeof(s->si2_msg)));
1893
1894         if (!memcmp(si, s->si2_msg, MIN(msgb_l3len(msg), sizeof(s->si2_msg))))
1895                 return 0;
1896         memcpy(s->si2_msg, si, MIN(msgb_l3len(msg), sizeof(s->si2_msg)));
1897
1898         LOGP(DRR, LOGL_INFO, "New SYSTEM INFORMATION 2\n");
1899
1900         /* Neighbor Cell Description */
1901         s->nb_ext_ind_si2 = (si->bcch_frequency_list[0] >> 6) & 1;
1902         s->nb_ba_ind_si2 = (si->bcch_frequency_list[0] >> 5) & 1;
1903         gsm48_decode_freq_list(&ms->support, s->freq, si->bcch_frequency_list,
1904                 sizeof(si->bcch_frequency_list), 0xce, FREQ_TYPE_NCELL_2);
1905         /* NCC Permitted */
1906         s->nb_ncc_permitted = si->ncc_permitted;
1907         /* RACH Control Parameter */
1908         gsm48_decode_rach_ctl_neigh(s, &si->rach_control);
1909
1910         s->si2 = 1;
1911
1912         return gsm48_send_sysinfo(ms, si->header.system_information);
1913 }
1914
1915 /* receive "SYSTEM INFORMATION 2bis" message (9.1.33) */
1916 static int gsm48_rr_rx_sysinfo2bis(struct osmocom_ms *ms, struct msgb *msg)
1917 {
1918         struct gsm48_system_information_type_2bis *si = msgb_l3(msg);
1919         struct gsm48_sysinfo *s = ms->cellsel.si;
1920         int payload_len = msgb_l3len(msg) - sizeof(*si);
1921
1922         if (!s) {
1923                 LOGP(DRR, LOGL_INFO, "No cell selected, SYSTEM INFORMATION 2bis"
1924                         " ignored\n");
1925                 return -EINVAL;
1926         }
1927
1928         if (payload_len < 0) {
1929                 LOGP(DRR, LOGL_NOTICE, "Short read of SYSTEM INFORMATION 2bis "
1930                         "message.\n");
1931                 return -EINVAL;
1932         }
1933
1934         if (!memcmp(si, s->si2b_msg, MIN(msgb_l3len(msg),
1935                         sizeof(s->si2b_msg))))
1936                 return 0;
1937         memcpy(s->si2b_msg, si, MIN(msgb_l3len(msg), sizeof(s->si2b_msg)));
1938
1939         LOGP(DRR, LOGL_INFO, "New SYSTEM INFORMATION 2bis\n");
1940
1941         /* Neighbor Cell Description */
1942         s->nb_ext_ind_si2bis = (si->bcch_frequency_list[0] >> 6) & 1;
1943         s->nb_ba_ind_si2bis = (si->bcch_frequency_list[0] >> 5) & 1;
1944         gsm48_decode_freq_list(&ms->support, s->freq,
1945                 si->bcch_frequency_list,
1946                 sizeof(si->bcch_frequency_list), 0x8e,
1947                 FREQ_TYPE_NCELL_2bis);
1948         /* RACH Control Parameter */
1949         gsm48_decode_rach_ctl_neigh(s, &si->rach_control);
1950
1951         s->si2bis = 1;
1952
1953         return gsm48_send_sysinfo(ms, si->header.system_information);
1954 }
1955
1956 /* receive "SYSTEM INFORMATION 2ter" message (9.1.34) */
1957 static int gsm48_rr_rx_sysinfo2ter(struct osmocom_ms *ms, struct msgb *msg)
1958 {
1959         struct gsm48_system_information_type_2ter *si = msgb_l3(msg);
1960         struct gsm48_sysinfo *s = ms->cellsel.si;
1961         int payload_len = msgb_l3len(msg) - sizeof(*si);
1962
1963         if (!s) {
1964                 LOGP(DRR, LOGL_INFO, "No cell selected, SYSTEM INFORMATION 2ter"
1965                         " ignored\n");
1966                 return -EINVAL;
1967         }
1968
1969         if (payload_len < 0) {
1970                 LOGP(DRR, LOGL_NOTICE, "Short read of SYSTEM INFORMATION 2ter "
1971                         "message.\n");
1972                 return -EINVAL;
1973         }
1974
1975         if (!memcmp(si, s->si2t_msg, MIN(msgb_l3len(msg),
1976                         sizeof(s->si2t_msg))))
1977                 return 0;
1978         memcpy(s->si2t_msg, si, MIN(msgb_l3len(msg), sizeof(s->si2t_msg)));
1979
1980         LOGP(DRR, LOGL_INFO, "New SYSTEM INFORMATION 2ter\n");
1981
1982         /* Neighbor Cell Description 2 */
1983         s->nb_multi_rep_si2ter = (si->ext_bcch_frequency_list[0] >> 6) & 3;
1984         gsm48_decode_freq_list(&ms->support, s->freq,
1985                 si->ext_bcch_frequency_list,
1986                 sizeof(si->ext_bcch_frequency_list), 0x8e,
1987                 FREQ_TYPE_NCELL_2ter);
1988
1989         s->si2ter = 1;
1990
1991         return gsm48_send_sysinfo(ms, si->header.system_information);
1992 }
1993
1994 /* receive "SYSTEM INFORMATION 3" message (9.1.35) */
1995 static int gsm48_rr_rx_sysinfo3(struct osmocom_ms *ms, struct msgb *msg)
1996 {
1997         struct gsm48_system_information_type_3 *si = msgb_l3(msg);
1998         struct gsm48_sysinfo *s = ms->cellsel.si;
1999         int payload_len = msgb_l3len(msg) - sizeof(*si);
2000
2001         if (!s) {
2002                 LOGP(DRR, LOGL_INFO, "No cell selected, SYSTEM INFORMATION 3 "
2003                         "ignored\n");
2004                 return -EINVAL;
2005         }
2006
2007         if (payload_len < 0) {
2008                 LOGP(DRR, LOGL_NOTICE, "Short read of SYSTEM INFORMATION 3 "
2009                         "message.\n");
2010                 return -EINVAL;
2011         }
2012
2013         if (!memcmp(si, s->si3_msg, MIN(msgb_l3len(msg), sizeof(s->si3_msg))))
2014                 return 0;
2015         memcpy(s->si3_msg, si, MIN(msgb_l3len(msg), sizeof(s->si3_msg)));
2016
2017         /* Cell Identity */
2018         s->cell_id = ntohs(si->cell_identity);
2019         /* LAI */
2020         gsm48_decode_lai(&si->lai, &s->mcc, &s->mnc, &s->lac);
2021         /* Control Channel Description */
2022         gsm48_decode_ccd(s, &si->control_channel_desc);
2023         /* Cell Options (BCCH) */
2024         gsm48_decode_cellopt_bcch(s, &si->cell_options);
2025         /* Cell Selection Parameters */
2026         gsm48_decode_cell_sel_param(s, &si->cell_sel_par);
2027         /* RACH Control Parameter */
2028         gsm48_decode_rach_ctl_param(s, &si->rach_control);
2029         /* SI 3 Rest Octets */
2030         if (payload_len >= 4)
2031                 gsm48_decode_si3_rest(s, si->rest_octets, payload_len);
2032
2033         LOGP(DRR, LOGL_INFO, "New SYSTEM INFORMATION 3 (mcc %s mnc %s "
2034                 "lac 0x%04x)\n", gsm_print_mcc(s->mcc),
2035                 gsm_print_mnc(s->mnc), s->lac);
2036
2037         s->si3 = 1;
2038
2039         return gsm48_send_sysinfo(ms, si->header.system_information);
2040 }
2041
2042 /* receive "SYSTEM INFORMATION 4" message (9.1.36) */
2043 static int gsm48_rr_rx_sysinfo4(struct osmocom_ms *ms, struct msgb *msg)
2044 {
2045         /* NOTE: pseudo length is not in this structure, so we skip */
2046         struct gsm48_system_information_type_4 *si = msgb_l3(msg);
2047         struct gsm48_sysinfo *s = ms->cellsel.si;
2048         int payload_len = msgb_l3len(msg) - sizeof(*si);
2049         uint8_t *data = si->data;
2050         struct gsm48_chan_desc *cd;
2051
2052         if (!s) {
2053                 LOGP(DRR, LOGL_INFO, "No cell selected, SYSTEM INFORMATION 4 "
2054                         "ignored\n");
2055                 return -EINVAL;
2056         }
2057
2058         if (payload_len < 0) {
2059                 short_read:
2060                 LOGP(DRR, LOGL_NOTICE, "Short read of SYSTEM INFORMATION 4 "
2061                         "message.\n");
2062                 return -EINVAL;
2063         }
2064
2065         if (!memcmp(si, s->si4_msg, MIN(msgb_l3len(msg), sizeof(s->si4_msg))))
2066                 return 0;
2067         memcpy(s->si4_msg, si, MIN(msgb_l3len(msg), sizeof(s->si4_msg)));
2068
2069         /* LAI */
2070         gsm48_decode_lai(&si->lai, &s->mcc, &s->mnc, &s->lac);
2071         /* Cell Selection Parameters */
2072         gsm48_decode_cell_sel_param(s, &si->cell_sel_par);
2073         /* RACH Control Parameter */
2074         gsm48_decode_rach_ctl_param(s, &si->rach_control);
2075         /* CBCH Channel Description */
2076         if (payload_len >= 1 && data[0] == GSM48_IE_CBCH_CHAN_DESC) {
2077                 if (payload_len < 4)
2078                         goto short_read;
2079                 cd = (struct gsm48_chan_desc *) (data + 1);
2080                 if (cd->h0.h) {
2081                         s->h = 1;
2082                         gsm48_decode_chan_h1(cd, &s->tsc, &s->maio, &s->hsn);
2083                 } else {
2084                         s->h = 0;
2085                         gsm48_decode_chan_h0(cd, &s->tsc, &s->arfcn);
2086                 }
2087                 payload_len -= 4;
2088                 data += 4;
2089         }
2090         /* CBCH Mobile Allocation */
2091         if (payload_len >= 1 && data[0] == GSM48_IE_CBCH_MOB_AL) {
2092                 if (payload_len < 1 || payload_len < 2 + data[1])
2093                         goto short_read;
2094                 gsm48_decode_mobile_alloc(s, data + 2, si->data[1]);
2095                 payload_len -= 2 + data[1];
2096                 data += 2 + data[1];
2097         }
2098         /* SI 4 Rest Octets */
2099         if (payload_len > 0)
2100                 gsm48_decode_si4_rest(s, data, payload_len);
2101
2102         LOGP(DRR, LOGL_INFO, "New SYSTEM INFORMATION 4 (mcc %s mnc %s "
2103                 "lac 0x%04x)\n", gsm_print_mcc(s->mcc),
2104                 gsm_print_mnc(s->mnc), s->lac);
2105
2106         s->si4 = 1;
2107
2108         return gsm48_send_sysinfo(ms, si->header.system_information);
2109 }
2110
2111 /* receive "SYSTEM INFORMATION 5" message (9.1.37) */
2112 static int gsm48_rr_rx_sysinfo5(struct osmocom_ms *ms, struct msgb *msg)
2113 {
2114         /* NOTE: pseudo length is not in this structure, so we skip */
2115         struct gsm48_system_information_type_5 *si = msgb_l3(msg) + 1;
2116         struct gsm48_sysinfo *s = ms->cellsel.si;
2117         int payload_len = msgb_l3len(msg) - sizeof(*si) - 1;
2118
2119         if (!s) {
2120                 LOGP(DRR, LOGL_INFO, "No cell selected, SYSTEM INFORMATION 5 "
2121                         "ignored\n");
2122                 return -EINVAL;
2123         }
2124
2125         if (payload_len < 0) {
2126                 LOGP(DRR, LOGL_NOTICE, "Short read of SYSTEM INFORMATION 5 "
2127                         "message.\n");
2128                 return -EINVAL;
2129         }
2130
2131         if (!memcmp(si, s->si5_msg, MIN(msgb_l3len(msg), sizeof(s->si5_msg))))
2132                 return 0;
2133         memcpy(s->si5_msg, si, MIN(msgb_l3len(msg), sizeof(s->si5_msg)));
2134
2135         LOGP(DRR, LOGL_INFO, "New SYSTEM INFORMATION 5\n");
2136
2137         /* Neighbor Cell Description */
2138         s->nb_ext_ind_si5 = (si->bcch_frequency_list[0] >> 6) & 1;
2139         s->nb_ba_ind_si5 = (si->bcch_frequency_list[0] >> 5) & 1;
2140         gsm48_decode_freq_list(&ms->support, s->freq, si->bcch_frequency_list,
2141                 sizeof(si->bcch_frequency_list), 0xce, FREQ_TYPE_REP_5);
2142
2143         s->si5 = 1;
2144
2145         return gsm48_send_sysinfo(ms, si->system_information);
2146 }
2147
2148 /* receive "SYSTEM INFORMATION 5bis" message (9.1.38) */
2149 static int gsm48_rr_rx_sysinfo5bis(struct osmocom_ms *ms, struct msgb *msg)
2150 {
2151         /* NOTE: pseudo length is not in this structure, so we skip */
2152         struct gsm48_system_information_type_5bis *si = msgb_l3(msg) + 1;
2153         struct gsm48_sysinfo *s = ms->cellsel.si;
2154         int payload_len = msgb_l3len(msg) - sizeof(*si) - 1;
2155
2156         if (!s) {
2157                 LOGP(DRR, LOGL_INFO, "No cell selected, SYSTEM INFORMATION 5bis"
2158                         " ignored\n");
2159                 return -EINVAL;
2160         }
2161
2162         if (payload_len < 0) {
2163                 LOGP(DRR, LOGL_NOTICE, "Short read of SYSTEM INFORMATION 5bis "
2164                         "message.\n");
2165                 return -EINVAL;
2166         }
2167
2168         LOGP(DRR, LOGL_INFO, "New SYSTEM INFORMATION 5bis\n");
2169
2170         if (!memcmp(si, s->si5b_msg, MIN(msgb_l3len(msg),
2171                         sizeof(s->si5b_msg))))
2172                 return 0;
2173         memcpy(s->si5b_msg, si, MIN(msgb_l3len(msg), sizeof(s->si5b_msg)));
2174
2175         /* Neighbor Cell Description */
2176         s->nb_ext_ind_si5bis = (si->bcch_frequency_list[0] >> 6) & 1;
2177         s->nb_ba_ind_si5bis = (si->bcch_frequency_list[0] >> 5) & 1;
2178         gsm48_decode_freq_list(&ms->support, s->freq, si->bcch_frequency_list,
2179                 sizeof(si->bcch_frequency_list), 0xce, FREQ_TYPE_REP_5bis);
2180
2181         s->si5bis = 1;
2182
2183         return gsm48_send_sysinfo(ms, si->system_information);
2184 }
2185
2186 /* receive "SYSTEM INFORMATION 5ter" message (9.1.39) */
2187 static int gsm48_rr_rx_sysinfo5ter(struct osmocom_ms *ms, struct msgb *msg)
2188 {
2189         /* NOTE: pseudo length is not in this structure, so we skip */
2190         struct gsm48_system_information_type_5ter *si = msgb_l3(msg) + 1;
2191         struct gsm48_sysinfo *s = ms->cellsel.si;
2192         int payload_len = msgb_l3len(msg) - sizeof(*si) - 1;
2193
2194         if (!s) {
2195                 LOGP(DRR, LOGL_INFO, "No cell selected, SYSTEM INFORMATION 5ter"
2196                         " ignored\n");
2197                 return -EINVAL;
2198         }
2199
2200         if (payload_len < 0) {
2201                 LOGP(DRR, LOGL_NOTICE, "Short read of SYSTEM INFORMATION 5ter "
2202                         "message.\n");
2203                 return -EINVAL;
2204         }
2205
2206         LOGP(DRR, LOGL_INFO, "New SYSTEM INFORMATION 5ter\n");
2207
2208         if (!memcmp(si, s->si5t_msg, MIN(msgb_l3len(msg),
2209                         sizeof(s->si5t_msg))))
2210                 return 0;
2211         memcpy(s->si5t_msg, si, MIN(msgb_l3len(msg), sizeof(s->si5t_msg)));
2212
2213         /* Neighbor Cell Description */
2214         gsm48_decode_freq_list(&ms->support, s->freq, si->bcch_frequency_list,
2215                 sizeof(si->bcch_frequency_list), 0xce, FREQ_TYPE_REP_5ter);
2216
2217         s->si5ter = 1;
2218
2219         return gsm48_send_sysinfo(ms, si->system_information);
2220 }
2221
2222 /* receive "SYSTEM INFORMATION 6" message (9.1.39) */
2223 static int gsm48_rr_rx_sysinfo6(struct osmocom_ms *ms, struct msgb *msg)
2224 {
2225         /* NOTE: pseudo length is not in this structure, so we skip */
2226         struct gsm48_system_information_type_6 *si = msgb_l3(msg) + 1;
2227         struct gsm48_sysinfo *s = ms->cellsel.si;
2228         int payload_len = msgb_l3len(msg) - sizeof(*si) - 1;
2229
2230         if (!s) {
2231                 LOGP(DRR, LOGL_INFO, "No cell selected, SYSTEM INFORMATION 6 "
2232                         "ignored\n");
2233                 return -EINVAL;
2234         }
2235
2236         if (payload_len < 0) {
2237                 LOGP(DRR, LOGL_NOTICE, "Short read of SYSTEM INFORMATION 6 "
2238                         "message.\n");
2239                 return -EINVAL;
2240         }
2241
2242         if (!memcmp(si, s->si6_msg, MIN(msgb_l3len(msg), sizeof(s->si6_msg))))
2243                 return 0;
2244         memcpy(s->si6_msg, si, MIN(msgb_l3len(msg), sizeof(s->si6_msg)));
2245
2246         /* Cell Identity */
2247         if (s->si6 && s->cell_id != ntohs(si->cell_identity))
2248                 LOGP(DRR, LOGL_INFO, "Cell ID on SI 6 differs from previous "
2249                         "read.\n");
2250         s->cell_id = ntohs(si->cell_identity);
2251         /* LAI */
2252         gsm48_decode_lai(&si->lai, &s->mcc, &s->mnc, &s->lac);
2253         /* Cell Options (SACCH) */
2254         gsm48_decode_cellopt_sacch(s, &si->cell_options);
2255         /* NCC Permitted */
2256         s->nb_ncc_permitted = si->ncc_permitted;
2257         /* SI 6 Rest Octets */
2258         if (payload_len >= 4)
2259                 gsm48_decode_si6_rest(s, si->rest_octets, payload_len);
2260
2261         LOGP(DRR, LOGL_INFO, "New SYSTEM INFORMATION 6 (mcc %s mnc %s "
2262                 "lac 0x%04x)\n", gsm_print_mcc(s->mcc),
2263                 gsm_print_mnc(s->mnc), s->lac);
2264
2265         s->si6 = 1;
2266
2267         return gsm48_send_sysinfo(ms, si->system_information);
2268 }
2269
2270 /*
2271  * paging
2272  */
2273
2274 /* paging channel request */
2275 static int gsm48_rr_chan2cause[4] = {
2276         RR_EST_CAUSE_ANS_PAG_ANY,
2277         RR_EST_CAUSE_ANS_PAG_SDCCH,
2278         RR_EST_CAUSE_ANS_PAG_TCH_F,
2279         RR_EST_CAUSE_ANS_PAG_TCH_ANY
2280 };
2281
2282 /* given LV of mobile identity is checked agains ms */
2283 static int gsm_match_mi(struct osmocom_ms *ms, uint8_t *mi)
2284 {
2285         char imsi[16];
2286         uint32_t tmsi;
2287         uint8_t mi_type;
2288
2289         if (mi[0] < 1)
2290                 return 0;
2291         mi_type = mi[1] & GSM_MI_TYPE_MASK;
2292         switch (mi_type) {
2293         case GSM_MI_TYPE_TMSI:
2294                 if (mi[0] < 5)
2295                         return 0;
2296                 memcpy(&tmsi, mi+2, 4);
2297                 if (ms->subscr.tmsi == ntohl(tmsi)
2298                  && ms->subscr.tmsi_valid) {
2299                         LOGP(DPAG, LOGL_INFO, "TMSI %08x matches\n",
2300                                 ntohl(tmsi));
2301
2302                         return 1;
2303                 } else
2304                         LOGP(DPAG, LOGL_INFO, "TMSI %08x (not for us)\n",
2305                                 ntohl(tmsi));
2306                 break;
2307         case GSM_MI_TYPE_IMSI:
2308                 gsm48_mi_to_string(imsi, sizeof(imsi), mi + 1, mi[0]);
2309                 if (!strcmp(imsi, ms->subscr.imsi)) {
2310                         LOGP(DPAG, LOGL_INFO, "IMSI %s matches\n", imsi);
2311
2312                         return 1;
2313                 } else
2314                         LOGP(DPAG, LOGL_INFO, "IMSI %s (not for us)\n", imsi);
2315                 break;
2316         default:
2317                 LOGP(DPAG, LOGL_NOTICE, "Paging with unsupported MI type %d.\n",
2318                         mi_type);
2319         }
2320
2321         return 0;
2322 }
2323
2324 /* 9.1.22 PAGING REQUEST 1 message received */
2325 static int gsm48_rr_rx_pag_req_1(struct osmocom_ms *ms, struct msgb *msg)
2326 {
2327         struct gsm48_rrlayer *rr = &ms->rrlayer;
2328         struct gsm322_cellsel *cs = &ms->cellsel;
2329         struct gsm48_paging1 *pa = msgb_l3(msg);
2330         int payload_len = msgb_l3len(msg) - sizeof(*pa);
2331         int chan_1, chan_2;
2332         uint8_t *mi;
2333
2334         /* empty paging request */
2335         if (payload_len >= 2 && (pa->data[1] & GSM_MI_TYPE_MASK) == 0)
2336                 return 0;
2337
2338         /* 3.3.1.1.2: ignore paging while not camping on a cell */
2339         if (rr->state != GSM48_RR_ST_IDLE || !cs->selected
2340          || (cs->state != GSM322_C3_CAMPED_NORMALLY
2341           && cs->state != GSM322_C7_CAMPED_ANY_CELL)) {
2342                 LOGP(DRR, LOGL_INFO, "PAGING ignored, we are not camping.\n");
2343
2344                 return 0;
2345         }
2346         LOGP(DPAG, LOGL_INFO, "PAGING REQUEST 1\n");
2347
2348         if (payload_len < 2) {
2349                 short_read:
2350                 LOGP(DRR, LOGL_NOTICE, "Short read of PAGING REQUEST 1 "
2351                         "message.\n");
2352
2353                 return -EINVAL;
2354         }
2355
2356         /* channel needed */
2357         chan_1 = pa->cneed1;
2358         chan_2 = pa->cneed2;
2359         /* first MI */
2360         mi = pa->data;
2361         if (payload_len < mi[0] + 1)
2362                 goto short_read;
2363         if (gsm_match_mi(ms, mi) > 0)
2364                 return gsm48_rr_chan_req(ms, gsm48_rr_chan2cause[chan_1], 1);
2365         /* second MI */
2366         payload_len -= mi[0] + 1;
2367         mi = pa->data + mi[0] + 1;
2368         if (payload_len < 2)
2369                 return 0;
2370         if (mi[0] != GSM48_IE_MOBILE_ID)
2371                 return 0;
2372         if (payload_len < mi[1] + 2)
2373                 goto short_read;
2374         if (gsm_match_mi(ms, mi + 1) > 0)
2375                 return gsm48_rr_chan_req(ms, gsm48_rr_chan2cause[chan_2], 1);
2376
2377         return 0;
2378 }
2379
2380 /* 9.1.23 PAGING REQUEST 2 message received */
2381 static int gsm48_rr_rx_pag_req_2(struct osmocom_ms *ms, struct msgb *msg)
2382 {
2383         struct gsm48_rrlayer *rr = &ms->rrlayer;
2384         struct gsm322_cellsel *cs = &ms->cellsel;
2385         struct gsm48_paging2 *pa = msgb_l3(msg);
2386         int payload_len = msgb_l3len(msg) - sizeof(*pa);
2387         uint8_t *mi;
2388         int chan_1, chan_2, chan_3;
2389
2390         /* 3.3.1.1.2: ignore paging while not camping on a cell */
2391         if (rr->state != GSM48_RR_ST_IDLE || !cs->selected
2392          || (cs->state != GSM322_C3_CAMPED_NORMALLY
2393           && cs->state != GSM322_C7_CAMPED_ANY_CELL)) {
2394                 LOGP(DRR, LOGL_INFO, "PAGING ignored, we are not camping.\n");
2395
2396                 return 0;
2397         }
2398         LOGP(DPAG, LOGL_INFO, "PAGING REQUEST 2\n");
2399
2400         if (payload_len < 0) {
2401                 short_read:
2402                 LOGP(DRR, LOGL_NOTICE, "Short read of PAGING REQUEST 2 "
2403                         "message .\n");
2404
2405                 return -EINVAL;
2406         }
2407
2408         /* channel needed */
2409         chan_1 = pa->cneed1;
2410         chan_2 = pa->cneed2;
2411         /* first MI */
2412         if (ms->subscr.tmsi == ntohl(pa->tmsi1)
2413          && ms->subscr.tmsi_valid) {
2414                 LOGP(DPAG, LOGL_INFO, "TMSI %08x matches\n", ntohl(pa->tmsi1));
2415                 return gsm48_rr_chan_req(ms, gsm48_rr_chan2cause[chan_1], 1);
2416         } else
2417                 LOGP(DPAG, LOGL_INFO, "TMSI %08x (not for us)\n",
2418                         ntohl(pa->tmsi1));
2419         /* second MI */
2420         if (ms->subscr.tmsi == ntohl(pa->tmsi2)
2421          && ms->subscr.tmsi_valid) {
2422                 LOGP(DPAG, LOGL_INFO, "TMSI %08x matches\n", ntohl(pa->tmsi2));
2423                 return gsm48_rr_chan_req(ms, gsm48_rr_chan2cause[chan_2], 1);
2424         } else
2425                 LOGP(DPAG, LOGL_INFO, "TMSI %08x (not for us)\n",
2426                         ntohl(pa->tmsi2));
2427         /* third MI */
2428         mi = pa->data;
2429         if (payload_len < 2)
2430                 return 0;
2431         if (mi[0] != GSM48_IE_MOBILE_ID)
2432                 return 0;
2433         if (payload_len < mi[1] + 2 + 1) /* must include "channel needed" */
2434                 goto short_read;
2435         chan_3 = mi[mi[1] + 2] & 0x03; /* channel needed */
2436         if (gsm_match_mi(ms, mi + 1) > 0)
2437                 return gsm48_rr_chan_req(ms, gsm48_rr_chan2cause[chan_3], 1);
2438
2439         return 0;
2440 }
2441
2442 /* 9.1.24 PAGING REQUEST 3 message received */
2443 static int gsm48_rr_rx_pag_req_3(struct osmocom_ms *ms, struct msgb *msg)
2444 {
2445         struct gsm48_rrlayer *rr = &ms->rrlayer;
2446         struct gsm322_cellsel *cs = &ms->cellsel;
2447         struct gsm48_paging3 *pa = msgb_l3(msg);
2448         int payload_len = msgb_l3len(msg) - sizeof(*pa);
2449         int chan_1, chan_2, chan_3, chan_4;
2450
2451         /* 3.3.1.1.2: ignore paging while not camping on a cell */
2452         if (rr->state != GSM48_RR_ST_IDLE || !cs->selected
2453          || (cs->state != GSM322_C3_CAMPED_NORMALLY
2454           && cs->state != GSM322_C7_CAMPED_ANY_CELL)) {
2455                 LOGP(DRR, LOGL_INFO, "PAGING ignored, we are not camping.\n");
2456
2457                 return 0;
2458         }
2459         LOGP(DPAG, LOGL_INFO, "PAGING REQUEST 3\n");
2460
2461         if (payload_len < 0) { /* must include "channel needed", part of *pa */
2462                 LOGP(DRR, LOGL_NOTICE, "Short read of PAGING REQUEST 3 "
2463                         "message .\n");
2464
2465                 return -EINVAL;
2466         }
2467
2468         /* channel needed */
2469         chan_1 = pa->cneed1;
2470         chan_2 = pa->cneed2;
2471         chan_3 = pa->cneed3;
2472         chan_4 = pa->cneed4;
2473         /* first MI */
2474         if (ms->subscr.tmsi == ntohl(pa->tmsi1)
2475          && ms->subscr.tmsi_valid) {
2476                 LOGP(DPAG, LOGL_INFO, "TMSI %08x matches\n", ntohl(pa->tmsi1));
2477                 return gsm48_rr_chan_req(ms, gsm48_rr_chan2cause[chan_1], 1);
2478         } else
2479                 LOGP(DPAG, LOGL_INFO, "TMSI %08x (not for us)\n",
2480                         ntohl(pa->tmsi1));
2481         /* second MI */
2482         if (ms->subscr.tmsi == ntohl(pa->tmsi2)
2483          && ms->subscr.tmsi_valid) {
2484                 LOGP(DPAG, LOGL_INFO, "TMSI %08x matches\n", ntohl(pa->tmsi2));
2485                 return gsm48_rr_chan_req(ms, gsm48_rr_chan2cause[chan_2], 1);
2486         } else
2487                 LOGP(DPAG, LOGL_INFO, "TMSI %08x (not for us)\n",
2488                         ntohl(pa->tmsi2));
2489         /* thrid MI */
2490         if (ms->subscr.tmsi == ntohl(pa->tmsi3)
2491          && ms->subscr.tmsi_valid) {
2492                 LOGP(DPAG, LOGL_INFO, "TMSI %08x matches\n", ntohl(pa->tmsi3));
2493                 return gsm48_rr_chan_req(ms, gsm48_rr_chan2cause[chan_3], 1);
2494         } else
2495                 LOGP(DPAG, LOGL_INFO, "TMSI %08x (not for us)\n",
2496                         ntohl(pa->tmsi3));
2497         /* fourth MI */
2498         if (ms->subscr.tmsi == ntohl(pa->tmsi4)
2499          && ms->subscr.tmsi_valid) {
2500                 LOGP(DPAG, LOGL_INFO, "TMSI %08x matches\n", ntohl(pa->tmsi4));
2501                 return gsm48_rr_chan_req(ms, gsm48_rr_chan2cause[chan_4], 1);
2502         } else
2503                 LOGP(DPAG, LOGL_INFO, "TMSI %08x (not for us)\n",
2504                         ntohl(pa->tmsi4));
2505
2506         return 0;
2507 }
2508
2509 /*
2510  * (immediate) assignment
2511  */
2512
2513 /* match request reference agains request history */
2514 static int gsm48_match_ra(struct osmocom_ms *ms, struct gsm48_req_ref *ref)
2515 {
2516         struct gsm48_rrlayer *rr = &ms->rrlayer;
2517         int i;
2518         struct gsm_time tm;
2519         uint8_t ia_t1, ia_t2, ia_t3;
2520
2521         for (i = 0; i < 3; i++) {
2522                 /* filter confirmed RACH requests only */
2523                 if (rr->cr_hist[i].valid == 2
2524                  && ref->ra == rr->cr_hist[i].chan_req) {
2525                         ia_t1 = ref->t1;
2526                         ia_t2 = ref->t2;
2527                         ia_t3 = (ref->t3_high << 3) | ref->t3_low;
2528                         gsm_fn2gsmtime(&tm, rr->cr_hist[i].fn);
2529                         if (ia_t1 == (tm.t1 & 0x1f) && ia_t2 == tm.t2
2530                          && ia_t3 == tm.t3) {
2531                                 LOGP(DRR, LOGL_INFO, "request %02x matches "
2532                                         "(fn=%d,%d,%d)\n", ref->ra, ia_t1,
2533                                         ia_t2, ia_t3);
2534                                 return 1;
2535                         } else
2536                                 LOGP(DRR, LOGL_INFO, "request %02x matches "
2537                                         "but not frame number (IMM.ASS "
2538                                         "fn=%d,%d,%d != RACH fn=%d,%d,%d)\n",
2539                                         ref->ra, ia_t1, ia_t2, ia_t3,
2540                                         tm.t1 & 0x1f, tm.t2, tm.t3);
2541                 }
2542         }
2543
2544         return 0;
2545 }
2546
2547 /* 9.1.18 IMMEDIATE ASSIGNMENT is received */
2548 static int gsm48_rr_rx_imm_ass(struct osmocom_ms *ms, struct msgb *msg)
2549 {
2550         struct gsm48_rrlayer *rr = &ms->rrlayer;
2551         struct gsm48_imm_ass *ia = msgb_l3(msg);
2552         int ma_len = msgb_l3len(msg) - sizeof(*ia);
2553         uint8_t ch_type, ch_subch, ch_ts;
2554         struct gsm48_rr_cd cd;
2555         uint8_t *st, st_len;
2556
2557         memset(&cd, 0, sizeof(cd));
2558
2559         if (ma_len < 0 /* mobile allocation IE must be included */
2560          || ia->mob_alloc_len > ma_len) { /* short read of IE */
2561                 LOGP(DRR, LOGL_NOTICE, "Short read of IMMEDIATE ASSIGNMENT "
2562                         "message.\n");
2563                 return -EINVAL;
2564         }
2565         if (ia->mob_alloc_len > 8) {
2566                 LOGP(DRR, LOGL_NOTICE, "Moble allocation in IMMEDIATE "
2567                         "ASSIGNMENT too large.\n");
2568                 return -EINVAL;
2569         }
2570
2571         /* starting time */
2572         st_len = ma_len - ia->mob_alloc_len;
2573         st = ia->mob_alloc + ia->mob_alloc_len;
2574         if (st_len >= 3 && st[0] == GSM48_IE_START_TIME)
2575                 gsm48_decode_start_time(&cd, (struct gsm48_start_time *)(st+1));
2576
2577         /* decode channel description */
2578         LOGP(DRR, LOGL_INFO, "IMMEDIATE ASSIGNMENT:\n");
2579         cd.chan_nr = ia->chan_desc.chan_nr;
2580         rsl_dec_chan_nr(cd.chan_nr, &ch_type, &ch_subch, &ch_ts);
2581         if (ia->chan_desc.h0.h) {
2582                 cd.h = 1;
2583                 gsm48_decode_chan_h1(&ia->chan_desc, &cd.tsc, &cd.maio,
2584                         &cd.hsn);
2585                 LOGP(DRR, LOGL_INFO, " (ta %d/%dm ra 0x%02x chan_nr 0x%02x "
2586                         "MAIO %u HSN %u TS %u SS %u TSC %u)\n",
2587                         ia->timing_advance,
2588                         ia->timing_advance * GSM_TA_CM / 100,
2589                         ia->req_ref.ra, ia->chan_desc.chan_nr, cd.maio,
2590                         cd.hsn, ch_ts, ch_subch, cd.tsc);
2591         } else {
2592                 cd.h = 0;
2593                 gsm48_decode_chan_h0(&ia->chan_desc, &cd.tsc, &cd.arfcn);
2594                 LOGP(DRR, LOGL_INFO, " (ta %d/%dm ra 0x%02x chan_nr 0x%02x "
2595                         "ARFCN %u TS %u SS %u TSC %u)\n",
2596                         ia->timing_advance,
2597                         ia->timing_advance * GSM_TA_CM / 100,
2598                         ia->req_ref.ra, ia->chan_desc.chan_nr, cd.arfcn,
2599                         ch_ts, ch_subch, cd.tsc);
2600         }
2601
2602         /* 3.3.1.1.2: ignore assignment while idle */
2603         if (rr->state != GSM48_RR_ST_CONN_PEND || !rr->wait_assign) {
2604                 LOGP(DRR, LOGL_INFO, "Not for us, no request.\n");
2605                 return 0;
2606         }
2607
2608         /* request ref */
2609         if (gsm48_match_ra(ms, &ia->req_ref)) {
2610                 /* channel description */
2611                 memcpy(&rr->cd_now, &cd, sizeof(rr->cd_now));
2612                 /* timing advance */
2613                 rr->cd_now.ta = ia->timing_advance;
2614                 /* mobile allocation */
2615                 memcpy(&rr->cd_now.mob_alloc_lv, &ia->mob_alloc_len,
2616                         ia->mob_alloc_len + 1);
2617                 rr->wait_assign = 0;
2618                 return gsm48_rr_dl_est(ms);
2619         }
2620         LOGP(DRR, LOGL_INFO, "Request, but not for us.\n");
2621
2622         return 0;
2623 }
2624
2625 /* 9.1.19 IMMEDIATE ASSIGNMENT EXTENDED is received */
2626 static int gsm48_rr_rx_imm_ass_ext(struct osmocom_ms *ms, struct msgb *msg)
2627 {
2628         struct gsm48_rrlayer *rr = &ms->rrlayer;
2629         struct gsm48_imm_ass_ext *ia = msgb_l3(msg);
2630         int ma_len = msgb_l3len(msg) - sizeof(*ia);
2631         uint8_t ch_type, ch_subch, ch_ts;
2632         struct gsm48_rr_cd cd1, cd2;
2633         uint8_t *st, st_len;
2634
2635         memset(&cd1, 0, sizeof(cd1));
2636         memset(&cd2, 0, sizeof(cd2));
2637
2638         if (ma_len < 0 /* mobile allocation IE must be included */
2639          || ia->mob_alloc_len > ma_len) { /* short read of IE */
2640                 LOGP(DRR, LOGL_NOTICE, "Short read of IMMEDIATE ASSIGNMENT "
2641                         "EXTENDED message.\n");
2642                 return -EINVAL;
2643         }
2644         if (ia->mob_alloc_len > 4) {
2645                 LOGP(DRR, LOGL_NOTICE, "Moble allocation in IMMEDIATE "
2646                         "ASSIGNMENT EXTENDED too large.\n");
2647                 return -EINVAL;
2648         }
2649
2650         /* starting time */
2651         st_len = ma_len - ia->mob_alloc_len;
2652         st = ia->mob_alloc + ia->mob_alloc_len;
2653         if (st_len >= 3 && st[0] == GSM48_IE_START_TIME) {
2654                 gsm48_decode_start_time(&cd1,
2655                         (struct gsm48_start_time *)(st+1));
2656                 memcpy(&cd2, &cd1, sizeof(cd2));
2657         }
2658
2659         /* decode channel description */
2660         LOGP(DRR, LOGL_INFO, "IMMEDIATE ASSIGNMENT EXTENDED:\n");
2661         cd2.chan_nr = ia->chan_desc1.chan_nr;
2662         rsl_dec_chan_nr(cd1.chan_nr, &ch_type, &ch_subch, &ch_ts);
2663         if (ia->chan_desc1.h0.h) {
2664                 cd1.h = 1;
2665                 gsm48_decode_chan_h1(&ia->chan_desc1, &cd1.tsc, &cd1.maio,
2666                         &cd1.hsn);
2667                 LOGP(DRR, LOGL_INFO, " assignment 1 (ta %d/%dm ra 0x%02x "
2668                         "chan_nr 0x%02x MAIO %u HSN %u TS %u SS %u TSC %u)\n",
2669                         ia->timing_advance1,
2670                         ia->timing_advance1 * GSM_TA_CM / 100,
2671                         ia->req_ref1.ra, ia->chan_desc1.chan_nr, cd1.maio,
2672                         cd1.hsn, ch_ts, ch_subch, cd1.tsc);
2673         } else {
2674                 cd1.h = 0;
2675                 gsm48_decode_chan_h0(&ia->chan_desc1, &cd1.tsc, &cd1.arfcn);
2676                 LOGP(DRR, LOGL_INFO, " assignment 1 (ta %d/%dm ra 0x%02x "
2677                         "chan_nr 0x%02x ARFCN %u TS %u SS %u TSC %u)\n",
2678                         ia->timing_advance1,
2679                         ia->timing_advance1 * GSM_TA_CM / 100,
2680                         ia->req_ref1.ra, ia->chan_desc1.chan_nr, cd1.arfcn,
2681                         ch_ts, ch_subch, cd1.tsc);
2682         }
2683         cd2.chan_nr = ia->chan_desc2.chan_nr;
2684         rsl_dec_chan_nr(cd2.chan_nr, &ch_type, &ch_subch, &ch_ts);
2685         if (ia->chan_desc2.h0.h) {
2686                 cd2.h = 1;
2687                 gsm48_decode_chan_h1(&ia->chan_desc2, &cd2.tsc, &cd2.maio,
2688                         &cd2.hsn);
2689                 LOGP(DRR, LOGL_INFO, " assignment 2 (ta %d/%dm ra 0x%02x "
2690                         "chan_nr 0x%02x MAIO %u HSN %u TS %u SS %u TSC %u)\n",
2691                         ia->timing_advance2,
2692                         ia->timing_advance2 * GSM_TA_CM / 100,
2693                         ia->req_ref2.ra, ia->chan_desc2.chan_nr, cd2.maio,
2694                         cd2.hsn, ch_ts, ch_subch, cd2.tsc);
2695         } else {
2696                 cd2.h = 0;
2697                 gsm48_decode_chan_h0(&ia->chan_desc2, &cd2.tsc, &cd2.arfcn);
2698                 LOGP(DRR, LOGL_INFO, " assignment 2 (ta %d/%dm ra 0x%02x "
2699                         "chan_nr 0x%02x ARFCN %u TS %u SS %u TSC %u)\n",
2700                         ia->timing_advance2,
2701                         ia->timing_advance2 * GSM_TA_CM / 100,
2702                         ia->req_ref2.ra, ia->chan_desc2.chan_nr, cd2.arfcn,
2703                         ch_ts, ch_subch, cd2.tsc);
2704         }
2705
2706         /* 3.3.1.1.2: ignore assignment while idle */
2707         if (rr->state != GSM48_RR_ST_CONN_PEND || !rr->wait_assign) {
2708                 LOGP(DRR, LOGL_INFO, "Not for us, no request.\n");
2709                 return 0;
2710         }
2711
2712         /* request ref 1 */
2713         if (gsm48_match_ra(ms, &ia->req_ref1)) {
2714                 /* channel description */
2715                 memcpy(&rr->cd_now, &cd1, sizeof(rr->cd_now));
2716                 /* timing advance */
2717                 rr->cd_now.ta = ia->timing_advance1;
2718                 /* mobile allocation */
2719                 memcpy(&rr->cd_now.mob_alloc_lv, &ia->mob_alloc_len,
2720                         ia->mob_alloc_len + 1);
2721                 rr->wait_assign = 0;
2722                 return gsm48_rr_dl_est(ms);
2723         }
2724         /* request ref 1 */
2725         if (gsm48_match_ra(ms, &ia->req_ref2)) {
2726                 /* channel description */
2727                 memcpy(&rr->cd_now, &cd2, sizeof(rr->cd_now));
2728                 /* timing advance */
2729                 rr->cd_now.ta = ia->timing_advance2;
2730                 /* mobile allocation */
2731                 memcpy(&rr->cd_now.mob_alloc_lv, &ia->mob_alloc_len,
2732                         ia->mob_alloc_len + 1);
2733                 rr->wait_assign = 0;
2734                 return gsm48_rr_dl_est(ms);
2735         }
2736         LOGP(DRR, LOGL_INFO, "Request, but not for us.\n");
2737
2738         return 0;
2739 }
2740
2741 /* 9.1.20 IMMEDIATE ASSIGNMENT REJECT is received */
2742 static int gsm48_rr_rx_imm_ass_rej(struct osmocom_ms *ms, struct msgb *msg)
2743 {
2744         struct gsm48_rrlayer *rr = &ms->rrlayer;
2745         struct gsm48_imm_ass_rej *ia = msgb_l3(msg);
2746         int payload_len = msgb_l3len(msg) - sizeof(*ia);
2747         int i;
2748         struct gsm48_req_ref *req_ref;
2749         uint8_t t3122_value;
2750
2751         /* 3.3.1.1.2: ignore assignment while idle */
2752         if (rr->state != GSM48_RR_ST_CONN_PEND || !rr->wait_assign)
2753                 return 0;
2754
2755         if (payload_len < 0) {
2756                 LOGP(DRR, LOGL_NOTICE, "Short read of IMMEDIATE ASSIGNMENT "
2757                         "REJECT message.\n");
2758                 return -EINVAL;
2759         }
2760
2761         for (i = 0; i < 4; i++) {
2762                 /* request reference */
2763                 req_ref = (struct gsm48_req_ref *)
2764                                 (((uint8_t *)&ia->req_ref1) + i * 4);
2765                 LOGP(DRR, LOGL_INFO, "IMMEDIATE ASSIGNMENT REJECT "
2766                         "(ref 0x%02x)\n", req_ref->ra);
2767                 if (gsm48_match_ra(ms, req_ref)) {
2768                         /* wait indication */
2769                         t3122_value = *(((uint8_t *)&ia->wait_ind1) + i * 4);
2770                         if (t3122_value)
2771                                 start_rr_t3122(rr, t3122_value, 0);
2772                         /* start timer 3126 if not already */
2773                         if (!bsc_timer_pending(&rr->t3126))
2774                                 start_rr_t3126(rr, 5, 0); /* TODO improve! */
2775                         /* stop assignmnet requests */
2776                         rr->n_chan_req = 0;
2777
2778                         /* wait until timer 3126 expires, then release
2779                          * or wait for channel assignment */
2780                         return 0;
2781                 }
2782         }
2783
2784         return 0;
2785 }
2786
2787 /* 9.1.1 ADDITIONAL ASSIGMENT is received  */
2788 static int gsm48_rr_rx_add_ass(struct osmocom_ms *ms, struct msgb *msg)
2789 {
2790         struct gsm48_hdr *gh = msgb_l3(msg);
2791         struct gsm48_add_ass *aa = (struct gsm48_add_ass *)gh->data;
2792         int payload_len = msgb_l3len(msg) - sizeof(*gh) - sizeof(*aa);
2793         struct tlv_parsed tp;
2794
2795         if (payload_len < 0) {
2796                 LOGP(DRR, LOGL_NOTICE, "Short read of ADDITIONAL ASSIGNMENT "
2797                         "message.\n");
2798                 return gsm48_rr_tx_rr_status(ms,
2799                         GSM48_RR_CAUSE_PROT_ERROR_UNSPC);
2800         }
2801         tlv_parse(&tp, &gsm48_rr_att_tlvdef, aa->data, payload_len, 0, 0);
2802
2803         return gsm48_rr_tx_rr_status(ms, GSM48_RR_CAUSE_PROT_ERROR_UNSPC);
2804 }
2805
2806 /*
2807  * measturement reports
2808  */
2809
2810 static int gsm48_rr_tx_meas_rep(struct osmocom_ms *ms)
2811 {
2812         struct gsm48_rrlayer *rr = &ms->rrlayer;
2813         struct gsm48_rr_meas *meas = &rr->meas;
2814         struct msgb *nmsg;
2815         struct gsm48_hdr *gh;
2816         struct gsm48_meas_res *mr;
2817
2818         nmsg = gsm48_l3_msgb_alloc();
2819         if (!nmsg)
2820                 return -ENOMEM;
2821         gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
2822         mr = (struct gsm48_meas_res *) msgb_put(nmsg, sizeof(*mr));
2823
2824         gh->proto_discr = GSM48_PDISC_RR;
2825         gh->msg_type = GSM48_MT_RR_MEAS_REP;
2826
2827         /* measurement results */
2828         mr->rxlev_full = meas->rxlev_full;
2829         mr->rxlev_sub = meas->rxlev_sub;
2830         mr->rxqual_full = meas->rxqual_full;
2831         mr->rxqual_sub = meas->rxqual_sub;
2832         mr->dtx_used = meas->dtx;
2833         mr->ba_used = meas->ba;
2834         mr->meas_valid = meas->meas_valid;
2835         if (meas->ncell_na) {
2836                 /* no results for serving cells */
2837                 mr->no_nc_n_hi = 1;
2838                 mr->no_nc_n_lo = 3;
2839         } else {
2840                 mr->no_nc_n_hi = meas->count >> 2;
2841                 mr->no_nc_n_lo = meas->count & 3;
2842         }
2843         mr->rxlev_nc1 = meas->rxlev_nc[0];
2844         mr->rxlev_nc2_hi = meas->rxlev_nc[1] >> 1;
2845         mr->rxlev_nc2_lo = meas->rxlev_nc[1] & 1;
2846         mr->rxlev_nc3_hi = meas->rxlev_nc[2] >> 2;
2847         mr->rxlev_nc3_lo = meas->rxlev_nc[2] & 3;
2848         mr->rxlev_nc4_hi = meas->rxlev_nc[3] >> 3;
2849         mr->rxlev_nc4_lo = meas->rxlev_nc[3] & 7;
2850         mr->rxlev_nc5_hi = meas->rxlev_nc[4] >> 4;
2851         mr->rxlev_nc5_lo = meas->rxlev_nc[4] & 15;
2852         mr->rxlev_nc6_hi = meas->rxlev_nc[5] >> 5;
2853         mr->rxlev_nc6_lo = meas->rxlev_nc[5] & 31;
2854         mr->bsic_nc1_hi = meas->bsic_nc[0] >> 3;
2855         mr->bsic_nc1_lo = meas->bsic_nc[0] & 7;
2856         mr->bsic_nc2_hi = meas->bsic_nc[1] >> 4;
2857         mr->bsic_nc2_lo = meas->bsic_nc[1] & 15;
2858         mr->bsic_nc3_hi = meas->bsic_nc[2] >> 5;
2859         mr->bsic_nc3_lo = meas->bsic_nc[2] & 31;
2860         mr->bsic_nc4 = meas->bsic_nc[3];
2861         mr->bsic_nc5 = meas->bsic_nc[4];
2862         mr->bsic_nc6 = meas->bsic_nc[5];
2863         mr->bcch_f_nc1 = meas->bcch_f_nc[0];
2864         mr->bcch_f_nc2 = meas->bcch_f_nc[1];
2865         mr->bcch_f_nc3 = meas->bcch_f_nc[2];
2866         mr->bcch_f_nc4 = meas->bcch_f_nc[3];
2867         mr->bcch_f_nc5_hi = meas->bcch_f_nc[4] >> 1;
2868         mr->bcch_f_nc5_lo = meas->bcch_f_nc[4] & 1;
2869         mr->bcch_f_nc6_hi = meas->bcch_f_nc[5] >> 2;
2870         mr->bcch_f_nc6_lo = meas->bcch_f_nc[5] & 3;
2871
2872         return gsm48_send_rsl(ms, RSL_MT_UNIT_DATA_REQ, nmsg);
2873 }
2874
2875 /*
2876  * link establishment and release
2877  */
2878
2879 /* process "Loss Of Signal" */
2880 int gsm48_rr_los(struct osmocom_ms *ms)
2881 {
2882         struct gsm48_rrlayer *rr = &ms->rrlayer;
2883         uint8_t *mode;
2884         struct msgb *nmsg;
2885         struct gsm48_rr_hdr *nrrh;
2886
2887         LOGP(DSUM, LOGL_INFO, "Radio link lost signal\n");
2888
2889         /* stop T3211 if running */
2890         stop_rr_t3110(rr);
2891
2892         switch(rr->state) {
2893         case GSM48_RR_ST_CONN_PEND:
2894                 LOGP(DRR, LOGL_INFO, "LOS during RACH request\n");
2895
2896                 /* stop pending RACH timer */
2897                 stop_rr_t3126(rr);
2898                 break;
2899         case GSM48_RR_ST_DEDICATED:
2900                 LOGP(DRR, LOGL_INFO, "LOS during dedicated mode, release "
2901                         "locally\n");
2902
2903                 new_rr_state(rr, GSM48_RR_ST_REL_PEND);
2904
2905                 /* release message */
2906                 rel_local:
2907                 nmsg = gsm48_l3_msgb_alloc();
2908                 if (!nmsg)
2909                         return -ENOMEM;
2910                 mode = msgb_put(nmsg, 2);
2911                 mode[0] = RSL_IE_RELEASE_MODE;
2912                 mode[1] = 1; /* local release */
2913                 /* start release */
2914                 return gsm48_send_rsl(ms, RSL_MT_REL_REQ, nmsg);
2915         case GSM48_RR_ST_REL_PEND:
2916                 LOGP(DRR, LOGL_INFO, "LOS during RR release procedure, release "
2917                         "locally\n");
2918
2919                 /* stop pending RACH timer */
2920                 stop_rr_t3110(rr);
2921
2922                 /* release locally */
2923                 goto rel_local;
2924         default:
2925                 /* this should not happen */
2926                 LOGP(DRR, LOGL_ERROR, "LOS in IDLE state, ignoring\n");
2927                 return -EINVAL;
2928         }
2929
2930         /* send inication to upper layer */
2931         nmsg = gsm48_rr_msgb_alloc(GSM48_RR_REL_IND);
2932         if (!nmsg)
2933                 return -ENOMEM;
2934         nrrh = (struct gsm48_rr_hdr *)nmsg->data;
2935         nrrh->cause = RR_REL_CAUSE_LOST_SIGNAL;
2936         gsm48_rr_upmsg(ms, nmsg);
2937
2938         /* return idle */
2939         new_rr_state(rr, GSM48_RR_ST_IDLE);
2940         return 0;
2941 }
2942
2943 /* activate link and send establish request */
2944 static int gsm48_rr_dl_est(struct osmocom_ms *ms)
2945 {
2946         struct gsm48_rrlayer *rr = &ms->rrlayer;
2947         struct gsm_subscriber *subscr = &ms->subscr;
2948         struct msgb *nmsg;
2949         struct gsm48_hdr *gh;
2950         struct gsm48_pag_rsp *pr;
2951         uint8_t mi[11];
2952         uint8_t ch_type, ch_subch, ch_ts;
2953
2954         /* 3.3.1.1.3.1 */
2955         stop_rr_t3126(rr);
2956
2957         /* flush pending RACH requests */
2958 #ifdef TODO
2959         rr->n_chan_req = 0; // just to be safe
2960         nmsg = msgb_alloc_headroom(20, 16, "RAND_FLUSH");
2961         if (!nmsg)
2962                 return -ENOMEM;
2963         gsm48_send_rsl(ms, RSL_MT_RAND_ACC_FLSH, msg);
2964 #else
2965         if (bsc_timer_pending(&rr->temp_rach_ti))
2966                 bsc_del_timer(&rr->temp_rach_ti);
2967 #endif
2968
2969         /* send DL_EST_REQ */
2970         if (rr->rr_est_msg) {
2971                 /* use queued message */
2972                 nmsg = rr->rr_est_msg;
2973                 rr->rr_est_msg = 0;
2974                 LOGP(DRR, LOGL_INFO, "sending establish message\n");
2975         } else {
2976                 /* create paging response */
2977                 nmsg = gsm48_l3_msgb_alloc();
2978                 if (!nmsg)
2979                         return -ENOMEM;
2980                 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
2981                 pr = (struct gsm48_pag_rsp *) msgb_put(nmsg, sizeof(*pr));
2982                 /* key sequence */
2983                 pr->key_seq = subscr->key_seq;
2984                 /* classmark 2 */
2985                 pr->cm2_len = sizeof(pr->cm2);
2986                 gsm48_rr_enc_cm2(ms, &pr->cm2);
2987                 /* mobile identity */
2988                 if (ms->subscr.tmsi_valid) {
2989                         gsm48_generate_mid_from_tmsi(mi, subscr->tmsi);
2990                         LOGP(DRR, LOGL_INFO, "sending paging response with "
2991                                 "TMSI\n");
2992                 } else if (subscr->imsi[0]) {
2993                         gsm48_generate_mid_from_imsi(mi, subscr->imsi);
2994                         LOGP(DRR, LOGL_INFO, "sending paging response with "
2995                                 "IMSI\n");
2996                 } else {
2997                         mi[1] = 1;
2998                         mi[2] = 0xf0 | GSM_MI_TYPE_NONE;
2999                         LOGP(DRR, LOGL_INFO, "sending paging response without "
3000                                 "TMSI/IMSI\n");
3001                 }
3002                 msgb_put(nmsg, 1 + mi[1]);
3003                 memcpy(pr->data, mi + 1, 1 + mi[1]);
3004         }
3005
3006         /* activate channel */
3007 #ifdef TODO
3008         RSL_MT_ to activate channel with all the cd_now informations
3009 #else
3010         if (rr->cd_now.h) {
3011                 printf("FIXME: Channel hopping not supported, exitting.\n");
3012                 exit(-ENOTSUP);
3013         }
3014         rsl_dec_chan_nr(rr->cd_now.chan_nr, &ch_type, &ch_subch, &ch_ts);
3015         if ((ch_type != RSL_CHAN_SDCCH8_ACCH
3016           && ch_type != RSL_CHAN_SDCCH4_ACCH) || ch_ts > 4) {
3017                 printf("Channel type %d, subch %d, ts %d not supported, "
3018                         "exitting.\n", ch_type, ch_subch, ch_ts);
3019                 exit(-ENOTSUP);
3020         }
3021         tx_ph_dm_est_req(ms, rr->cd_now.arfcn, rr->cd_now.chan_nr,
3022                          rr->cd_now.tsc);
3023 #endif
3024
3025         /* start establishmnet */
3026         return gsm48_send_rsl(ms, RSL_MT_EST_REQ, nmsg);
3027 }
3028
3029 /* the link is established */
3030 static int gsm48_rr_estab_cnf(struct osmocom_ms *ms, struct msgb *msg)
3031 {
3032         struct gsm48_rrlayer *rr = &ms->rrlayer;
3033         uint8_t *mode;
3034         struct msgb *nmsg;
3035
3036         /* if MM has releases before confirm, we start release */
3037         if (rr->state == GSM48_RR_ST_REL_PEND) {
3038                 LOGP(DRR, LOGL_INFO, "MM already released RR.\n");
3039                 /* release message */
3040                 nmsg = gsm48_l3_msgb_alloc();
3041                 if (!nmsg)
3042                         return -ENOMEM;
3043                 mode = msgb_put(nmsg, 2);
3044                 mode[0] = RSL_IE_RELEASE_MODE;
3045                 mode[1] = 0; /* normal release */
3046                 /* start release */
3047                 return gsm48_send_rsl(ms, RSL_MT_REL_REQ, nmsg);
3048         }
3049
3050         /* 3.3.1.1.4 */
3051         new_rr_state(rr, GSM48_RR_ST_DEDICATED);
3052
3053         /* send confirm to upper layer */
3054         nmsg = gsm48_rr_msgb_alloc(
3055                 (rr->rr_est_req) ? GSM48_RR_EST_CNF : GSM48_RR_EST_IND);
3056         if (!nmsg)
3057                 return -ENOMEM;
3058         return gsm48_rr_upmsg(ms, nmsg);
3059 }
3060
3061 /* the link is released in pending state (by l2) */
3062 static int gsm48_rr_rel_ind(struct osmocom_ms *ms, struct msgb *msg)
3063 {
3064         struct gsm48_rrlayer *rr = &ms->rrlayer;
3065         struct msgb *nmsg;
3066         struct gsm48_rr_hdr *nrrh;
3067
3068         LOGP(DSUM, LOGL_INFO, "Radio link is released\n");
3069
3070         /* send inication to upper layer */
3071         nmsg = gsm48_rr_msgb_alloc(GSM48_RR_REL_IND);
3072         if (!nmsg)
3073                 return -ENOMEM;
3074         nrrh = (struct gsm48_rr_hdr *)nmsg->data;
3075         nrrh->cause = RR_REL_CAUSE_NORMAL;
3076         gsm48_rr_upmsg(ms, nmsg);
3077
3078         /* start release timer, so UA will be transmitted */
3079         start_rr_t_rel_wait(rr, 1, 500000);
3080
3081         /* pending release */
3082         new_rr_state(rr, GSM48_RR_ST_REL_PEND);
3083
3084         return 0;
3085 }
3086
3087 /* 9.1.7 CHANNEL RELEASE is received  */
3088 static int gsm48_rr_rx_chan_rel(struct osmocom_ms *ms, struct msgb *msg)
3089 {
3090         struct gsm48_rrlayer *rr = &ms->rrlayer;
3091         struct gsm48_hdr *gh = msgb_l3(msg);
3092         struct gsm48_chan_rel *cr = (struct gsm48_chan_rel *)gh->data;
3093         int payload_len = msgb_l3len(msg) - sizeof(*gh) - sizeof(*cr);
3094         struct tlv_parsed tp;
3095         struct msgb *nmsg;
3096         uint8_t *mode;
3097
3098         if (payload_len < 0) {
3099                 LOGP(DRR, LOGL_NOTICE, "Short read of CHANNEL RELEASE "
3100                         "message.\n");
3101                 return gsm48_rr_tx_rr_status(ms,
3102                         GSM48_RR_CAUSE_PROT_ERROR_UNSPC);
3103         }
3104         tlv_parse(&tp, &gsm48_rr_att_tlvdef, cr->data, payload_len, 0, 0);
3105
3106         LOGP(DRR, LOGL_INFO, "channel release request with cause 0x%02x)\n",
3107                 cr->rr_cause);
3108
3109         /* BA range */
3110         if (TLVP_PRESENT(&tp, GSM48_IE_BA_RANGE)) {
3111                 gsm48_decode_ba_range(TLVP_VAL(&tp, GSM48_IE_BA_RANGE),
3112                         *(TLVP_VAL(&tp, GSM48_IE_BA_RANGE) - 1), rr->ba_range,
3113                         &rr->ba_ranges,
3114                         sizeof(rr->ba_range) / sizeof(rr->ba_range[0]));
3115                 /* NOTE: the ranges are kept until IDLE state is returned
3116                  * (see new_rr_state)
3117                  */
3118         }
3119
3120         new_rr_state(rr, GSM48_RR_ST_REL_PEND);
3121
3122         /* start T3110, so that two DISCs can be sent due to T200 timeout */
3123         start_rr_t3110(rr, 1, 500000);
3124
3125         /* disconnect the main signalling link */
3126         nmsg = gsm48_l3_msgb_alloc();
3127         if (!nmsg)
3128                 return -ENOMEM;
3129         mode = msgb_put(nmsg, 2);
3130         mode[0] = RSL_IE_RELEASE_MODE;
3131         mode[1] = 0; /* normal release */
3132         return gsm48_send_rsl(ms, RSL_MT_REL_REQ, nmsg);
3133 }
3134
3135 /*
3136  * assignment and handover
3137  */
3138
3139 /* 9.1.3 sending ASSIGNMENT COMPLETE */
3140 static int gsm48_rr_tx_ass_cpl(struct osmocom_ms *ms, uint8_t cause)
3141 {
3142         struct msgb *nmsg;
3143         struct gsm48_hdr *gh;
3144         struct gsm48_ass_cpl *ac;
3145
3146         LOGP(DRR, LOGL_INFO, "ASSIGNMENT COMPLETE (cause #%d)\n", cause);
3147
3148         nmsg = gsm48_l3_msgb_alloc();
3149         if (!nmsg)
3150                 return -ENOMEM;
3151         gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
3152         ac = (struct gsm48_ass_cpl *) msgb_put(nmsg, sizeof(*ac));
3153
3154         gh->proto_discr = GSM48_PDISC_RR;
3155         gh->msg_type = GSM48_MT_RR_ASS_COMPL;
3156
3157         /* RR_CAUSE */
3158         ac->rr_cause = cause;
3159
3160         return gsm48_send_rsl(ms, RSL_MT_DATA_REQ, nmsg);
3161 }
3162
3163 /* 9.1.4 sending ASSIGNMENT FAILURE */
3164 static int gsm48_rr_tx_ass_fail(struct osmocom_ms *ms, uint8_t cause)
3165 {
3166         struct msgb *nmsg;
3167         struct gsm48_hdr *gh;
3168         struct gsm48_ass_fail *af;
3169
3170         LOGP(DRR, LOGL_INFO, "ASSIGNMENT FAILURE (cause #%d)\n", cause);
3171
3172         nmsg = gsm48_l3_msgb_alloc();
3173         if (!nmsg)
3174                 return -ENOMEM;
3175         gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
3176         af = (struct gsm48_ass_fail *) msgb_put(nmsg, sizeof(*af));
3177
3178         gh->proto_discr = GSM48_PDISC_RR;
3179         gh->msg_type = GSM48_MT_RR_ASS_COMPL;
3180
3181         /* RR_CAUSE */
3182         af->rr_cause = cause;
3183
3184         return gsm48_send_rsl(ms, RSL_MT_DATA_REQ, nmsg);
3185 }
3186
3187 /* 9.1.2 ASSIGNMENT COMMAND is received */
3188 static int gsm48_rr_rx_ass_cmd(struct osmocom_ms *ms, struct msgb *msg)
3189 {
3190 //      struct gsm48_rrlayer *rr = &ms->rrlayer;
3191         struct gsm48_hdr *gh = msgb_l3(msg);
3192         struct gsm48_ass_cmd *ac = (struct gsm48_ass_cmd *)gh->data;
3193         int payload_len = msgb_l3len(msg) - sizeof(*gh) - sizeof(*ac);
3194         struct tlv_parsed tp;
3195         struct gsm48_rr_cd cd;
3196
3197         LOGP(DRR, LOGL_INFO, "ASSIGNMENT COMMAND\n");
3198
3199         memset(&cd, 0, sizeof(cd));
3200
3201         if (payload_len < 0) {
3202                 LOGP(DRR, LOGL_NOTICE, "Short read of ASSIGNMENT COMMAND message.\n");
3203                 return gsm48_rr_tx_rr_status(ms, GSM48_RR_CAUSE_PROT_ERROR_UNSPC);
3204         }
3205         tlv_parse(&tp, &gsm48_rr_att_tlvdef, ac->data, payload_len, 0, 0);
3206
3207 #if 0
3208         /* channel description */
3209         memcpy(&cd.chan_desc, &ac->chan_desc, sizeof(chan_desc));
3210         /* power command */
3211         cd.power_command = ac->power_command;
3212         /* frequency list, after timer */
3213         tlv_copy(&cd.fl, sizeof(fl_after), &tp, GSM48_IE_FRQLIST_AFTER);
3214         /* cell channel description */
3215         tlv_copy(&cd.ccd, sizeof(ccd), &tp, GSM48_IE_CELL_CH_DESC);
3216         /* multislot allocation */
3217         tlv_copy(&cd.multia, sizeof(ma), &tp, GSM48_IE_MSLOT_DESC);
3218         /* channel mode */
3219         tlv_copy(&cd.chanmode, sizeof(chanmode), &tp, GSM48_IE_CHANMODE_1);
3220         /* mobile allocation, after time */
3221         tlv_copy(&cd.moba_after, sizeof(moba_after), &tp, GSM48_IE_MOB_AL_AFTER);
3222         /* starting time */
3223         tlv_copy(&cd.start, sizeof(start), &tp, GSM_IE_START_TIME);
3224         /* frequency list, before time */
3225         tlv_copy(&cd.fl_before, sizeof(fl_before), &tp, GSM48_IE_FRQLIST_BEFORE);
3226         /* channel description, before time */
3227         tlv_copy(&cd.chan_desc_before, sizeof(cd_before), &tp, GSM48_IE_CHDES_1_BEFORE);
3228         /* frequency channel sequence, before time */
3229         tlv_copy(&cd.fcs_before, sizeof(fcs_before), &tp, GSM48_IE_FRQSEQ_BEFORE);
3230         /* mobile allocation, before time */
3231         tlv_copy(&cd.moba_before, sizeof(moba_before), &tp, GSM48_IE_MOB_AL_BEFORE);
3232         /* cipher mode setting */
3233         if (TLVP_PRESENT(&tp, GSM48_IE_CIP_MODE_SET))
3234                 cd.cipher = *TLVP_VAL(&tp, GSM48_IE_CIP_MODE_SET);
3235         else
3236                 cd.cipher = 0;
3237
3238         if (no CA) {
3239                 LOGP(DRR, LOGL_INFO, "No current cell allocation available.\n");
3240                 return gsm48_rr_tx_ass_fail(ms, GSM48_GSM48_RR_CAUSE_NO_CELL_ALLOC_A);
3241         }
3242
3243         if (not supported) {
3244                 LOGP(DRR, LOGL_INFO, "New channel is not supported.\n");
3245                 return gsm48_rr_tx_ass_fail(ms, GSM48_RR_CAUSE_CHAN_MODE_UNACCEPT);
3246         }
3247
3248         if (freq not supported) {
3249                 LOGP(DRR, LOGL_INFO, "New frequency is not supported.\n");
3250                 return gsm48_rr_tx_ass_fail(ms, GSM48_RR_CAUSE_FREQ_NOT_IMPL);
3251         }
3252
3253         /* store current channel descriptions, to return in case of failure */
3254         memcpy(&rr->chan_last, &rr->chan_desc, sizeof(*cd));
3255         /* copy new description */
3256         memcpy(&rr->chan_desc, cd, sizeof(cd));
3257
3258         /* start suspension of current link */
3259         nmsg = gsm48_l3_msgb_alloc();
3260         if (!nmsg)
3261                 return -ENOMEM;
3262         gsm48_send_rsl(ms, RSL_MT_SUSP_REQ, msg);
3263
3264         /* change into special assignment suspension state */
3265         rr->assign_susp_state = 1;
3266         rr->resume_last_state = 0;
3267 #else
3268         return gsm48_rr_tx_ass_fail(ms, GSM48_RR_CAUSE_FREQ_NOT_IMPL);
3269 #endif
3270
3271         return 0;
3272 }
3273
3274 /*
3275  * radio ressource requests
3276  */
3277
3278 /* establish request for dedicated mode */
3279 static int gsm48_rr_est_req(struct osmocom_ms *ms, struct msgb *msg)
3280 {
3281         struct gsm48_rrlayer *rr = &ms->rrlayer;
3282         struct gsm322_cellsel *cs = &ms->cellsel;
3283         struct gsm48_sysinfo *s = cs->si;
3284         struct gsm_subscriber *subscr = &ms->subscr;
3285         struct gsm48_rr_hdr *rrh = (struct gsm48_rr_hdr *) msg->data;
3286         struct gsm48_hdr *gh = msgb_l3(msg);
3287         uint8_t cause;
3288         struct msgb *nmsg;
3289         struct gsm48_rr_hdr *nrrh;
3290         uint16_t acc_class;
3291
3292         /* 3.3.1.1.3.2 */
3293         if (bsc_timer_pending(&rr->t3122)) {
3294                 if (rrh->cause != RR_EST_CAUSE_EMERGENCY) {
3295                         LOGP(DRR, LOGL_INFO, "T3122 running, rejecting!\n");
3296                         cause = RR_REL_CAUSE_T3122;
3297                         reject:
3298                         LOGP(DSUM, LOGL_INFO, "Establishing radio link not "
3299                                 "possible\n");
3300                         nmsg = gsm48_rr_msgb_alloc(GSM48_RR_REL_IND);
3301                         if (!nmsg)
3302                                 return -ENOMEM;
3303                         nrrh = (struct gsm48_rr_hdr *)nmsg->data;
3304                         nrrh->cause = cause;
3305                         return gsm48_rr_upmsg(ms, nmsg);
3306                 }
3307                 LOGP(DRR, LOGL_INFO, "T3122 running, but emergency call\n");
3308                 stop_rr_t3122(rr);
3309         }
3310
3311         /* if state is not idle */
3312         if (rr->state != GSM48_RR_ST_IDLE) {
3313                 LOGP(DRR, LOGL_INFO, "We are not IDLE yet, rejecting!\n");
3314                 cause = RR_REL_CAUSE_TRY_LATER;
3315                 goto reject;
3316         }
3317
3318         /* cell selected */
3319         if (!cs->selected) {
3320                 LOGP(DRR, LOGL_INFO, "No cell selected, rejecting!\n");
3321                 cause = RR_REL_CAUSE_TRY_LATER;
3322                 goto reject;
3323         }
3324
3325         /* check if camping */
3326         if (cs->state != GSM322_C3_CAMPED_NORMALLY
3327          && rrh->cause != RR_EST_CAUSE_EMERGENCY) {
3328                 LOGP(DRR, LOGL_INFO, "Not camping normally, rejecting!\n");
3329                 cause = RR_REL_CAUSE_EMERGENCY_ONLY;
3330                 goto reject;
3331         }
3332         if (cs->state != GSM322_C3_CAMPED_NORMALLY
3333          && cs->state != GSM322_C7_CAMPED_ANY_CELL) {
3334                 LOGP(DRR, LOGL_INFO, "Not camping, rejecting!\n");
3335                 cause = RR_REL_CAUSE_TRY_LATER;
3336                 goto reject;
3337         }
3338
3339         /* check for relevant informations */
3340         if (!s->si3) {
3341                 LOGP(DRR, LOGL_INFO, "Not enough SI, rejecting!\n");
3342                 cause = RR_REL_CAUSE_TRY_LATER;
3343                 goto reject;
3344         }
3345
3346         /* 3.3.1.1.1 */
3347         if (!subscr->acc_barr && s->cell_barr) {
3348                 LOGP(DRR, LOGL_INFO, "Cell barred, rejecting!\n");
3349                 cause = RR_REL_CAUSE_NOT_AUTHORIZED;
3350                 goto reject;
3351         }
3352         if (rrh->cause == RR_EST_CAUSE_EMERGENCY)
3353                 acc_class = subscr->acc_class | 0x0400;
3354         else
3355                 acc_class = subscr->acc_class & 0xfbff;
3356         if (!subscr->acc_barr && !(acc_class & (s->class_barr ^ 0xffff))) {
3357                 LOGP(DRR, LOGL_INFO, "Cell barred for our access class (access "
3358                         "%04x barred %04x)!\n", acc_class, s->class_barr);
3359                 cause = RR_REL_CAUSE_NOT_AUTHORIZED;
3360                 goto reject;
3361         }
3362
3363         /* requested by RR */
3364         rr->rr_est_req = 1;
3365
3366         /* clone and store REQUEST message */
3367         if (!gh) {
3368                 LOGP(DRR, LOGL_ERROR, "Error, missing l3 message\n");
3369                 return -EINVAL;
3370         }
3371         rr->rr_est_msg = gsm48_l3_msgb_alloc();
3372         if (!rr->rr_est_msg)
3373                 return -ENOMEM;
3374         memcpy(msgb_put(rr->rr_est_msg, msgb_l3len(msg)),
3375                 msgb_l3(msg), msgb_l3len(msg));
3376
3377         /* request channel */
3378         return gsm48_rr_chan_req(ms, rrh->cause, 0);
3379 }
3380
3381 /* send all queued messages down to layer 2 */
3382 static int gsm48_rr_dequeue_down(struct osmocom_ms *ms)
3383 {
3384         struct gsm48_rrlayer *rr = &ms->rrlayer;
3385         struct msgb *msg;
3386
3387         while((msg = msgb_dequeue(&rr->downqueue))) {
3388                 LOGP(DRR, LOGL_INFO, "Sending queued message.\n");
3389                 gsm48_send_rsl(ms, RSL_MT_DATA_REQ, msg);
3390         }
3391
3392         return 0;
3393 }
3394
3395 /* 3.4.2 transfer data in dedicated mode */
3396 static int gsm48_rr_data_req(struct osmocom_ms *ms, struct msgb *msg)
3397 {
3398         struct gsm48_rrlayer *rr = &ms->rrlayer;
3399
3400         if (rr->state != GSM48_RR_ST_DEDICATED) {
3401                 msgb_free(msg);
3402                 return -EINVAL;
3403         }
3404
3405         /* pull RR header */
3406         msgb_pull(msg, sizeof(struct gsm48_rr_hdr));
3407
3408         /* queue message, during handover or assignment procedure */
3409         if (rr->hando_susp_state || rr->assign_susp_state) {
3410                 LOGP(DRR, LOGL_INFO, "Queueing message during suspend.\n");
3411                 msgb_enqueue(&rr->downqueue, msg);
3412                 return 0;
3413         }
3414
3415         /* forward message */
3416         return gsm48_send_rsl(ms, RSL_MT_DATA_REQ, msg);
3417 }
3418
3419 /*
3420  * data indications from data link
3421  */
3422
3423 /* 3.4.2 data from layer 2 to RR and upper layer*/
3424 static int gsm48_rr_data_ind(struct osmocom_ms *ms, struct msgb *msg)
3425 {
3426         struct gsm48_hdr *gh = msgb_l3(msg);
3427         struct gsm48_rr_hdr *rrh;
3428         uint8_t pdisc = gh->proto_discr & 0x0f;
3429
3430         if (pdisc == GSM48_PDISC_RR) {
3431                 int rc = -EINVAL;
3432                 uint8_t skip_ind = (gh->proto_discr & 0xf0) >> 4;
3433
3434                 /* ignore if skip indicator is not B'0000' */
3435                 if (skip_ind)
3436                         return 0;
3437
3438                 switch(gh->msg_type) {
3439                 case GSM48_MT_RR_ADD_ASS:
3440                         rc = gsm48_rr_rx_add_ass(ms, msg);
3441                         break;
3442                 case GSM48_MT_RR_ASS_CMD:
3443                         rc = gsm48_rr_rx_ass_cmd(ms, msg);
3444                         break;
3445 #if 0
3446                 case GSM48_MT_RR_CIP_MODE_CMD:
3447                         rc = gsm48_rr_rx_cip_mode_cmd(ms, msg);
3448                         break;
3449 #endif
3450                 case GSM48_MT_RR_CLSM_ENQ:
3451                         rc = gsm48_rr_rx_cm_enq(ms, msg);
3452                         break;
3453 #if 0
3454                 case GSM48_MT_RR_HANDO_CMD:
3455                         rc = gsm48_rr_rx_hando_cmd(ms, msg);
3456                         break;
3457                 case GSM48_MT_RR_FREQ_REDEF:
3458                         rc = gsm48_rr_rx_freq_redef(ms, msg);
3459                         break;
3460 #endif
3461                 case GSM48_MT_RR_CHAN_REL:
3462                         rc = gsm48_rr_rx_chan_rel(ms, msg);
3463                         break;
3464                 default:
3465                         LOGP(DRR, LOGL_NOTICE, "Message type 0x%02x unknown.\n",
3466                                 gh->msg_type);
3467
3468                         /* status message */
3469                         gsm48_rr_tx_rr_status(ms, GSM48_RR_CAUSE_MSG_TYPE_N);
3470                 }
3471
3472                 msgb_free(msg);
3473                 return rc;
3474         }
3475
3476         /* pull off RSL header up to L3 message */
3477         msgb_pull(msg, (long)msgb_l3(msg) - (long)msg->data);
3478
3479         /* push RR header */
3480         msgb_push(msg, sizeof(struct gsm48_rr_hdr));
3481         rrh = (struct gsm48_rr_hdr *)msg->data;
3482         rrh->msg_type = GSM48_RR_DATA_IND;
3483
3484         return gsm48_rr_upmsg(ms, msg);
3485 }
3486
3487 /* receive BCCH at RR layer */
3488 static int gsm48_rr_rx_bcch(struct osmocom_ms *ms, struct msgb *msg)
3489 {
3490         struct gsm48_system_information_type_header *sih = msgb_l3(msg);
3491
3492         switch (sih->system_information) {
3493         case GSM48_MT_RR_SYSINFO_1:
3494                 return gsm48_rr_rx_sysinfo1(ms, msg);
3495         case GSM48_MT_RR_SYSINFO_2:
3496                 return gsm48_rr_rx_sysinfo2(ms, msg);
3497         case GSM48_MT_RR_SYSINFO_2bis:
3498                 return gsm48_rr_rx_sysinfo2bis(ms, msg);
3499         case GSM48_MT_RR_SYSINFO_2ter:
3500                 return gsm48_rr_rx_sysinfo2ter(ms, msg);
3501         case GSM48_MT_RR_SYSINFO_3:
3502                 return gsm48_rr_rx_sysinfo3(ms, msg);
3503         case GSM48_MT_RR_SYSINFO_4:
3504                 return gsm48_rr_rx_sysinfo4(ms, msg);
3505         default:
3506 #if 0
3507                 LOGP(DRR, LOGL_NOTICE, "BCCH message type 0x%02x not sup.\n",
3508                         sih->system_information);
3509 #endif
3510                 return -EINVAL;
3511         }
3512 }
3513
3514 /* receive CCCH at RR layer */
3515 static int gsm48_rr_rx_pch_agch(struct osmocom_ms *ms, struct msgb *msg)
3516 {
3517         struct gsm48_system_information_type_header *sih = msgb_l3(msg);
3518
3519         switch (sih->system_information) {
3520         case GSM48_MT_RR_SYSINFO_5:
3521                 return gsm48_rr_rx_sysinfo5(ms, msg);
3522         case GSM48_MT_RR_SYSINFO_5bis:
3523                 return gsm48_rr_rx_sysinfo5bis(ms, msg);
3524         case GSM48_MT_RR_SYSINFO_5ter:
3525                 return gsm48_rr_rx_sysinfo5ter(ms, msg);
3526         case GSM48_MT_RR_SYSINFO_6:
3527                 return gsm48_rr_rx_sysinfo6(ms, msg);
3528
3529         case GSM48_MT_RR_PAG_REQ_1:
3530                 return gsm48_rr_rx_pag_req_1(ms, msg);
3531         case GSM48_MT_RR_PAG_REQ_2:
3532                 return gsm48_rr_rx_pag_req_2(ms, msg);
3533         case GSM48_MT_RR_PAG_REQ_3:
3534                 return gsm48_rr_rx_pag_req_3(ms, msg);
3535
3536         case GSM48_MT_RR_IMM_ASS:
3537                 return gsm48_rr_rx_imm_ass(ms, msg);
3538         case GSM48_MT_RR_IMM_ASS_EXT:
3539                 return gsm48_rr_rx_imm_ass_ext(ms, msg);
3540         case GSM48_MT_RR_IMM_ASS_REJ:
3541                 return gsm48_rr_rx_imm_ass_rej(ms, msg);
3542         default:
3543 #if 0
3544                 LOGP(DRR, LOGL_NOTICE, "CCCH message type 0x%02x unknown.\n",
3545                         sih->system_information);
3546 #endif
3547                 return -EINVAL;
3548         }
3549 }
3550
3551 /* unit data from layer 2 to RR layer */
3552 static int gsm48_rr_unit_data_ind(struct osmocom_ms *ms, struct msgb *msg)
3553 {
3554         struct gsm322_cellsel *cs = &ms->cellsel;
3555         struct abis_rsl_rll_hdr *rllh = msgb_l2(msg);
3556         struct tlv_parsed tv;
3557
3558         DEBUGP(DRSL, "RSLms UNIT DATA IND chan_nr=0x%02x link_id=0x%02x\n",
3559                 rllh->chan_nr, rllh->link_id);
3560
3561         rsl_tlv_parse(&tv, rllh->data, msgb_l2len(msg)-sizeof(*rllh));
3562         if (!TLVP_PRESENT(&tv, RSL_IE_L3_INFO)) {
3563                 DEBUGP(DRSL, "UNIT_DATA_IND without L3 INFO ?!?\n");
3564                 return -EIO;
3565         }
3566         msg->l3h = (uint8_t *) TLVP_VAL(&tv, RSL_IE_L3_INFO);
3567
3568         if (cs->ccch_state != GSM322_CCCH_ST_SYNC
3569          && cs->ccch_state != GSM322_CCCH_ST_DATA)
3570                 return -EINVAL;
3571
3572         /* when camping, start/reset loss timer */
3573         if (cs->state == GSM322_C3_CAMPED_NORMALLY
3574          || cs->state == GSM322_C7_CAMPED_ANY_CELL) {
3575                 struct gsm48_sysinfo *s = &ms->cellsel.sel_si;
3576 #ifdef TODO
3577         set radio link timeout on layer 1
3578         it is the number of subsequent BCCH blocks. (about 1/4 seconds)
3579 #else
3580                 start_loss_timer(cs, s->bcch_radio_link_timeout / 4, 0);
3581 #endif
3582         }
3583
3584         /* temporary moved here until confirm is fixed */
3585         if (cs->ccch_state != GSM322_CCCH_ST_DATA) {
3586                 LOGP(DCS, LOGL_INFO, "Channel provides data.\n");
3587                 cs->ccch_state = GSM322_CCCH_ST_DATA;
3588
3589                 /* in dedicated mode */
3590                 if (ms->rrlayer.state == GSM48_RR_ST_CONN_PEND)
3591                         return gsm48_rr_tx_rand_acc(ms, NULL);
3592
3593                 /* set timer for reading BCCH */
3594                 if (cs->state == GSM322_C2_STORED_CELL_SEL
3595                  || cs->state == GSM322_C1_NORMAL_CELL_SEL
3596                  || cs->state == GSM322_C6_ANY_CELL_SEL
3597                  || cs->state == GSM322_C4_NORMAL_CELL_RESEL
3598                  || cs->state == GSM322_C8_ANY_CELL_RESEL
3599                  || cs->state == GSM322_C5_CHOOSE_CELL
3600                  || cs->state == GSM322_C9_CHOOSE_ANY_CELL
3601                  || cs->state == GSM322_PLMN_SEARCH
3602                  || cs->state == GSM322_HPLMN_SEARCH)
3603                         start_cs_timer(cs, ms->support.scan_to, 0);
3604                                 // TODO: timer depends on BCCH config
3605         }
3606
3607         switch (rllh->chan_nr) {
3608         case RSL_CHAN_PCH_AGCH:
3609                 return gsm48_rr_rx_pch_agch(ms, msg);
3610         case RSL_CHAN_BCCH:
3611 #if 0
3612 #warning testing corrupt frames
3613 {int i;
3614 if (ms->cellsel.state == GSM322_C7_CAMPED_ANY_CELL)
3615 for(i=0;i<msgb_l3len(msg);i++)
3616  msg->l3h[i] = random();
3617  }
3618 #endif
3619                 return gsm48_rr_rx_bcch(ms, msg);
3620         default:
3621                 LOGP(DRSL, LOGL_NOTICE, "RSL with chan_nr 0x%02x unknown.\n",
3622                         rllh->chan_nr);
3623                 return -EINVAL;
3624         }
3625 }
3626
3627 /* 3.4.13.3 RR abort in dedicated mode (also in conn. pending mode) */
3628 static int gsm48_rr_abort_req(struct osmocom_ms *ms, struct msgb *msg)
3629 {
3630         struct gsm48_rrlayer *rr = &ms->rrlayer;
3631         uint8_t *mode;
3632
3633         /* stop pending RACH timer */
3634         stop_rr_t3126(rr);
3635
3636         /* release "normally" if we are in dedicated mode */
3637         if (rr->state == GSM48_RR_ST_DEDICATED) {
3638                 struct msgb *nmsg;
3639
3640                 LOGP(DRR, LOGL_INFO, "Abort in dedicated state, send release "
3641                         "to layer 2.\n");
3642
3643                 new_rr_state(rr, GSM48_RR_ST_REL_PEND);
3644
3645                 /* release message */
3646                 nmsg = gsm48_l3_msgb_alloc();
3647                 if (!nmsg)
3648                         return -ENOMEM;
3649                 mode = msgb_put(nmsg, 2);
3650                 mode[0] = RSL_IE_RELEASE_MODE;
3651                 mode[1] = 0; /* normal release */
3652                 return gsm48_send_rsl(ms, RSL_MT_REL_REQ, nmsg);
3653         }
3654
3655         LOGP(DRR, LOGL_INFO, "Abort in connection pending state, return to "
3656                 "idle state.\n");
3657         /* return idle */
3658         new_rr_state(rr, GSM48_RR_ST_REL_PEND);
3659
3660         return 0;
3661 }
3662
3663 /* release confirm in dedicated mode */
3664 static int gsm48_rr_susp_cnf_dedicated(struct osmocom_ms *ms, struct msgb *msg)
3665 {
3666         struct gsm48_rrlayer *rr = &ms->rrlayer;
3667
3668         if (rr->hando_susp_state || rr->assign_susp_state) {
3669                 struct msgb *nmsg;
3670
3671                 /* change radio to new channel */
3672                 tx_ph_dm_est_req(ms, rr->cd_now.arfcn, rr->cd_now.chan_nr,
3673                                  rr->cd_now.tsc);
3674
3675                 /* send DL-ESTABLISH REQUEST */
3676                 nmsg = gsm48_l3_msgb_alloc();
3677                 if (!nmsg)
3678                         return -ENOMEM;
3679                 gsm48_send_rsl(ms, RSL_MT_EST_REQ, nmsg);
3680
3681 #ifdef TODO
3682                 /* trigger RACH */
3683                 if (rr->hando_susp_state) {
3684                         gsm48_rr_tx_hando_access(ms);
3685                         rr->hando_acc_left = 3;
3686                 }
3687 #endif
3688         }
3689         return 0;
3690 }
3691
3692 /* release confirm */
3693 static int gsm48_rr_rel_cnf(struct osmocom_ms *ms, struct msgb *msg)
3694 {
3695         struct gsm48_rrlayer *rr = &ms->rrlayer;
3696         struct msgb *nmsg;
3697         struct gsm48_rr_hdr *nrrh;
3698
3699         LOGP(DSUM, LOGL_INFO, "Requesting channel aborted\n");
3700
3701         /* stop T3211 if running */
3702         stop_rr_t3110(rr);
3703
3704         /* send release indication */
3705         nmsg = gsm48_rr_msgb_alloc(GSM48_RR_REL_IND);
3706         if (!nmsg)
3707                 return -ENOMEM;
3708         nrrh = (struct gsm48_rr_hdr *)nmsg->data;
3709         nrrh->cause = RR_REL_CAUSE_NORMAL;
3710         gsm48_rr_upmsg(ms, nmsg);
3711
3712         /* return idle */
3713         new_rr_state(rr, GSM48_RR_ST_IDLE);
3714         return 0;
3715 }
3716
3717 /*
3718  * state machines
3719  */
3720
3721 /* state trasitions for link layer messages (lower layer) */
3722 static struct dldatastate {
3723         uint32_t        states;
3724         int             type;
3725         int             (*rout) (struct osmocom_ms *ms, struct msgb *msg);
3726 } dldatastatelist[] = {
3727         /* data transfer */
3728         {SBIT(GSM48_RR_ST_IDLE) |
3729          SBIT(GSM48_RR_ST_CONN_PEND) |
3730          SBIT(GSM48_RR_ST_DEDICATED) |
3731          SBIT(GSM48_RR_ST_REL_PEND),
3732          RSL_MT_UNIT_DATA_IND, gsm48_rr_unit_data_ind},
3733
3734         {SBIT(GSM48_RR_ST_DEDICATED), /* 3.4.2 */
3735          RSL_MT_DATA_IND, gsm48_rr_data_ind},
3736
3737         /* esablish */
3738         {SBIT(GSM48_RR_ST_CONN_PEND), /* 3.3.1.1.2 */
3739          RSL_MT_CHAN_CNF, gsm48_rr_tx_rand_acc},
3740
3741         {SBIT(GSM48_RR_ST_IDLE) |
3742          SBIT(GSM48_RR_ST_CONN_PEND) |
3743          SBIT(GSM48_RR_ST_REL_PEND),
3744          RSL_MT_EST_CONF, gsm48_rr_estab_cnf},
3745
3746 #if 0
3747         {SBIT(GSM48_RR_ST_DEDICATED),
3748          RSL_MT_EST_CONF, gsm48_rr_estab_cnf_dedicated},
3749
3750         {SBIT(GSM_RRSTATE),
3751          RSL_MT_CONNECT_CNF, gsm48_rr_connect_cnf},
3752
3753 #endif
3754
3755         /* release */
3756         {SBIT(GSM48_RR_ST_CONN_PEND) |
3757          SBIT(GSM48_RR_ST_DEDICATED),
3758          RSL_MT_REL_IND, gsm48_rr_rel_ind},
3759
3760         {SBIT(GSM48_RR_ST_REL_PEND),
3761          RSL_MT_REL_CONF, gsm48_rr_rel_cnf},
3762
3763         /* suspenion */
3764         {SBIT(GSM48_RR_ST_DEDICATED),
3765          RSL_MT_SUSP_CONF, gsm48_rr_susp_cnf_dedicated},
3766
3767 #if 0
3768         {SBIT(GSM48_RR_ST_DEDICATED),
3769          RSL_MT_CHAN_CNF, gsm48_rr_rand_acc_cnf_dedicated},
3770
3771         {SBIT(GSM_RRSTATE),
3772          RSL_MT_MDL_ERROR_IND, gsm48_rr_mdl_error_ind},
3773 #endif
3774 };
3775
3776 #define DLDATASLLEN \
3777         (sizeof(dldatastatelist) / sizeof(struct dldatastate))
3778
3779 static int gsm48_rcv_rsl(struct osmocom_ms *ms, struct msgb *msg)
3780 {
3781         struct gsm48_rrlayer *rr = &ms->rrlayer;
3782         struct abis_rsl_rll_hdr *rllh = msgb_l2(msg);
3783         int msg_type = rllh->c.msg_type;
3784         int i;
3785         int rc;
3786
3787         if (msg_type != RSL_MT_UNIT_DATA_IND) {
3788                 LOGP(DRSL, LOGL_INFO, "(ms %s) Received '%s' from L2 in state "
3789                         "%s\n", ms->name, get_rsl_name(msg_type),
3790                         gsm48_rr_state_names[rr->state]);
3791         }
3792
3793         /* find function for current state and message */
3794         for (i = 0; i < DLDATASLLEN; i++)
3795                 if ((msg_type == dldatastatelist[i].type)
3796                  && ((1 << rr->state) & dldatastatelist[i].states))
3797                         break;
3798         if (i == DLDATASLLEN) {
3799                 LOGP(DRSL, LOGL_NOTICE, "RSLms message unhandled\n");
3800                 msgb_free(msg);
3801                 return 0;
3802         }
3803
3804         rc = dldatastatelist[i].rout(ms, msg);
3805
3806         /* free msgb unless it is forwarded */
3807         if (dldatastatelist[i].rout != gsm48_rr_data_ind)
3808                 msgb_free(msg);
3809
3810         return rc;
3811 }
3812
3813 /* state trasitions for RR-SAP messages from up */
3814 static struct rrdownstate {
3815         uint32_t        states;
3816         int             type;
3817         int             (*rout) (struct osmocom_ms *ms, struct msgb *msg);
3818 } rrdownstatelist[] = {
3819         /* NOTE: If not IDLE, it is rejected there. */
3820         {ALL_STATES, /* 3.3.1.1 */
3821          GSM48_RR_EST_REQ, gsm48_rr_est_req},
3822
3823         {SBIT(GSM48_RR_ST_DEDICATED), /* 3.4.2 */
3824          GSM48_RR_DATA_REQ, gsm48_rr_data_req},
3825
3826         {SBIT(GSM48_RR_ST_CONN_PEND) |
3827          SBIT(GSM48_RR_ST_DEDICATED), /* 3.4.13.3 */
3828          GSM48_RR_ABORT_REQ, gsm48_rr_abort_req},
3829
3830 #if 0
3831         {SBIT(GSM48_RR_ST_DEDICATED),
3832          GSM48_RR_ACT_REQ, gsm48_rr_act_req},
3833 #endif
3834 };
3835
3836 #define RRDOWNSLLEN \
3837         (sizeof(rrdownstatelist) / sizeof(struct rrdownstate))
3838
3839 int gsm48_rr_downmsg(struct osmocom_ms *ms, struct msgb *msg)
3840 {
3841         struct gsm48_rrlayer *rr = &ms->rrlayer;
3842         struct gsm48_rr_hdr *rrh = (struct gsm48_rr_hdr *) msg->data;
3843         int msg_type = rrh->msg_type;
3844         int i;
3845         int rc;
3846
3847         LOGP(DRR, LOGL_INFO, "(ms %s) Message '%s' received in state %s\n",
3848                 ms->name, get_rr_name(msg_type),
3849                 gsm48_rr_state_names[rr->state]);
3850
3851         /* find function for current state and message */
3852         for (i = 0; i < RRDOWNSLLEN; i++)
3853                 if ((msg_type == rrdownstatelist[i].type)
3854                  && ((1 << rr->state) & rrdownstatelist[i].states))
3855                         break;
3856         if (i == RRDOWNSLLEN) {
3857                 LOGP(DRR, LOGL_NOTICE, "Message unhandled at this state.\n");
3858                 msgb_free(msg);
3859                 return 0;
3860         }
3861
3862         rc = rrdownstatelist[i].rout(ms, msg);
3863
3864         /* free msgb uless it is forwarded */
3865         if (rrdownstatelist[i].rout != gsm48_rr_data_req)
3866                 msgb_free(msg);
3867
3868         return rc;
3869 }
3870
3871 /*
3872  * init/exit
3873  */
3874
3875 int gsm48_rr_init(struct osmocom_ms *ms)
3876 {
3877         struct gsm48_rrlayer *rr = &ms->rrlayer;
3878
3879         memset(rr, 0, sizeof(*rr));
3880         rr->ms = ms;
3881
3882         LOGP(DRR, LOGL_INFO, "init Radio Ressource process\n");
3883
3884         INIT_LLIST_HEAD(&rr->rsl_upqueue);
3885         INIT_LLIST_HEAD(&rr->downqueue);
3886         /* downqueue is handled here, so don't add_work */
3887
3888         osmol2_register_handler(ms, &gsm48_rx_rsl);
3889
3890         return 0;
3891 }
3892
3893 int gsm48_rr_exit(struct osmocom_ms *ms)
3894 {
3895         struct gsm48_rrlayer *rr = &ms->rrlayer;
3896         struct msgb *msg;
3897
3898         LOGP(DRR, LOGL_INFO, "exit Radio Ressource process\n");
3899
3900         /* flush queues */
3901         while ((msg = msgb_dequeue(&rr->rsl_upqueue)))
3902                 msgb_free(msg);
3903         while ((msg = msgb_dequeue(&rr->downqueue)))
3904                 msgb_free(msg);
3905
3906         if (rr->rr_est_msg) {
3907                 msgb_free(rr->rr_est_msg);
3908                 rr->rr_est_msg = NULL;
3909         }
3910
3911         stop_rr_t_rel_wait(rr);
3912         stop_rr_t3110(rr);
3913         stop_rr_t3122(rr);
3914         stop_rr_t3126(rr);
3915
3916         return 0;
3917 }
3918
3919 #if 0
3920
3921 the process above is complete
3922 ------------------------------------------------------------------------------
3923 incomplete
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
3942
3943 todo:
3944
3945 stop timers on abort
3946 wird beim abbruch immer der gepufferte cm-service-request entfernt, auch beim verschicken?:
3947 measurement reports
3948 todo rr_sync_ind when receiving ciph, re ass, channel mode modify
3949
3950 todo change procedures, release procedure
3951
3952 static int gsm48_rr_act_req(struct osmocom_ms *ms, struct gsm48_rr *rrmsg)
3953 {
3954 }
3955
3956
3957 }
3958
3959 /* memcopy of LV of given IE from tlv_parsed structure */
3960 static int tlv_copy(void *dest, int dest_len, struct tlv_parsed *tp, uint8_t ie)
3961 {
3962         uint8_t *lv = dest;
3963         uint8_t len;
3964
3965         if (dest_len < 1)
3966                 return -EINVAL;
3967         lv[0] = 0;
3968
3969         if (!TLVP_PRESENT(tp, ie))
3970                 return 0;
3971
3972         len = TLVP_LEN(tp, ie);
3973         if (len < 1)
3974                 return 0;
3975         if (len + 1 > dest_len)
3976                 return -ENOMEM;
3977
3978         memcpy(dest, TLVP_VAL(tp, ie) - 1, len + 1);
3979         return 0;
3980 }
3981
3982
3983 /* decode "Cell Description" (10.5.2.2) */
3984 static int gsm48_decode_cell_desc(struct gsm48_cell_desc *cd, uint16_t *arfcn, uint8_t *ncc uint8_t *bcc)
3985 {
3986         *arfcn = (cd->bcch_hi << 8) + cd->bcch_lo;
3987         *ncc = cd->ncc;
3988         *bcc = cd->bcc;
3989 }
3990
3991 /* decode "Power Command" (10.5.2.28) and (10.5.2.28a) */
3992 static int gsm48_decode_power_cmd_acc(struct gsm48_power_cmd *pc, uint8_t *power_level uint8_t *atc)
3993 {
3994         *power_level = pc->power_level;
3995         if (atc) /* only in case of 10.5.2.28a */
3996                 *atc = pc->atc;
3997 }
3998
3999 /* decode "Synchronization Indication" (10.5.2.39) */
4000 static int gsm48_decode_power_cmd_acc(struct gsm48_rrlayer *rr, struct gsm48_rr_sync_ind *si)
4001 {
4002         rr->ho_sync_ind = si->si;
4003         rr->ho_rot = si->rot;
4004         rr->ho_nci = si->nci;
4005 }
4006
4007 /* receiving HANDOVER COMMAND message (9.1.15) */
4008 static int gsm48_rr_rx_hando_cmd(struct osmocom_ms *ms, struct msgb *msg)
4009 {
4010         struct gsm48_rrlayer *rr = ms->rrlayer;
4011         struct gsm48_hdr *gh = msgb_l3(msg);
4012         struct gsm48_ho_cmd *ho = (struct gsm48_ho_cmd *)gh->data;
4013         int payload_len = msgb_l3len(msg) - sizeof(*gh) - wirklich sizeof(*ho);
4014         struct tlv_parsed tp;
4015         struct gsm48_rr_cd cd;
4016         struct msgb *nmsg;
4017
4018         memset(&cd, 0, sizeof(cd));
4019
4020         if (payload_len < 0) {
4021                 LOGP(DRR, LOGL_NOTICE, "Short read of HANDOVER COMMAND message.\n");
4022                 return gsm48_rr_tx_rr_status(ms, GSM48_RR_CAUSE_PROT_ERROR_UNSPC);
4023         }
4024         tlv_parse(&tp, &gsm48_rr_att_tlvdef, ho->data, payload_len, 0, 0);
4025
4026         /* decode Cell Description */
4027         gsm_decode_cell_desc(&ho->cell_desc, &cd.bcch_arfcn, &cd.ncc, &cd.bcc);
4028         /* Channel Description */
4029         memcpy(&rr->chan_desc.chan_desc, ho->chan_desc, 3);
4030         /* Handover Reference */
4031         rr->hando_ref = ho->ho_ref;
4032         /* Power Command and access type */
4033         gsm_decode_power_cmd_acc((struct gsm48_power_cmd *)&ho->power_command,
4034                 &cd.power_level, cd.atc);
4035         /* Synchronization Indication */
4036         if (TLVP_PRESENT(&tp, GSM48_IE_SYNC_IND))
4037                 gsm48_decode_sync_ind(rr,
4038                         TLVP_VAL(&tp, GSM48_IE_SYNC_IND)-1, &cd);
4039         /* Frequency Sort List */
4040         if (TLVP_PRESENT(&tp, GSM48_IE_FREQ_SHORT_LIST))
4041                 gsm48_decode_freq_list(&ms->support, s->freq,
4042                         TLVP_VAL(&tp, GSM48_IE_FREQ_SHORT_LIST),
4043                         *(TLVP_VAL(&tp, GSM48_IE_FREQ_SHORT_LIST)-1),
4044                                 0xce, FREQ_TYPE_SERV);
4045
4046
4047 today: more IE parsing
4048
4049         /* store current channel descriptions, to return in case of failure */
4050         memcpy(&rr->chan_last, &rr->chan_desc, sizeof(*cd));
4051         /* copy new description */
4052         memcpy(&rr->chan_desc, cd, sizeof(cd));
4053
4054         /* start suspension of current link */
4055         nmsg = gsm48_l3_msgb_alloc();
4056         if (!nmsg)
4057                 return -ENOMEM;
4058         gsm48_send_rsl(ms, RSL_MT_SUSP_REQ, msg);
4059
4060         /* change into special handover suspension state */
4061         rr->hando_susp_state = 1;
4062         rr->resume_last_state = 0;
4063
4064         return 0;
4065 }
4066
4067 static int gsm48_rr_estab_cnf_dedicated(struct osmocom_ms *ms, struct msgb *msg)
4068 {
4069         if (rr->hando_susp_state || rr->assign_susp_state) {
4070                 if (rr->resume_last_state) {
4071                         rr->resume_last_state = 0;
4072                         gsm48_rr_tx_ass_cpl(ms, GSM48_RR_CAUSE_NORMAL);
4073                 } else {
4074                         gsm48_rr_tx_ass_fail(ms, GSM48_RR_CAUSE_PROTO_ERR_UNSPEC);
4075                 }
4076                 /* transmit queued frames during ho / ass transition */
4077                 gsm48_rr_dequeue_down(ms);
4078         }
4079
4080         return 0;
4081 }
4082
4083 static int gsm48_rr_connect_cnf(struct osmocom_ms *ms, struct msgbl *msg)
4084 {
4085 }
4086
4087 static int gsm48_rr_mdl_error_ind(struct osmocom_ms *ms, struct msgb *msg)
4088 {
4089         struct gsm48_rrlayer *rr = ms->rrlayer;
4090         struct msgb *nmsg;
4091         struct gsm_rr_hdr *nrrh;
4092
4093         printing of the cause
4094
4095         switch (msg->l3h[0]) {
4096         case RLL_CAUSE_SEQ_ERR:
4097         case RLL_CAUSE_UNSOL_DM_RESP_MF:
4098         einige muessen ignoriert werden
4099         andere gelten als release
4100         }
4101
4102         if (rr->hando_susp_state || rr->assign_susp_state) {
4103                 if (!rr->resume_last_state) {
4104                         rr->resume_last_state = 1;
4105
4106                         /* get old channel description */
4107                         memcpy(&rr->chan_desc, &rr->chan_last, sizeof(*cd));
4108
4109                         /* change radio to old channel */
4110                         tx_ph_dm_est_req(ms, rr->cd_now.arfcn,
4111                                 rr->cd_now.chan_nr, rr->cd_now.tsc);
4112
4113                         /* re-establish old link */
4114                         nmsg = gsm48_l3_msgb_alloc();
4115                         if (!nmsg)
4116                                 return -ENOMEM;
4117                         return gsm48_send_rsl(ms, RSL_MT_RECON_REQ, nmsg);
4118                 }
4119                 rr->resume_last_state = 0;
4120         }
4121
4122         /* deactivate channel */
4123         tx_ph_dm_rel_req(ms, arfcn, rr->chan_desc.chan_desc.chan_nr);
4124
4125         /* send abort ind to upper layer */
4126         nmsg = gsm48_mm_msgb_alloc();
4127
4128         if (!msg)
4129                 return -ENOMEM;
4130         nrrh = (struct gsm_mm_hdr *)nmsg->data;
4131         nrrh->msg_type = RR_ABORT_IND;
4132         nrrh->cause = GSM_MM_CAUSE_LINK_FAILURE;
4133         return gsm48_rr_upmsg(ms, msg);
4134 }
4135
4136 static void timeout_rr_t3124(void *arg)
4137 {
4138         struct gsm48_rrlayer *rr = arg;
4139         struct msgb *nmsg;
4140
4141         /* stop sending more access bursts when timer expired */
4142         hando_acc_left = 0;
4143
4144         /* get old channel description */
4145         memcpy(&rr->chan_desc, &rr->chan_last, sizeof(*cd));
4146
4147         /* change radio to old channel */
4148         tx_ph_dm_est_req(ms, rr->cd_now.arfcn, rr->cd_now.chan_nr,
4149                          rr->cd_now.tsc);
4150
4151         /* re-establish old link */
4152         nmsg = gsm48_l3_msgb_alloc();
4153         if (!nmsg)
4154                 return -ENOMEM;
4155         return gsm48_send_rsl(ms, RSL_MT_REEST_REQ, nmsg);
4156
4157         todo
4158 }
4159
4160 /* send HANDOVER ACCESS burst (9.1.14) */
4161 static int gsm48_rr_tx_hando_access(struct osmocom_ms *ms)
4162 {
4163         nmsg = msgb_alloc_headroom(20, 16, "HAND_ACCESS");
4164         if (!nmsg)
4165                 return -ENOMEM;
4166         *msgb_put(nmsg, 1) = rr->hando_ref;
4167         todo burst
4168         return gsm48_send_rsl(ms, RSL_MT_RAND_ACC_REQ, nmsg);
4169 }
4170
4171 /* send next channel request in dedicated state */
4172 static int gsm48_rr_rand_acc_cnf_dedicated(struct osmocom_ms *ms, struct msgb *msg)
4173 {
4174         struct gsm48_rrlayer *rr = &ms->rrlayer;
4175         struct msgb *nmsg;
4176         int s;
4177
4178         if (!rr->hando_susp_state) {
4179                 LOGP(DRR, LOGL_NOTICE, "Random acces confirm, but not in handover state.\n");
4180                 return 0;
4181         }
4182
4183         /* send up to four handover access bursts */
4184         if (rr->hando_acc_left) {
4185                 rr->hando_acc_left--;
4186                 gsm48_rr_tx_hando_access(ms);
4187                 return;
4188         }
4189
4190         /* start timer for sending next HANDOVER ACCESS bursts afterwards */
4191         if (!bsc_timer_pending(&rr->t3124)) {
4192                 if (allocated channel is SDCCH)
4193                         start_rr_t3124(rr, GSM_T3124_675);
4194                 else
4195                         start_rr_t3124(rr, GSM_T3124_320);
4196         if (!rr->n_chan_req) {
4197                 start_rr_t3126(rr, 5, 0); /* TODO improve! */
4198                 return 0;
4199         }
4200         rr->n_chan_req--;
4201
4202         /* wait for PHYSICAL INFORMATION message or T3124 timeout */
4203         return 0;
4204
4205 }
4206
4207 #endif
4208
4209