从寄存器中读取2位

Question

I'm looking at a datasheet specification of a NIC and it says:

bits 2:3 of register contain the NIC speed, 4 contains link state, etc. How can I isolate these bits using bitwise?

For example, I've seen the code to isolate the link state which is something like:

(link_reg & (1 << 4))>>4

But I don't quite get why the right shift. I must say, I'm still not fairly comfortable with the bitwise ops, even though I understand how to convert to binary and what each operation does, but it doesn't ring as practical.

Answer 1

It depends on what you want to do with that bit. The link state, call it L is in a variable/register somewhere

    43210
xxxxLxxxx

To isolate that bit you want to and it with a 1, a bitwise operation:

  xxLxxxx
& 0010000
=========
  00L0000

1<<4 = 1 with 4 zeros or 0b10000, the number you want to and with.

status&(1<<4) 

This will give a result of either zero or 0b10000. You can do a boolean comparison to determine if it is false (zero) or true (not zero)

if(status&(1<<4))
{
   //bit was on/one
}
else
{
   //bit was off/zero
}

If you want to have the result be a 1 or zero, you need to shift the result to the ones column

  (0b00L0000 >> 4) = 0b0000L

If the result of the and was zero then shifting still gives zero, if the result was 0b10000 then the shift right of 4 gives a 0b00001

so

(status&(1<<4))>>4 gives either a 1 or 0;

(xxxxLxxxx & (00001<<4))>>4 =
(xxxxLxxxx & (10000))>>4 = 
(0000L0000) >> 4 = 
0000L

Another way to do this using fewer operations is

(status>>4)&1;
xxxxLxxxx >> 4 = xxxxxxL
xxxxxxL & 00001 = 00000L

Answer 2

Easiest to look at some binary numbers.

Here's a possible register value, with the bit index underneath:

  00111010
  76543210

So, bit 4 is 1. How do we get just that bit? We construct a mask containing only that bit (which we can do by shifting a 1 into the right place, ie 1<<4 ), and use & :

  00111010
& 00010000
----------
  00010000

But we want a 0 or a 1. So, one way is to shift the result down: 00010000 >> 4 == 1 . Another alternative is !!val , which turns 0 into 0 and nonzero into 1 (note that this only works for single bits, not a two-bit value like the link speed).

Now, if you want bits 3:2, you can use a mask with both of those bits set. You can write 3 << 2 to get 00001100 (since 3 has two bits set). Then we & with it:

  00111010
& 00001100
----------
  00001000

and shift down by 2 to get 10 , the desired two bits. So, the statement to get the two-bit link speed would be (link_reg & (3<<2))>>2 .

Answer 3

you can use this to determine if the bit at position pos is set in val :

#define CHECK_BIT(val, pos) ((val) & (1U<<(pos)))

if (CHECK_BIT(reg, 4)) {
    /* bit 4 is set */
}

the bitwise and operator (&) sets each bit in the result to 1 if both operands have the corresponding bit set to 1. otherwise, the result bit is 0.

Answer 4

If you want to treat bits 2 and 3 (starting the count at 0) as a number, you can do this:

unsigned int n = (link_get & 0xF) >> 2;

The bitwise and with 15 (which is 0b1111 in binary) sets all but the bottom four bits to zero, and the following right-shift by 2 gets you the number in bits 2 and 3.

Answer 5

The problem is that isolating bits is not enough: you need to shift them to get the correct size order of the value.

In your example you have bit 2 and 3 for the size (I'm assuming that least significant is bit 0), it means that it is a value in range [0,3]. Now you can mask these bits with reg & (0x03<<2) or, converted, (reg & 0x12) but this is not enough:

reg   0110 1010 &
0x12  0000 1100
---------------
0x08  0000 1000

As you can see the result is 1000b which is 8, which is over the range. To solve this you need to shift back the result so that the least significant bit of the value you are interested in corresponds to the least significant bit of the containing byte:

0000 1000 >> 2 = 10b = 3

which now is correct.