src/host/layer23/src/l1ctl.c

   1 /* Layer1 control code, talking L1CTL protocol with L1 on the phone */
   2
   3 /* (C) 2010 by Holger Hans Peter Freyther <zecke@selfish.org>
   4  * (C) 2010 by Harald Welte <laforge@gnumonks.org>
   5  *
   6  * All Rights Reserved
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with this program; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  *
  22  */
  23
  24 #include <stdio.h>
  25 #include <stdint.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <l1a_l23_interface.h>
  29
  30 #include <osmocore/timer.h>
  31 #include <osmocore/msgb.h>
  32 #include <osmocore/tlv.h>
  33 #include <osmocore/protocol/gsm_04_08.h>
  34 #include <osmocore/protocol/gsm_08_58.h>
  35
  36 #include <osmocom/l1ctl.h>
  37 #include <osmocom/osmocom_data.h>
  38 #include <osmocom/lapdm.h>
  39 #include <osmocom/debug.h>
  40
  41 #include "gsmtap_util.h"
  42
  43 static struct msgb *osmo_l1_alloc(uint8_t msg_type)
  44 {
  45         struct l1ctl_info_ul *ul;
  46         struct msgb *msg = msgb_alloc_headroom(256, 4, "osmo_l1");
  47
  48         if (!msg) {
  49                 fprintf(stderr, "Failed to allocate memory.\n");
  50                 return NULL;
  51         }
  52
  53         msg->l1h = msgb_put(msg, sizeof(*ul));
  54         ul = (struct l1ctl_info_ul *) msg->l1h;
  55         ul->msg_type = msg_type;
  56
  57         return msg;
  58 }
  59
  60
  61 static int osmo_make_band_arfcn(struct osmocom_ms *ms)
  62 {
  63         /* TODO: Include the band */
  64         return ms->arfcn;
  65 }
  66
  67 static int rx_l1_ccch_resp(struct osmocom_ms *ms, struct msgb *msg)
  68 {
  69         struct l1ctl_info_dl *dl;
  70         struct l1ctl_sync_new_ccch_resp *sb;
  71
  72         if (msgb_l3len(msg) < sizeof(*sb)) {
  73                 fprintf(stderr, "MSG too short for CCCH RESP: %u\n", msgb_l3len(msg));
  74                 return -1;
  75         }
  76
  77         dl = (struct l1ctl_info_dl *) msg->l1h;
  78         sb = (struct l1ctl_sync_new_ccch_resp *) msg->l2h;
  79
  80         printf("SCH: SNR: %u TDMA: (%.4u/%.2u/%.2u) bsic: %d\n",
  81                 dl->snr[0], dl->time.t1, dl->time.t2, dl->time.t3, sb->bsic);
  82
  83         return 0;
  84 }
  85
  86 char *chan_nr2string(uint8_t chan_nr)
  87 {
  88         static char str[20];
  89         uint8_t cbits = chan_nr >> 3;
  90
  91         str[0] = '\0';
  92
  93         if (cbits == 0x01)
  94                 sprintf(str, "TCH/F");
  95         else if ((cbits & 0x1e) == 0x02)
  96                 sprintf(str, "TCH/H(%u)", cbits & 0x01);
  97         else if ((cbits & 0x1c) == 0x04)
  98                 sprintf(str, "SDCCH/4(%u)", cbits & 0x03);
  99         else if ((cbits & 0x18) == 0x08)
 100                 sprintf(str, "SDCCH/8(%u)", cbits & 0x07);
 101         else if (cbits == 0x10)
 102                 sprintf(str, "BCCH");
 103         else if (cbits == 0x11)
 104                 sprintf(str, "RACH");
 105         else if (cbits == 0x12)
 106                 sprintf(str, "PCH/AGCH");
 107         else
 108                 sprintf(str, "UNKNOWN");
 109
 110         return str;
 111 }
 112
 113 /* Receive L1CTL_DATA_IND (Data Indication from L1) */
 114 static int rx_ph_data_ind(struct osmocom_ms *ms, struct msgb *msg)
 115 {
 116         struct l1ctl_info_dl *dl, dl_cpy;
 117         struct l1ctl_data_ind *ccch;
 118         struct lapdm_entity *le;
 119
 120         if (msgb_l3len(msg) < sizeof(*ccch)) {
 121                 fprintf(stderr, "MSG too short Data Ind: %u\n", msgb_l3len(msg));
 122                 return -1;
 123         }
 124
 125         dl = (struct l1ctl_info_dl *) msg->l1h;
 126         ccch = (struct l1ctl_data_ind *) msg->l2h;
 127         printf("%s (%.4u/%.2u/%.2u) %s\n",
 128                 chan_nr2string(dl->chan_nr), dl->time.t1, dl->time.t2,
 129                 dl->time.t3, hexdump(ccch->data, sizeof(ccch->data)));
 130
 131         /* send CCCH data via GSMTAP */
 132         gsmtap_sendmsg(dl->chan_nr & 0x07, dl->band_arfcn, dl->time.fn, ccch->data,
 133                         sizeof(ccch->data));
 134
 135         /* determine LAPDm entity based on SACCH or not */
 136         if (dl->link_id & 0x40)
 137                 le = &ms->lapdm_acch;
 138         else
 139                 le = &ms->lapdm_dcch;
 140         /* make local stack copy of l1ctl_info_dl, as LAPDm will overwrite skb hdr */
 141         memcpy(&dl_cpy, dl, sizeof(dl_cpy));
 142
 143         /* pull the L1 header from the msgb */
 144         msgb_pull(msg, msg->l2h - msg->l1h);
 145         msg->l1h = NULL;
 146
 147         /* send it up into LAPDm */
 148         l2_ph_data_ind(msg, le, &dl_cpy);
 149
 150         return 0;
 151 }
 152
 153 /* Transmit L1CTL_DATA_REQ */
 154 int tx_ph_data_req(struct osmocom_ms *ms, struct msgb *msg,
 155                    uint8_t chan_nr, uint8_t link_id)
 156 {
 157         struct l1ctl_info_ul *l1i_ul;
 158
 159         printf("tx_ph_data_req(%s)\n", hexdump(msg->l2h, msgb_l2len(msg)));
 160
 161         if (msgb_l2len(msg) > 23) {
 162                 printf("L1 cannot handle message length > 23 (%u)\n", msgb_l2len(msg));
 163                 msgb_free(msg);
 164                 return -EINVAL;
 165         } else if (msgb_l2len(msg) < 23)
 166                 printf("L1 message length < 23 (%u) doesn't seem right!\n", msgb_l2len(msg));
 167
 168         /* prepend uplink info header */
 169         printf("sizeof(struct l1ctl_info_ul)=%lu\n", sizeof(*l1i_ul));
 170         msg->l1h = msgb_push(msg, sizeof(*l1i_ul));
 171         l1i_ul = (struct l1ctl_info_ul *) msg->l1h;
 172
 173         l1i_ul->msg_type = L1CTL_DATA_REQ;
 174
 175         l1i_ul->chan_nr = chan_nr;
 176         l1i_ul->link_id = link_id;
 177
 178         /* FIXME: where to get this from? */
 179         l1i_ul->tx_power = 0;
 180
 181         return osmo_send_l1(ms, msg);
 182 }
 183
 184 /* Receive L1CTL_RESET */
 185 static int rx_l1_reset(struct osmocom_ms *ms)
 186 {
 187         struct msgb *msg;
 188         struct l1ctl_sync_new_ccch_req *req;
 189
 190         msg = osmo_l1_alloc(L1CTL_NEW_CCCH_REQ);
 191         if (!msg)
 192                 return -1;
 193
 194         printf("Layer1 Reset.\n");
 195         req = (struct l1ctl_sync_new_ccch_req *) msgb_put(msg, sizeof(*req));
 196         req->band_arfcn = osmo_make_band_arfcn(ms);
 197
 198         return osmo_send_l1(ms, msg);
 199 }
 200
 201 /* Transmit L1CTL_RACH_REQ */
 202 int tx_ph_rach_req(struct osmocom_ms *ms)
 203 {
 204         struct msgb *msg;
 205         struct l1ctl_rach_req *req;
 206         static uint8_t i = 0;
 207
 208         msg = osmo_l1_alloc(L1CTL_RACH_REQ);
 209         if (!msg)
 210                 return -1;
 211
 212         printf("RACH Req.\n");
 213         req = (struct l1ctl_rach_req *) msgb_put(msg, sizeof(*req));
 214         req->ra = i++;
 215
 216         return osmo_send_l1(ms, msg);
 217 }
 218
 219 /* Transmit L1CTL_DM_EST_REQ */
 220 int tx_ph_dm_est_req(struct osmocom_ms *ms, uint16_t band_arfcn, uint8_t chan_nr)
 221 {
 222         struct msgb *msg;
 223         struct l1ctl_info_ul *ul;
 224         struct l1ctl_dm_est_req *req;
 225
 226         msg = osmo_l1_alloc(L1CTL_DM_EST_REQ);
 227         if (!msg)
 228                 return -1;
 229
 230         printf("Tx Dedic.Mode Est Req (arfcn=%u, chan_nr=0x%02x)\n",
 231                 band_arfcn, chan_nr);
 232         ul = (struct l1ctl_info_ul *) msg->l1h;
 233         ul->chan_nr = chan_nr;
 234         ul->link_id = 0;
 235         ul->tx_power = 0; /* FIXME: initial TX power */
 236         req = (struct l1ctl_dm_est_req *) msgb_put(msg, sizeof(*req));
 237         req->band_arfcn = band_arfcn;
 238
 239         return osmo_send_l1(ms, msg);
 240
 241 }
 242
 243 /* Receive incoming data from L1 using L1CTL format */
 244 int l1ctl_recv(struct osmocom_ms *ms, struct msgb *msg)
 245 {
 246         int rc = 0;
 247         struct l1ctl_info_dl *dl;
 248
 249         if (msgb_l2len(msg) < sizeof(*dl)) {
 250                 fprintf(stderr, "Short Layer2 message: %u\n", msgb_l2len(msg));
 251                 return -1;
 252         }
 253
 254         dl = (struct l1ctl_info_dl *) msg->l1h;
 255         msg->l2h = &msg->l1h[0] + sizeof(*dl);
 256
 257         switch (dl->msg_type) {
 258         case L1CTL_NEW_CCCH_RESP:
 259                 rc = rx_l1_ccch_resp(ms, msg);
 260                 break;
 261         case L1CTL_DATA_IND:
 262                 rc = rx_ph_data_ind(ms, msg);
 263                 break;
 264         case L1CTL_RESET:
 265                 rc = rx_l1_reset(ms);
 266                 break;
 267         default:
 268                 fprintf(stderr, "Unknown MSG: %u\n", dl->msg_type);
 269                 break;
 270         }
 271
 272         return rc;
 273 }