drivers/uwb/drp-avail.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Ultra Wide Band
   4  * DRP availability management
   5  *
   6  * Copyright (C) 2005-2006 Intel Corporation
   7  * Reinette Chatre <reinette.chatre@intel.com>
   8  * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
   9  *
  10  * Manage DRP Availability (the MAS available for DRP
  11  * reservations). Thus:
  12  *
  13  * - Handle DRP Availability Change notifications
  14  *
  15  * - Allow the reservation manager to indicate MAS reserved/released
  16  *   by local (owned by/targeted at the radio controller)
  17  *   reservations.
  18  *
  19  * - Based on the two sources above, generate a DRP Availability IE to
  20  *   be included in the beacon.
  21  *
  22  * See also the documentation for struct uwb_drp_avail.
  23  */
  24
  25 #include <linux/errno.h>
  26 #include <linux/module.h>
  27 #include <linux/device.h>
  28 #include <linux/bitmap.h>
  29 #include "uwb-internal.h"
  30
  31 /**
  32  * uwb_drp_avail_init - initialize an RC's MAS availability
  33  *
  34  * All MAS are available initially.  The RC will inform use which
  35  * slots are used for the BP (it may change in size).
  36  */
  37 void uwb_drp_avail_init(struct uwb_rc *rc)
  38 {
  39         bitmap_fill(rc->drp_avail.global, UWB_NUM_MAS);
  40         bitmap_fill(rc->drp_avail.local, UWB_NUM_MAS);
  41         bitmap_fill(rc->drp_avail.pending, UWB_NUM_MAS);
  42 }
  43
  44 /*
  45  * Determine MAS available for new local reservations.
  46  *
  47  * avail = global & local & pending
  48  */
  49 void uwb_drp_available(struct uwb_rc *rc, struct uwb_mas_bm *avail)
  50 {
  51         bitmap_and(avail->bm, rc->drp_avail.global, rc->drp_avail.local, UWB_NUM_MAS);
  52         bitmap_and(avail->bm, avail->bm, rc->drp_avail.pending, UWB_NUM_MAS);
  53 }
  54
  55 /**
  56  * uwb_drp_avail_reserve_pending - reserve MAS for a new reservation
  57  * @rc: the radio controller
  58  * @mas: the MAS to reserve
  59  *
  60  * Returns 0 on success, or -EBUSY if the MAS requested aren't available.
  61  */
  62 int uwb_drp_avail_reserve_pending(struct uwb_rc *rc, struct uwb_mas_bm *mas)
  63 {
  64         struct uwb_mas_bm avail;
  65
  66         uwb_drp_available(rc, &avail);
  67         if (!bitmap_subset(mas->bm, avail.bm, UWB_NUM_MAS))
  68                 return -EBUSY;
  69
  70         bitmap_andnot(rc->drp_avail.pending, rc->drp_avail.pending, mas->bm, UWB_NUM_MAS);
  71         return 0;
  72 }
  73
  74 /**
  75  * uwb_drp_avail_reserve - reserve MAS for an established reservation
  76  * @rc: the radio controller
  77  * @mas: the MAS to reserve
  78  */
  79 void uwb_drp_avail_reserve(struct uwb_rc *rc, struct uwb_mas_bm *mas)
  80 {
  81         bitmap_or(rc->drp_avail.pending, rc->drp_avail.pending, mas->bm, UWB_NUM_MAS);
  82         bitmap_andnot(rc->drp_avail.local, rc->drp_avail.local, mas->bm, UWB_NUM_MAS);
  83         rc->drp_avail.ie_valid = false;
  84 }
  85
  86 /**
  87  * uwb_drp_avail_release - release MAS from a pending or established reservation
  88  * @rc: the radio controller
  89  * @mas: the MAS to release
  90  */
  91 void uwb_drp_avail_release(struct uwb_rc *rc, struct uwb_mas_bm *mas)
  92 {
  93         bitmap_or(rc->drp_avail.local, rc->drp_avail.local, mas->bm, UWB_NUM_MAS);
  94         bitmap_or(rc->drp_avail.pending, rc->drp_avail.pending, mas->bm, UWB_NUM_MAS);
  95         rc->drp_avail.ie_valid = false;
  96         uwb_rsv_handle_drp_avail_change(rc);
  97 }
  98
  99 /**
 100  * uwb_drp_avail_ie_update - update the DRP Availability IE
 101  * @rc: the radio controller
 102  *
 103  * avail = global & local
 104  */
 105 void uwb_drp_avail_ie_update(struct uwb_rc *rc)
 106 {
 107         struct uwb_mas_bm avail;
 108
 109         bitmap_and(avail.bm, rc->drp_avail.global, rc->drp_avail.local, UWB_NUM_MAS);
 110
 111         rc->drp_avail.ie.hdr.element_id = UWB_IE_DRP_AVAILABILITY;
 112         rc->drp_avail.ie.hdr.length = UWB_NUM_MAS / 8;
 113         uwb_mas_bm_copy_le(rc->drp_avail.ie.bmp, &avail);
 114         rc->drp_avail.ie_valid = true;
 115 }
 116
 117 /**
 118  * Create an unsigned long from a buffer containing a byte stream.
 119  *
 120  * @array: pointer to buffer
 121  * @itr:   index of buffer from where we start
 122  * @len:   the buffer's remaining size may not be exact multiple of
 123  *         sizeof(unsigned long), @len is the length of buffer that needs
 124  *         to be converted. This will be sizeof(unsigned long) or smaller
 125  *         (BUG if not). If it is smaller then we will pad the remaining
 126  *         space of the result with zeroes.
 127  */
 128 static
 129 unsigned long get_val(u8 *array, size_t itr, size_t len)
 130 {
 131         unsigned long val = 0;
 132         size_t top = itr + len;
 133
 134         BUG_ON(len > sizeof(val));
 135
 136         while (itr < top) {
 137                 val <<= 8;
 138                 val |= array[top - 1];
 139                 top--;
 140         }
 141         val <<= 8 * (sizeof(val) - len); /* padding */
 142         return val;
 143 }
 144
 145 /**
 146  * Initialize bitmap from data buffer.
 147  *
 148  * The bitmap to be converted could come from a IE, for example a
 149  * DRP Availability IE.
 150  * From ECMA-368 1.0 [16.8.7]: "
 151  * octets: 1            1               N * (0 to 32)
 152  *         Element ID   Length (=N)     DRP Availability Bitmap
 153  *
 154  * The DRP Availability Bitmap field is up to 256 bits long, one
 155  * bit for each MAS in the superframe, where the least-significant
 156  * bit of the field corresponds to the first MAS in the superframe
 157  * and successive bits correspond to successive MASs."
 158  *
 159  * The DRP Availability bitmap is in octets from 0 to 32, so octet
 160  * 32 contains bits for MAS 1-8, etc. If the bitmap is smaller than 32
 161  * octets, the bits in octets not included at the end of the bitmap are
 162  * treated as zero. In this case (when the bitmap is smaller than 32
 163  * octets) the MAS represented range from MAS 1 to MAS (size of bitmap)
 164  * with the last octet still containing bits for MAS 1-8, etc.
 165  *
 166  * For example:
 167  * F00F0102 03040506 0708090A 0B0C0D0E 0F010203
 168  * ^^^^
 169  * ||||
 170  * ||||
 171  * |||\LSB of byte is MAS 9
 172  * ||\MSB of byte is MAS 16
 173  * |\LSB of first byte is MAS 1
 174  * \ MSB of byte is MAS 8
 175  *
 176  * An example of this encoding can be found in ECMA-368 Annex-D [Table D.11]
 177  *
 178  * The resulting bitmap will have the following mapping:
 179  *      bit position 0 == MAS 1
 180  *      bit position 1 == MAS 2
 181  *      ...
 182  *      bit position (UWB_NUM_MAS - 1) == MAS UWB_NUM_MAS
 183  *
 184  * @bmp_itr:    pointer to bitmap (can be declared with DECLARE_BITMAP)
 185  * @buffer:     pointer to buffer containing bitmap data in big endian
 186  *              format (MSB first)
 187  * @buffer_size:number of bytes with which bitmap should be initialized
 188  */
 189 static
 190 void buffer_to_bmp(unsigned long *bmp_itr, void *_buffer,
 191                    size_t buffer_size)
 192 {
 193         u8 *buffer = _buffer;
 194         size_t itr, len;
 195         unsigned long val;
 196
 197         itr = 0;
 198         while (itr < buffer_size) {
 199                 len = buffer_size - itr >= sizeof(val) ?
 200                         sizeof(val) : buffer_size - itr;
 201                 val = get_val(buffer, itr, len);
 202                 bmp_itr[itr / sizeof(val)] = val;
 203                 itr += sizeof(val);
 204         }
 205 }
 206
 207
 208 /**
 209  * Extract DRP Availability bitmap from the notification.
 210  *
 211  * The notification that comes in contains a bitmap of (UWB_NUM_MAS / 8) bytes
 212  * We convert that to our internal representation.
 213  */
 214 static
 215 int uwbd_evt_get_drp_avail(struct uwb_event *evt, unsigned long *bmp)
 216 {
 217         struct device *dev = &evt->rc->uwb_dev.dev;
 218         struct uwb_rc_evt_drp_avail *drp_evt;
 219         int result = -EINVAL;
 220
 221         /* Is there enough data to decode the event? */
 222         if (evt->notif.size < sizeof(*drp_evt)) {
 223                 dev_err(dev, "DRP Availability Change: Not enough "
 224                         "data to decode event [%zu bytes, %zu "
 225                         "needed]\n", evt->notif.size, sizeof(*drp_evt));
 226                 goto error;
 227         }
 228         drp_evt = container_of(evt->notif.rceb, struct uwb_rc_evt_drp_avail, rceb);
 229         buffer_to_bmp(bmp, drp_evt->bmp, UWB_NUM_MAS/8);
 230         result = 0;
 231 error:
 232         return result;
 233 }
 234
 235
 236 /**
 237  * Process an incoming DRP Availability notification.
 238  *
 239  * @evt:        Event information (packs the actual event data, which
 240  *              radio controller it came to, etc).
 241  *
 242  * @returns:    0 on success (so uwbd() frees the event buffer), < 0
 243  *              on error.
 244  *
 245  * According to ECMA-368 1.0 [16.8.7], bits set to ONE indicate that
 246  * the MAS slot is available, bits set to ZERO indicate that the slot
 247  * is busy.
 248  *
 249  * So we clear available slots, we set used slots :)
 250  *
 251  * The notification only marks non-availability based on the BP and
 252  * received DRP IEs that are not for this radio controller.  A copy of
 253  * this bitmap is needed to generate the real availability (which
 254  * includes local and pending reservations).
 255  *
 256  * The DRP Availability IE that this radio controller emits will need
 257  * to be updated.
 258  */
 259 int uwbd_evt_handle_rc_drp_avail(struct uwb_event *evt)
 260 {
 261         int result;
 262         struct uwb_rc *rc = evt->rc;
 263         DECLARE_BITMAP(bmp, UWB_NUM_MAS);
 264
 265         result = uwbd_evt_get_drp_avail(evt, bmp);
 266         if (result < 0)
 267                 return result;
 268
 269         mutex_lock(&rc->rsvs_mutex);
 270         bitmap_copy(rc->drp_avail.global, bmp, UWB_NUM_MAS);
 271         rc->drp_avail.ie_valid = false;
 272         uwb_rsv_handle_drp_avail_change(rc);
 273         mutex_unlock(&rc->rsvs_mutex);
 274
 275         uwb_rsv_sched_update(rc);
 276
 277         return 0;
 278 }