It represent the bitmask for events supported by the device.

Sample of devices entry for a AT Keyboard:

I: Bus= Vendor= Product= Version=ab41

N: Name="AT Translated Set 2 keyboard"

P: Phys=isa0060/serio0/input0

S: Sysfs=/devices/platform/i8042/serio0/input/input2

U: Uniq=

H: Handlers=sysrq kbd event2

B: PROP=

B: EV=

B: KEY=       500f   f900d401 feffffdf ffefffff ffffffff fffffffe

B: MSC=

B: LED=

The B in front stands for bitmap, N, P, S, U, H are simply first letter in corresponding name value and I is for ID. In ordered fashion:

    I => @id: id of the device (struct input_id)

        Bus     => id.bustype

        Vendor  => id.vendor

        Product => id.product

        Version => id.version

    N => name of the device.

    P => physical path to the device in the system hierarchy.

    S => sysfs path.

    U => unique identification code for the device (if device has it).

    H => list of input handles associated with the device.

    B => bitmaps

        PROP => device properties and quirks.

        EV   => types of events supported by the device.

        KEY  => keys/buttons this device has.

        MSC  => miscellaneous events supported by the device.

        LED  => leds present on the device.

Bitmasks

As you know computers deal in binary, so:

 =

 =

 =

 =

 =

...

So if i have a bitmap with value  that one would hold bits  and  in other word one can give each number a name and check if they correspond to a value.

E.g.

A = ,

B = ,

C = ,  

Then if I have MYVAR =  which is  in binary this would check out:

MYVAR & A == TRUE   ( &  => )

MYVAR & B == FALSE  ( &  => )

MYVAR & C == TRUE   ( &  =>  )

Thus my var has A and C.

The kernel uses a bit more sophisticated/complex way, and set bits by offset. One reason being that more bits then is available in one computer (CPU) integer is used. For example look at the KEY bitmap.

So, if we say:

A =

B =

C =

...

And then

target = ;

set_bit(A, target);  => target ==

set_bit(C, target);  => target ==  

Decoding 

The value  is a hexadecimal. As binary it gives us:

0x120013 ==       binary

Numbered from right they are:

                              <= offset ('s)

        <= offset (counted from right)

        <= binary

Set bits are:

   , , , , 

Then check input.h you find that they correspond to:

     EV_SYN (0x00)

     EV_KEY (0x01)

     EV_MSC (0x04)

    EV_LED (0x11)

    EV_REP (0x14)

To check what they mean a quick introduction is given by kernel Documentation.

* EV_SYN:

  - Used as markers to separate events. Events may be separated in time or in

    space, such as with the multitouch protocol.

* EV_KEY:

  - Used to describe state changes of keyboards, buttons, or other key-like

    devices.

* EV_MSC:

  - Used to describe miscellaneous input data that do not fit into other types.

* EV_LED:

  - Used to turn LEDs on devices on and off.

* EV_REP:

  - Used for autorepeating devices.

This, "EDIT 2 (continued):" in particular, might be of interest.