X-Git-Url: http://git.rot13.org/?a=blobdiff_plain;f=src%2Fhost%2Flayer23%2Fsrc%2Fl1ctl.c;h=051b3d88c188ea2b939227eb0fe583c122ae3baf;hb=78f6fb7713beb247c07327a1f802b14ebd2b830a;hp=5a94c111b26236a31eee27af604e8ac38c7c5a5e;hpb=c35e661758d8f51ef9d1b3081ba92b35b8e6d451;p=osmocom-bb.git diff --git a/src/host/layer23/src/l1ctl.c b/src/host/layer23/src/l1ctl.c index 5a94c11..051b3d8 100644 --- a/src/host/layer23/src/l1ctl.c +++ b/src/host/layer23/src/l1ctl.c @@ -30,6 +30,8 @@ #include +#include +#include #include #include #include @@ -40,8 +42,9 @@ #include #include +#include #include -#include +#include #include static struct msgb *osmo_l1_alloc(uint8_t msg_type) @@ -50,7 +53,7 @@ static struct msgb *osmo_l1_alloc(uint8_t msg_type) struct msgb *msg = msgb_alloc_headroom(256, 4, "osmo_l1"); if (!msg) { - fprintf(stderr, "Failed to allocate memory.\n"); + LOGP(DL1C, LOGL_ERROR, "Failed to allocate memory.\n"); return NULL; } @@ -62,29 +65,40 @@ static struct msgb *osmo_l1_alloc(uint8_t msg_type) } -static int osmo_make_band_arfcn(struct osmocom_ms *ms) +static int osmo_make_band_arfcn(struct osmocom_ms *ms, uint16_t arfcn) { /* TODO: Include the band */ - return ms->arfcn; + return arfcn; } -static int rx_l1_ccch_resp(struct osmocom_ms *ms, struct msgb *msg) +static int rx_l1_fbsb_resp(struct osmocom_ms *ms, struct msgb *msg) { struct l1ctl_info_dl *dl; - struct l1ctl_sync_new_ccch_resp *sb; + struct l1ctl_fbsb_resp *sb; struct gsm_time tm; - if (msgb_l3len(msg) < sizeof(*sb)) { - fprintf(stderr, "MSG too short for CCCH RESP: %u\n", msgb_l3len(msg)); + if (msgb_l3len(msg) < sizeof(*dl) + sizeof(*sb)) { + LOGP(DL1C, LOGL_ERROR, "FBSB RESP: MSG too short %u\n", + msgb_l3len(msg)); return -1; } dl = (struct l1ctl_info_dl *) msg->l1h; - sb = (struct l1ctl_sync_new_ccch_resp *) dl->payload; + sb = (struct l1ctl_fbsb_resp *) dl->payload; + + printf("snr=%04x, arfcn=%u result=%u\n", dl->snr, ntohs(dl->band_arfcn), + sb->result); + + if (sb->result != 0) { + LOGP(DL1C, LOGL_ERROR, "FBSB RESP: result=%u\n", sb->result); + dispatch_signal(SS_L1CTL, S_L1CTL_FBSB_ERR, ms); + return 0; + } gsm_fn2gsmtime(&tm, ntohl(dl->frame_nr)); - printf("SCH: SNR: %u TDMA: (%.4u/%.2u/%.2u) bsic: %d\n", + DEBUGP(DL1C, "SCH: SNR: %u TDMA: (%.4u/%.2u/%.2u) bsic: %d\n", dl->snr, tm.t1, tm.t2, tm.t3, sb->bsic); + dispatch_signal(SS_L1CTL, S_L1CTL_FBSB_RESP, ms); return 0; } @@ -127,7 +141,9 @@ static int rx_ph_data_ind(struct osmocom_ms *ms, struct msgb *msg) struct gsm_time tm; if (msgb_l3len(msg) < sizeof(*ccch)) { - fprintf(stderr, "MSG too short Data Ind: %u\n", msgb_l3len(msg)); + LOGP(DL1C, LOGL_ERROR, "MSG too short Data Ind: %u\n", + msgb_l3len(msg)); + msgb_free(msg); return -1; } @@ -137,21 +153,29 @@ static int rx_ph_data_ind(struct osmocom_ms *ms, struct msgb *msg) gsm_fn2gsmtime(&tm, ntohl(dl->frame_nr)); rsl_dec_chan_nr(dl->chan_nr, &chan_type, &chan_ss, &chan_ts); - printf("%s (%.4u/%.2u/%.2u) %s\n", + DEBUGP(DL1C, "%s (%.4u/%.2u/%.2u) %s\n", chan_nr2string(dl->chan_nr), tm.t1, tm.t2, tm.t3, hexdump(ccch->data, sizeof(ccch->data))); + if (dl->num_biterr) { + LOGP(DL1C, LOGL_NOTICE, "Dropping frame with %u bit errors\n", + dl->num_biterr); + return 0; + } + /* send CCCH data via GSMTAP */ gsmtap_chan_type = chantype_rsl2gsmtap(chan_type, dl->link_id); gsmtap_sendmsg(dl->band_arfcn, chan_ts, gsmtap_chan_type, chan_ss, - tm.fn, dl->rx_level-110, dl->snr, ccch->data, sizeof(ccch->data)); + tm.fn, dl->rx_level-110, dl->snr, ccch->data, + sizeof(ccch->data)); /* determine LAPDm entity based on SACCH or not */ if (dl->link_id & 0x40) - le = &ms->lapdm_acch; + le = &ms->l2_entity.lapdm_acch; else - le = &ms->lapdm_dcch; - /* make local stack copy of l1ctl_info_dl, as LAPDm will overwrite skb hdr */ + le = &ms->l2_entity.lapdm_dcch; + /* make local stack copy of l1ctl_info_dl, as LAPDm will + * overwrite skb hdr */ memcpy(&dl_cpy, dl, sizeof(dl_cpy)); /* pull the L1 header from the msgb */ @@ -173,14 +197,16 @@ int tx_ph_data_req(struct osmocom_ms *ms, struct msgb *msg, uint8_t chan_type, chan_ts, chan_ss; uint8_t gsmtap_chan_type; - printf("tx_ph_data_req(%s)\n", hexdump(msg->l2h, msgb_l2len(msg))); + DEBUGP(DL1C, "(%s)\n", hexdump(msg->l2h, msgb_l2len(msg))); if (msgb_l2len(msg) > 23) { - printf("L1 cannot handle message length > 23 (%u)\n", msgb_l2len(msg)); + LOGP(DL1C, LOGL_ERROR, "L1 cannot handle message length " + "> 23 (%u)\n", msgb_l2len(msg)); msgb_free(msg); return -EINVAL; } else if (msgb_l2len(msg) < 23) - printf("L1 message length < 23 (%u) doesn't seem right!\n", msgb_l2len(msg)); + LOGP(DL1C, LOGL_ERROR, "L1 message length < 23 (%u) " + "doesn't seem right!\n", msgb_l2len(msg)); /* send copy via GSMTAP */ rsl_dec_chan_nr(chan_nr, &chan_type, &chan_ss, &chan_ts); @@ -205,19 +231,28 @@ int tx_ph_data_req(struct osmocom_ms *ms, struct msgb *msg, return osmo_send_l1(ms, msg); } -/* Receive L1CTL_RESET */ -static int rx_l1_reset(struct osmocom_ms *ms) +/* Transmit FBSB_REQ */ +int l1ctl_tx_fbsb_req(struct osmocom_ms *ms, uint16_t arfcn, + uint8_t flags, uint16_t timeout, uint8_t sync_info_idx) { struct msgb *msg; - struct l1ctl_sync_new_ccch_req *req; + struct l1ctl_fbsb_req *req; - msg = osmo_l1_alloc(L1CTL_NEW_CCCH_REQ); + msg = osmo_l1_alloc(L1CTL_FBSB_REQ); if (!msg) return -1; - printf("Layer1 Reset.\n"); - req = (struct l1ctl_sync_new_ccch_req *) msgb_put(msg, sizeof(*req)); - req->band_arfcn = osmo_make_band_arfcn(ms); + req = (struct l1ctl_fbsb_req *) msgb_put(msg, sizeof(*req)); + req->band_arfcn = htons(osmo_make_band_arfcn(ms, arfcn)); + req->timeout = htons(timeout); + /* Threshold when to consider FB_MODE1: 4kHz - 1kHz */ + req->freq_err_thresh1 = htons(4000 - 1000); + /* Threshold when to consider SCH: 1kHz - 200Hz */ + req->freq_err_thresh2 = htons(1000 - 200); + /* not used yet! */ + req->num_freqerr_avg = 3; + req->flags = flags; + req->sync_info_idx = sync_info_idx; return osmo_send_l1(ms, msg); } @@ -234,7 +269,7 @@ int tx_ph_rach_req(struct osmocom_ms *ms) if (!msg) return -1; - printf("RACH Req.\n"); + DEBUGP(DL1C, "RACH Req.\n"); ul = (struct l1ctl_info_ul *) msgb_put(msg, sizeof(*ul)); req = (struct l1ctl_rach_req *) msgb_put(msg, sizeof(*req)); req->ra = i++; @@ -253,18 +288,82 @@ int tx_ph_dm_est_req(struct osmocom_ms *ms, uint16_t band_arfcn, uint8_t chan_nr if (!msg) return -1; - printf("Tx Dedic.Mode Est Req (arfcn=%u, chan_nr=0x%02x)\n", + DEBUGP(DL1C, "Tx Dedic.Mode Est Req (arfcn=%u, chan_nr=0x%02x)\n", band_arfcn, chan_nr); ul = (struct l1ctl_info_ul *) msgb_put(msg, sizeof(*ul)); ul->chan_nr = chan_nr; ul->link_id = 0; ul->tx_power = 0; /* FIXME: initial TX power */ req = (struct l1ctl_dm_est_req *) msgb_put(msg, sizeof(*req)); - req->band_arfcn = band_arfcn; + req->band_arfcn = htons(band_arfcn); return osmo_send_l1(ms, msg); } +int l1ctl_tx_echo_req(struct osmocom_ms *ms, unsigned int len) +{ + struct msgb *msg; + uint8_t *data; + unsigned int i; + + msg = osmo_l1_alloc(L1CTL_ECHO_REQ); + if (!msg) + return -1; + + data = msgb_put(msg, len); + for (i = 0; i < len; i++) + data[i] = i % 8; + + return osmo_send_l1(ms, msg); +} + +/* Transmit L1CTL_PM_REQ */ +int l1ctl_tx_pm_req_range(struct osmocom_ms *ms, uint16_t arfcn_from, + uint16_t arfcn_to) +{ + struct msgb *msg; + struct l1ctl_pm_req *pm; + + msg = osmo_l1_alloc(L1CTL_PM_REQ); + if (!msg) + return -1; + + printf("Tx PM Req (%u-%u)\n", arfcn_from, arfcn_to); + pm = (struct l1ctl_pm_req *) msgb_put(msg, sizeof(*pm)); + pm->type = 1; + pm->range.band_arfcn_from = htons(arfcn_from); + pm->range.band_arfcn_to = htons(arfcn_to); + + return osmo_send_l1(ms, msg); +} + +/* Receive L1CTL_RESET */ +static int rx_l1_reset(struct osmocom_ms *ms) +{ + printf("Layer1 Reset.\n"); + dispatch_signal(SS_L1CTL, S_L1CTL_RESET, ms); + + return 0; +} + +/* Receive L1CTL_PM_RESP */ +static int rx_l1_pm_resp(struct osmocom_ms *ms, struct msgb *msg) +{ + struct l1ctl_pm_resp *pmr; + + for (pmr = (struct l1ctl_pm_resp *) msg->l1h; + (uint8_t *) pmr < msg->tail; pmr++) { + struct osmobb_meas_res mr; + DEBUGP(DL1C, "PM MEAS: ARFCN: %4u RxLev: %3d %3d\n", + ntohs(pmr->band_arfcn), pmr->pm[0], pmr->pm[1]); + mr.band_arfcn = ntohs(pmr->band_arfcn); + mr.rx_lev = (pmr->pm[0] + pmr->pm[1]) / 2; + mr.ms = ms; + dispatch_signal(SS_L1CTL, S_L1CTL_PM_RES, &mr); + } + return 0; +} + /* Receive incoming data from L1 using L1CTL format */ int l1ctl_recv(struct osmocom_ms *ms, struct msgb *msg) { @@ -273,28 +372,39 @@ int l1ctl_recv(struct osmocom_ms *ms, struct msgb *msg) struct l1ctl_info_dl *dl; if (msgb_l2len(msg) < sizeof(*dl)) { - fprintf(stderr, "Short Layer2 message: %u\n", msgb_l2len(msg)); + LOGP(DL1C, LOGL_ERROR, "Short Layer2 message: %u\n", + msgb_l2len(msg)); + msgb_free(msg); return -1; } - l1h = (struct l1ctl_info_dl *) msg->l1h; + l1h = (struct l1ctl_hdr *) msg->l1h; /* move the l1 header pointer to point _BEHIND_ l1ctl_hdr, as the l1ctl header is of no interest to subsequent code */ msg->l1h = l1h->data; switch (l1h->msg_type) { - case L1CTL_NEW_CCCH_RESP: - rc = rx_l1_ccch_resp(ms, msg); + case L1CTL_FBSB_RESP: + rc = rx_l1_fbsb_resp(ms, msg); + msgb_free(msg); break; case L1CTL_DATA_IND: rc = rx_ph_data_ind(ms, msg); break; case L1CTL_RESET: rc = rx_l1_reset(ms); + msgb_free(msg); + break; + case L1CTL_PM_RESP: + rc = rx_l1_pm_resp(ms, msg); + msgb_free(msg); + if (l1h->flags & L1CTL_F_DONE) + dispatch_signal(SS_L1CTL, S_L1CTL_PM_DONE, ms); break; default: fprintf(stderr, "Unknown MSG: %u\n", l1h->msg_type); + msgb_free(msg); break; }