LCOM1920-T02G10

#ifndef __BOARD_H__

#define __BOARD_H__

#include <string.h>

/* 

  Utility functions to access/parse the board_id defined in the machine

  struct in include/minix/type.h.

   Identifier for the board 

     [31:28] Architecture.  (MINIX_BOARD_ARCH)

     [27:24] Architecture variant (MINIX_BOARD_ARCH_VARIANT) VERSION e.g. ARMV7 

     [23:16] Vendor/Soc (EG TI )  (MINIX_BOARD_VENDOR) 

     [15:8]  Board      (EG Beagle bone , beagle board ) (MINIX_BOARD)

     [7:0]   Board variant (EG BealgeBone white v.s. BeagleBone black ) (MINIX_BOARD_VARIANT)

*/

#define MINIX_BOARD_ARCH_SHIFT         (28)

#define MINIX_BOARD_ARCH_VARIANT_SHIFT (24)

#define MINIX_BOARD_VENDOR_SHIFT       (16)

#define MINIX_BOARD_SHIFT              (8)

#define MINIX_BOARD_VARIANT_SHIFT      (0)

/* 4 bits */

#define MINIX_BOARD_ARCH_MASK \

        (0XF << MINIX_BOARD_ARCH_SHIFT)

/* 4 bits */

#define MINIX_BOARD_ARCH_VARIANT_MASK \

        (0XF << MINIX_BOARD_ARCH_VARIANT_SHIFT)

/* 8 bits */

#define MINIX_BOARD_VENDOR_MASK \

        (0XFF << MINIX_BOARD_VENDOR_SHIFT)

/* 8 bits */

#define MINIX_BOARD_MASK \

        (0XFF << MINIX_BOARD_SHIFT)

/* 8 bits */

#define MINIX_BOARD_VARIANT_MASK \

        (0XFF << MINIX_BOARD_VARIANT_SHIFT)

#define MINIX_MK_BOARD_ARCH(v) \

        ((v << MINIX_BOARD_ARCH_SHIFT ) & MINIX_BOARD_ARCH_MASK)

#define MINIX_MK_BOARD_ARCH_VARIANT(v) \

        (( v << MINIX_BOARD_ARCH_VARIANT_SHIFT) & MINIX_BOARD_ARCH_VARIANT_MASK )

#define MINIX_MK_BOARD_VENDOR(v) \

        (( v << MINIX_BOARD_VENDOR_SHIFT) & MINIX_BOARD_VENDOR_MASK )

#define MINIX_MK_BOARD(v) \

        (( v << MINIX_BOARD_SHIFT) & MINIX_BOARD_MASK )

#define MINIX_MK_BOARD_VARIANT(v) \

        (( v << MINIX_BOARD_VARIANT_SHIFT) & MINIX_BOARD_VARIANT_MASK )

#define MINIX_BOARD_ARCH(v) \

        ((v & MINIX_BOARD_ARCH_MASK) >> MINIX_BOARD_ARCH_SHIFT )

#define MINIX_BOARD_ARCH_VARIANT(v) \

        (( v & MINIX_BOARD_ARCH_VARIANT_MASK) >> MINIX_BOARD_ARCH_VARIANT_SHIFT)

#define MINIX_BOARD_VENDOR(v) \

        (( v & MINIX_BOARD_VENDOR_MASK) >> MINIX_BOARD_VENDOR_SHIFT)

#define MINIX_BOARD(v) \

        (( v & MINIX_BOARD_MASK) >> MINIX_BOARD_SHIFT)

#define MINIX_BOARD_VARIANT(v) \

        (( v & MINIX_BOARD_VARIANT_MASK) >> MINIX_BOARD_VARIANT_SHIFT)

/* We want to make it possible to use masks and therefore only try to use bits */

#define MINIX_BOARD_ARCH_X86 MINIX_MK_BOARD_ARCH(1 << 0)

#define MINIX_BOARD_ARCH_ARM MINIX_MK_BOARD_ARCH(1 << 1)

#define MINIX_BOARD_ARCH_VARIANT_X86_GENERIC MINIX_MK_BOARD_ARCH_VARIANT(1<<0)

#define MINIX_BOARD_ARCH_VARIANT_ARM_ARMV6 MINIX_MK_BOARD_ARCH_VARIANT(1<<1)

#define MINIX_BOARD_ARCH_VARIANT_ARM_ARMV7 MINIX_MK_BOARD_ARCH_VARIANT(1<<2)

#define MINIX_BOARD_VENDOR_INTEL MINIX_MK_BOARD_VENDOR(1<<0)

#define MINIX_BOARD_VENDOR_TI MINIX_MK_BOARD_VENDOR(1<<1)

#define MINIX_BOARD_GENERIC MINIX_MK_BOARD(1<<0)

/* BeagleBoard XM */

#define MINIX_BOARD_BBXM MINIX_MK_BOARD(1<<1)

/* BeagleBone (Black and* white) */

#define MINIX_BOARD_BB MINIX_MK_BOARD(1<<2)

/* Only  one  of a kind */

#define MINIX_BOARD_VARIANT_GENERIC MINIX_MK_BOARD_VARIANT(1<<0)

/* BeagleBone White */

#define MINIX_BOARD_VARIANT_BBW MINIX_MK_BOARD_VARIANT(1<<1)

/* BeagleBone Black */

#define MINIX_BOARD_VARIANT_BBB MINIX_MK_BOARD_VARIANT(1<<2)

#define BOARD_ID_INTEL \

        ( MINIX_BOARD_ARCH_X86 \

        | MINIX_BOARD_ARCH_VARIANT_X86_GENERIC \

        | MINIX_BOARD_VENDOR_INTEL \

        | MINIX_BOARD_GENERIC \

        | MINIX_BOARD_VARIANT_GENERIC\

        )

#define BOARD_ID_BBXM \

        ( MINIX_BOARD_ARCH_ARM \

        | MINIX_BOARD_ARCH_VARIANT_ARM_ARMV7 \

        | MINIX_BOARD_VENDOR_TI \

        | MINIX_BOARD_BBXM \

        | MINIX_BOARD_VARIANT_GENERIC\

        )

#define BOARD_ID_BBW \

        ( MINIX_BOARD_ARCH_ARM \

        | MINIX_BOARD_ARCH_VARIANT_ARM_ARMV7 \

        | MINIX_BOARD_VENDOR_TI \

        | MINIX_BOARD_BB \

        | MINIX_BOARD_VARIANT_BBW\

        )

#define BOARD_ID_BBB \

        ( MINIX_BOARD_ARCH_ARM \

        | MINIX_BOARD_ARCH_VARIANT_ARM_ARMV7 \

        | MINIX_BOARD_VENDOR_TI \

        | MINIX_BOARD_BB \

        | MINIX_BOARD_VARIANT_BBB\

        )

#define BOARD_IS_BBXM(v) \

                ( (BOARD_ID_BBXM & ~MINIX_BOARD_VARIANT_MASK) == (v & ~MINIX_BOARD_VARIANT_MASK))

/* Either one of the known BeagleBones */

#define BOARD_IS_BB(v)   \

                ( (BOARD_ID_BBW & ~MINIX_BOARD_VARIANT_MASK) == (v & ~MINIX_BOARD_VARIANT_MASK))

#define BOARD_IS_BBW(v)  ( v == BOARD_ID_BBW)

#define BOARD_IS_BBB(v)  ( v == BOARD_ID_BBB)

#define BOARD_FILTER_BBXM_VALUE (BOARD_ID_BBXM)

#define BOARD_FILTER_BBXM_MASK  \

                (MINIX_BOARD_ARCH_MASK \

                | MINIX_BOARD_ARCH_VARIANT_MASK \

                | MINIX_BOARD_VENDOR_MASK \

                | MINIX_BOARD_MASK \

                | MINIX_BOARD_VARIANT_MASK)

#define BOARD_FILTER_BB_VALUE   (BOARD_ID_BBW & ~MINIX_BOARD_VARIANT_MASK)

#define BOARD_FILTER_BB_MASK    \

                (MINIX_BOARD_ARCH_MASK \

                | MINIX_BOARD_ARCH_VARIANT_MASK \

                | MINIX_BOARD_VENDOR_MASK \

                | MINIX_BOARD_MASK )

struct shortname2id

{

        const char name[15];

        unsigned int id;

};

/* mapping from fields given by the bootloader to board id's */

static struct shortname2id shortname2id[] = {

        {.name = "BBXM",.id = BOARD_ID_BBXM},

        {.name = "A335BONE",.id = BOARD_ID_BBW},

        {.name = "A335BNLT",.id = BOARD_ID_BBB},

};

struct board_id2name

{

        unsigned int id;

        const char name[40];

};

/* how to convert a BOARD id to a board name */

static struct board_id2name board_id2name[] = {

        {.id = BOARD_ID_INTEL,.name = "X86-I586-GENERIC-GENERIC-GENERIC"},

        {.id = BOARD_ID_BBXM,.name = "ARM-ARMV7-TI-BBXM-GENERIC"},

        {.id = BOARD_ID_BBW,.name = "ARM-ARMV7-TI-BB-WHITE"},

        {.id = BOARD_ID_BBB,.name = "ARM-ARMV7-TI-BB-BLACK"},

};

struct board_arch2arch

{

        unsigned int board_arch;

        const char arch[40];

};

/* Mapping from board_arch to arch */

static struct board_arch2arch board_arch2arch[] = {

        {.board_arch = MINIX_BOARD_ARCH_ARM ,.arch = "earm"},

        {.board_arch = MINIX_BOARD_ARCH_X86 ,.arch = "i386"},

};

/* returns 0 if no board was found that match that id */

static int

get_board_id_by_short_name(const char *name)

{

        int x;

        for (x = 0; x < sizeof(shortname2id) / sizeof(shortname2id[0]); x++) {

                if (strncmp(name, shortname2id[x].name, 15) == 0) {

                        return shortname2id[x].id;

                }

        }

        return 0;

}

/* returns 0 if no board was found that match that id */

static int

get_board_id_by_name(const char *name)

{

        int x;

        for (x = 0; x < sizeof(board_id2name) / sizeof(board_id2name[0]); x++) {

                if (strncmp(name, board_id2name[x].name, 40) == 0) {

                        return board_id2name[x].id;

                }

        }

        return 0;

}

/* convert a board id to a board name to use later 

   returns NULL if no board was found that match that id */

static const char *

get_board_name(unsigned int id)

{

        int x;

        for (x = 0; x < sizeof(board_id2name) / sizeof(board_id2name[0]); x++) {

                if (board_id2name[x].id == id) {

                        return board_id2name[x].name;

                }

        }

        return NULL;

}

/* convert a board id to a board name to use later 

   returns NULL if no board was found that match that id */

static const char *

get_board_arch_name(unsigned int id)

{

        int x;

        for (x = 0; x < sizeof(board_arch2arch) / sizeof(board_arch2arch[0]); x++) {

                if (board_arch2arch[x].board_arch == (id & MINIX_BOARD_ARCH_MASK) ) {

                        return board_arch2arch[x].arch;

                }

        }

        return NULL;

}

#endif