blob: 8141e477417b0e5f73af48e59b94ebd6bc50ec99 [file] [log] [blame]
Harald Welte8470bf22008-12-25 23:28:35 +00001/* GSM Channel allocation routines
2 *
3 * (C) 2008 by Harald Welte <laforge@gnumonks.org>
Holger Freythere64a7a32009-02-06 21:55:37 +00004 * (C) 2008, 2009 by Holger Hans Peter Freyther <zecke@selfish.org>
Harald Welte8470bf22008-12-25 23:28:35 +00005 *
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 <stdlib.h>
26#include <string.h>
27#include <errno.h>
28
29#include <openbsc/gsm_data.h>
30#include <openbsc/chan_alloc.h>
Harald Welte4b634542008-12-27 01:55:51 +000031#include <openbsc/abis_nm.h>
Holger Freyther67b4b9a2009-01-01 03:46:11 +000032#include <openbsc/abis_rsl.h>
Holger Freytherc6ea9db2008-12-30 19:18:21 +000033#include <openbsc/debug.h>
Holger Freyther7c19f742009-06-06 13:54:35 +000034#include <openbsc/signal.h>
Holger Freytherc6ea9db2008-12-30 19:18:21 +000035
Harald Weltef85497c2009-01-01 00:33:20 +000036static void auto_release_channel(void *_lchan);
Harald Welte8470bf22008-12-25 23:28:35 +000037
Harald Welte4c704542009-12-24 10:10:16 +010038static int ts_is_usable(struct gsm_bts_trx_ts *ts)
39{
40 /* FIXME: How does this behave for BS-11 ? */
41 if (is_ipaccess_bts(ts->trx->bts)) {
42 if (ts->nm_state.operational != NM_OPSTATE_ENABLED ||
43 ts->nm_state.availability != NM_AVSTATE_OK)
44 return 0;
45 }
46
47 return 1;
48}
49
Harald Welte (local)82ff3972009-12-28 16:36:28 +010050int trx_is_usable(struct gsm_bts_trx *trx)
Harald Welte4c704542009-12-24 10:10:16 +010051{
52 /* FIXME: How does this behave for BS-11 ? */
53 if (is_ipaccess_bts(trx->bts)) {
54 if (trx->nm_state.operational != NM_OPSTATE_ENABLED ||
55 trx->nm_state.availability != NM_AVSTATE_OK ||
56 trx->bb_transc.nm_state.operational != NM_OPSTATE_ENABLED ||
57 trx->bb_transc.nm_state.availability != NM_AVSTATE_OK)
58 return 0;
59 }
60
61 return 1;
62}
63
Harald Welte8470bf22008-12-25 23:28:35 +000064struct gsm_bts_trx_ts *ts_c0_alloc(struct gsm_bts *bts,
65 enum gsm_phys_chan_config pchan)
66{
Harald Weltee441d9c2009-06-21 16:17:15 +020067 struct gsm_bts_trx *trx = bts->c0;
Harald Welte8470bf22008-12-25 23:28:35 +000068 struct gsm_bts_trx_ts *ts = &trx->ts[0];
69
70 if (pchan != GSM_PCHAN_CCCH &&
71 pchan != GSM_PCHAN_CCCH_SDCCH4)
72 return NULL;
73
74 if (ts->pchan != GSM_PCHAN_NONE)
75 return NULL;
76
77 ts->pchan = pchan;
78
79 return ts;
80}
81
Harald Welte4bfdfe72009-06-10 23:11:52 +080082/* Allocate a physical channel (TS) */
Harald Welte8470bf22008-12-25 23:28:35 +000083struct gsm_bts_trx_ts *ts_alloc(struct gsm_bts *bts,
84 enum gsm_phys_chan_config pchan)
85{
Harald Welte88367262009-08-10 13:25:55 +020086 int j;
87 struct gsm_bts_trx *trx;
88
89 llist_for_each_entry(trx, &bts->trx_list, list) {
Harald Welte75a983f2008-12-27 21:34:06 +000090 int from, to;
91
Harald Welte4c704542009-12-24 10:10:16 +010092 if (!trx_is_usable(trx))
93 continue;
94
Harald Welte75a983f2008-12-27 21:34:06 +000095 /* the following constraints are pure policy,
96 * no requirement to put this restriction in place */
Harald Welted46299d2009-07-29 16:46:37 +020097 if (trx == bts->c0) {
98 /* On the first TRX we run one CCCH and one SDCCH8 */
99 switch (pchan) {
100 case GSM_PCHAN_CCCH:
101 case GSM_PCHAN_CCCH_SDCCH4:
102 from = 0; to = 0;
103 break;
Harald Welted46299d2009-07-29 16:46:37 +0200104 case GSM_PCHAN_TCH_F:
105 case GSM_PCHAN_TCH_H:
Harald Welte89e9d592009-08-09 22:01:26 +0200106 from = 1; to = 7;
Harald Welted46299d2009-07-29 16:46:37 +0200107 break;
Harald Welte89e9d592009-08-09 22:01:26 +0200108 case GSM_PCHAN_SDCCH8_SACCH8C:
Harald Welted46299d2009-07-29 16:46:37 +0200109 default:
110 return NULL;
111 }
112 } else {
113 /* Every secondary TRX is configured for TCH/F
114 * and TCH/H only */
115 switch (pchan) {
Harald Welte89e9d592009-08-09 22:01:26 +0200116 case GSM_PCHAN_SDCCH8_SACCH8C:
117 from = 1; to = 1;
Harald Welted46299d2009-07-29 16:46:37 +0200118 case GSM_PCHAN_TCH_F:
119 case GSM_PCHAN_TCH_H:
Harald Welte89e9d592009-08-09 22:01:26 +0200120 from = 1; to = 7;
Harald Welted46299d2009-07-29 16:46:37 +0200121 break;
122 default:
123 return NULL;
124 }
Harald Welte75a983f2008-12-27 21:34:06 +0000125 }
126
127 for (j = from; j <= to; j++) {
Harald Welte8470bf22008-12-25 23:28:35 +0000128 struct gsm_bts_trx_ts *ts = &trx->ts[j];
Harald Welte4c704542009-12-24 10:10:16 +0100129
130 if (!ts_is_usable(ts))
131 continue;
132
Harald Welte8470bf22008-12-25 23:28:35 +0000133 if (ts->pchan == GSM_PCHAN_NONE) {
134 ts->pchan = pchan;
Harald Welte4b634542008-12-27 01:55:51 +0000135 /* set channel attribute on OML */
Harald Welte21bd3a52009-08-10 12:21:22 +0200136 abis_nm_set_channel_attr(ts, abis_nm_chcomb4pchan(pchan));
Harald Welte8470bf22008-12-25 23:28:35 +0000137 return ts;
138 }
139 }
140 }
141 return NULL;
142}
143
144/* Free a physical channel (TS) */
145void ts_free(struct gsm_bts_trx_ts *ts)
146{
147 ts->pchan = GSM_PCHAN_NONE;
148}
149
150static const u_int8_t subslots_per_pchan[] = {
151 [GSM_PCHAN_NONE] = 0,
152 [GSM_PCHAN_CCCH] = 0,
153 [GSM_PCHAN_CCCH_SDCCH4] = 4,
154 [GSM_PCHAN_TCH_F] = 1,
155 [GSM_PCHAN_TCH_H] = 2,
Harald Welte4bfdfe72009-06-10 23:11:52 +0800156 [GSM_PCHAN_SDCCH8_SACCH8C] = 8,
Harald Welteb908cb72009-12-22 13:09:29 +0100157 /* FIXME: what about dynamic TCH_F_TCH_H ? */
Harald Welte8470bf22008-12-25 23:28:35 +0000158};
159
160static struct gsm_lchan *
Harald Weltefc0d9522009-08-10 13:46:55 +0200161_lc_find_trx(struct gsm_bts_trx *trx, enum gsm_phys_chan_config pchan)
Harald Welte8470bf22008-12-25 23:28:35 +0000162{
Harald Welte8470bf22008-12-25 23:28:35 +0000163 struct gsm_bts_trx_ts *ts;
Harald Welte88367262009-08-10 13:25:55 +0200164 int j, ss;
165
Harald Welte4c704542009-12-24 10:10:16 +0100166 if (!trx_is_usable(trx))
167 return NULL;
168
Harald Weltefc0d9522009-08-10 13:46:55 +0200169 for (j = 0; j < 8; j++) {
170 ts = &trx->ts[j];
Harald Welte4c704542009-12-24 10:10:16 +0100171 if (!ts_is_usable(ts))
172 continue;
Harald Weltefc0d9522009-08-10 13:46:55 +0200173 if (ts->pchan != pchan)
174 continue;
175 /* check if all sub-slots are allocated yet */
176 for (ss = 0; ss < subslots_per_pchan[pchan]; ss++) {
177 struct gsm_lchan *lc = &ts->lchan[ss];
Harald Welte (local)3e460312009-12-27 18:12:29 +0100178 if (lc->type == GSM_LCHAN_NONE &&
179 lc->state == LCHAN_S_NONE)
Harald Weltefc0d9522009-08-10 13:46:55 +0200180 return lc;
Harald Welte8470bf22008-12-25 23:28:35 +0000181 }
182 }
Harald Weltefc0d9522009-08-10 13:46:55 +0200183 return NULL;
184}
185
186static struct gsm_lchan *
187_lc_find_bts(struct gsm_bts *bts, enum gsm_phys_chan_config pchan)
188{
189 struct gsm_bts_trx *trx;
190 struct gsm_bts_trx_ts *ts;
191 struct gsm_lchan *lc;
192
193 if (bts->chan_alloc_reverse) {
194 llist_for_each_entry_reverse(trx, &bts->trx_list, list) {
195 lc = _lc_find_trx(trx, pchan);
196 if (lc)
197 return lc;
198 }
199 } else {
200 llist_for_each_entry(trx, &bts->trx_list, list) {
201 lc = _lc_find_trx(trx, pchan);
202 if (lc)
203 return lc;
204 }
205 }
206
Harald Welte8470bf22008-12-25 23:28:35 +0000207 /* we cannot allocate more of these */
208 if (pchan == GSM_PCHAN_CCCH_SDCCH4)
209 return NULL;
210
211 /* if we've reached here, we need to allocate a new physical
212 * channel for the logical channel type requested */
213 ts = ts_alloc(bts, pchan);
214 if (!ts) {
215 /* no more radio resources */
216 return NULL;
217 }
218 return &ts->lchan[0];
219}
220
221/* Allocate a logical channel */
222struct gsm_lchan *lchan_alloc(struct gsm_bts *bts, enum gsm_chan_t type)
223{
224 struct gsm_lchan *lchan = NULL;
Harald Welte65676fe2009-08-10 14:44:24 +0200225 enum gsm_phys_chan_config first, second;
Harald Welte8470bf22008-12-25 23:28:35 +0000226
227 switch (type) {
228 case GSM_LCHAN_SDCCH:
Harald Welte65676fe2009-08-10 14:44:24 +0200229 if (bts->chan_alloc_reverse) {
230 first = GSM_PCHAN_SDCCH8_SACCH8C;
231 second = GSM_PCHAN_CCCH_SDCCH4;
232 } else {
233 first = GSM_PCHAN_CCCH_SDCCH4;
234 second = GSM_PCHAN_SDCCH8_SACCH8C;
235 }
236
237 lchan = _lc_find_bts(bts, first);
Harald Welte8470bf22008-12-25 23:28:35 +0000238 if (lchan == NULL)
Harald Welte65676fe2009-08-10 14:44:24 +0200239 lchan = _lc_find_bts(bts, second);
Harald Welte8470bf22008-12-25 23:28:35 +0000240 break;
241 case GSM_LCHAN_TCH_F:
Harald Weltefc0d9522009-08-10 13:46:55 +0200242 lchan = _lc_find_bts(bts, GSM_PCHAN_TCH_F);
Harald Welte8470bf22008-12-25 23:28:35 +0000243 break;
244 case GSM_LCHAN_TCH_H:
Harald Weltefc0d9522009-08-10 13:46:55 +0200245 lchan =_lc_find_bts(bts, GSM_PCHAN_TCH_H);
Harald Welte210c8502009-12-12 20:58:20 +0100246 /* If we don't have TCH/H available, fall-back to TCH/F */
Harald Welte487e6be2009-12-12 21:16:38 +0100247 if (!lchan) {
Harald Welte210c8502009-12-12 20:58:20 +0100248 lchan = _lc_find_bts(bts, GSM_PCHAN_TCH_F);
Harald Welte487e6be2009-12-12 21:16:38 +0100249 type = GSM_LCHAN_TCH_F;
250 }
Harald Welte8470bf22008-12-25 23:28:35 +0000251 break;
252 default:
Harald Welteb1d4c8e2009-12-17 23:10:46 +0100253 LOGP(DRLL, LOGL_ERROR, "Unknown gsm_chan_t %u\n", type);
Harald Welte8470bf22008-12-25 23:28:35 +0000254 }
255
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000256 if (lchan) {
Harald Welte8470bf22008-12-25 23:28:35 +0000257 lchan->type = type;
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000258 lchan->use_count = 0;
259
Holger Hans Peter Freyther5ba6f482009-10-28 14:23:39 +0100260 /* clear sapis */
Holger Hans Peter Freyther45b02432009-11-18 22:59:51 +0100261 memset(lchan->sapis, 0, ARRAY_SIZE(lchan->sapis));
Holger Hans Peter Freyther5ba6f482009-10-28 14:23:39 +0100262
Holger Hans Peter Freytherea528022009-11-18 22:57:02 +0100263 /* clear multi rate config */
264 memset(&lchan->mr_conf, 0, sizeof(lchan->mr_conf));
265
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000266 /* Configure the time and start it so it will be closed */
267 lchan->release_timer.cb = auto_release_channel;
268 lchan->release_timer.data = lchan;
Harald Welteff117a82009-05-23 05:22:08 +0000269 bsc_schedule_timer(&lchan->release_timer, LCHAN_RELEASE_TIMEOUT);
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000270 }
Harald Welte8470bf22008-12-25 23:28:35 +0000271
272 return lchan;
273}
274
275/* Free a logical channel */
276void lchan_free(struct gsm_lchan *lchan)
277{
Harald Welted12b0fd2009-12-15 21:36:05 +0100278 int i;
279
Harald Welte8470bf22008-12-25 23:28:35 +0000280 lchan->type = GSM_LCHAN_NONE;
Holger Freyther12aa50d2009-01-01 18:02:05 +0000281 if (lchan->subscr) {
282 subscr_put(lchan->subscr);
Holger Hans Peter Freytherba925872009-10-27 10:42:53 +0100283 lchan->subscr = NULL;
Holger Freyther12aa50d2009-01-01 18:02:05 +0000284 }
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000285
Holger Freyther7c19f742009-06-06 13:54:35 +0000286 /* We might kill an active channel... */
Harald Weltec627afc2009-01-09 21:39:17 +0000287 if (lchan->use_count != 0) {
Holger Freyther7c19f742009-06-06 13:54:35 +0000288 dispatch_signal(SS_LCHAN, S_LCHAN_UNEXPECTED_RELEASE, lchan);
Harald Weltec627afc2009-01-09 21:39:17 +0000289 lchan->use_count = 0;
290 }
291
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000292 /* stop the timer */
Harald Welteff117a82009-05-23 05:22:08 +0000293 bsc_del_timer(&lchan->release_timer);
Sylvain Munautf77af1f2009-12-21 01:11:25 +0100294 bsc_del_timer(&lchan->T3101);
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000295
Harald Welted12b0fd2009-12-15 21:36:05 +0100296 /* clear cached measuement reports */
297 lchan->meas_rep_idx = 0;
298 for (i = 0; i < ARRAY_SIZE(lchan->meas_rep); i++) {
299 lchan->meas_rep[i].flags = 0;
300 lchan->meas_rep[i].nr = 0;
301 }
Harald Weltef7c28b02009-12-21 13:30:17 +0100302 for (i = 0; i < ARRAY_SIZE(lchan->neigh_meas); i++)
303 lchan->neigh_meas[i].arfcn = 0;
Harald Welted12b0fd2009-12-15 21:36:05 +0100304
Harald Welte8470bf22008-12-25 23:28:35 +0000305 /* FIXME: ts_free() the timeslot, if we're the last logical
306 * channel using it */
307}
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000308
Holger Freyther67b4b9a2009-01-01 03:46:11 +0000309/* Consider releasing the channel now */
310int lchan_auto_release(struct gsm_lchan *lchan)
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000311{
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000312 if (lchan->use_count > 0) {
Holger Freyther67b4b9a2009-01-01 03:46:11 +0000313 return 0;
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000314 }
315
Holger Freythere64a7a32009-02-06 21:55:37 +0000316 /* Assume we have GSM04.08 running and send a release */
317 if (lchan->subscr) {
318 gsm48_send_rr_release(lchan);
319 }
320
Holger Freyther67b4b9a2009-01-01 03:46:11 +0000321 /* spoofed? message */
Harald Welteb1d4c8e2009-12-17 23:10:46 +0100322 if (lchan->use_count < 0)
323 LOGP(DRLL, LOGL_ERROR, "Channel count is negative: %d\n",
324 lchan->use_count);
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000325
Harald Welte44227dd2009-02-01 22:25:58 +0000326 DEBUGP(DRLL, "Recycling the channel with: %d (%x)\n", lchan->nr, lchan->nr);
Harald Welted2dc1de2009-08-08 13:15:07 +0200327 rsl_release_request(lchan, 0);
Holger Freyther67b4b9a2009-01-01 03:46:11 +0000328 return 1;
329}
330
331/* Auto release the channel when the use count is zero */
332static void auto_release_channel(void *_lchan)
333{
334 struct gsm_lchan *lchan = _lchan;
335
336 if (!lchan_auto_release(lchan))
Harald Welteff117a82009-05-23 05:22:08 +0000337 bsc_schedule_timer(&lchan->release_timer, LCHAN_RELEASE_TIMEOUT);
Holger Freytherc6ea9db2008-12-30 19:18:21 +0000338}
339
Holger Freytherd0e38c32009-01-04 03:48:30 +0000340struct gsm_lchan* lchan_find(struct gsm_bts *bts, struct gsm_subscriber *subscr) {
Harald Weltee441d9c2009-06-21 16:17:15 +0200341 struct gsm_bts_trx *trx;
342 int ts_no, lchan_no;
Holger Freytherd0e38c32009-01-04 03:48:30 +0000343
Harald Weltee441d9c2009-06-21 16:17:15 +0200344 llist_for_each_entry(trx, &bts->trx_list, list) {
Holger Freytherd0e38c32009-01-04 03:48:30 +0000345 for (ts_no = 0; ts_no < 8; ++ts_no) {
346 for (lchan_no = 0; lchan_no < TS_MAX_LCHAN; ++lchan_no) {
347 struct gsm_lchan *lchan =
Harald Weltee441d9c2009-06-21 16:17:15 +0200348 &trx->ts[ts_no].lchan[lchan_no];
Holger Freytherd0e38c32009-01-04 03:48:30 +0000349 if (subscr == lchan->subscr)
350 return lchan;
351 }
352 }
353 }
354
355 return NULL;
356}
Harald Welte1a6f7982009-08-09 18:52:33 +0200357
358struct gsm_lchan *lchan_for_subscr(struct gsm_subscriber *subscr)
359{
360 struct gsm_bts *bts;
361 struct gsm_network *net = subscr->net;
362 struct gsm_lchan *lchan;
363
364 llist_for_each_entry(bts, &net->bts_list, list) {
365 lchan = lchan_find(bts, subscr);
366 if (lchan)
367 return lchan;
368 }
369
Holger Hans Peter Freytherba925872009-10-27 10:42:53 +0100370 return NULL;
Harald Welte1a6f7982009-08-09 18:52:33 +0200371}
Harald Welteb908cb72009-12-22 13:09:29 +0100372
373void bts_chan_load(struct pchan_load *cl, const struct gsm_bts *bts)
374{
375 struct gsm_bts_trx *trx;
376
377 llist_for_each_entry(trx, &bts->trx_list, list) {
378 int i;
379
380 /* skip administratively deactivated tranxsceivers */
381 if (trx->nm_state.availability != NM_AVSTATE_OK ||
382 trx->bb_transc.nm_state.availability != NM_AVSTATE_OK)
383 continue;
384
385 for (i = 0; i < ARRAY_SIZE(trx->ts); i++) {
386 struct gsm_bts_trx_ts *ts = &trx->ts[i];
387 struct load_counter *pl = &cl->pchan[ts->pchan];
388 int j;
389
390 /* skip administratively deactivated timeslots */
391 if (ts->nm_state.availability != NM_AVSTATE_OK)
392 continue;
393
394 for (j = 0; j < subslots_per_pchan[ts->pchan]; j++) {
395 struct gsm_lchan *lchan = &ts->lchan[j];
396
397 pl->total++;
398
399 switch (lchan->state) {
400 case LCHAN_S_NONE:
401 break;
402 default:
403 pl->used++;
404 break;
405 }
406 }
407 }
408 }
409}
410
411void network_chan_load(struct pchan_load *pl, struct gsm_network *net)
412{
413 struct gsm_bts *bts;
414
415 memset(pl, 0, sizeof(*pl));
416
417 llist_for_each_entry(bts, &net->bts_list, list)
418 bts_chan_load(pl, bts);
419}