drivers/media/dvb-frontends/cxd2880/cxd2880_common.c

   1 /*
   2  * cxd2880_common.c
   3  * Sony CXD2880 DVB-T2/T tuner + demodulator driver
   4  * common functions
   5  *
   6  * Copyright (C) 2016, 2017 Sony Semiconductor Solutions Corporation
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; version 2 of the License.
  11  *
  12  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  13  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  14  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
  15  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  16  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  17  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  18  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  19  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  20  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  21  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  22  *
  23  * You should have received a copy of the GNU General Public License along
  24  * with this program; if not, see <http://www.gnu.org/licenses/>.
  25  */
  26
  27 #include "cxd2880_common.h"
  28
  29 #define MASKUPPER(n) (((n) == 0) ? 0 : (0xFFFFFFFFU << (32 - (n))))
  30 #define MASKLOWER(n) (((n) == 0) ? 0 : (0xFFFFFFFFU >> (32 - (n))))
  31
  32 int cxd2880_convert2s_complement(u32 value, u32 bitlen)
  33 {
  34         if ((bitlen == 0) || (bitlen >= 32))
  35                 return (int)value;
  36
  37         if (value & (u32)(1 << (bitlen - 1)))
  38                 return (int)(MASKUPPER(32 - bitlen) | value);
  39         else
  40                 return (int)(MASKLOWER(bitlen) & value);
  41 }
  42
  43 u32 cxd2880_bit_split_from_byte_array(u8 *array, u32 start_bit, u32 bit_num)
  44 {
  45         u32 value = 0;
  46         u8 *array_read;
  47         u8 bit_read;
  48         u32 len_remain;
  49
  50         if (!array)
  51                 return 0;
  52         if ((bit_num == 0) || (bit_num > 32))
  53                 return 0;
  54
  55         array_read = array + (start_bit / 8);
  56         bit_read = (u8)(start_bit % 8);
  57         len_remain = bit_num;
  58
  59         if (bit_read != 0) {
  60                 if (((int)len_remain) <= 8 - bit_read) {
  61                         value = (*array_read) >> ((8 - bit_read) - len_remain);
  62                         len_remain = 0;
  63                 } else {
  64                         value = *array_read++;
  65                         len_remain -= 8 - bit_read;
  66                 }
  67         }
  68
  69         while (len_remain > 0) {
  70                 if (len_remain < 8) {
  71                         value <<= len_remain;
  72                         value |= (*array_read++ >> (8 - len_remain));
  73                         len_remain = 0;
  74                 } else {
  75                         value <<= 8;
  76                         value |= (u32)(*array_read++);
  77                         len_remain -= 8;
  78                 }
  79         }
  80
  81         value &= MASKLOWER(bit_num);
  82
  83         return value;
  84 }