File content as of revision 0:726fdf0062c6:

const uint8_t init_ges7620_register_array[][2] = {
                        {0xEF,0x00},
                        {0x37,0x07},
                        {0x38,0x17},
                        {0x39,0x06},
                        {0x42,0x01},
                        {0x46,0x2D},
                        {0x47,0x0F},
                        {0x48,0x3C},
                        {0x49,0x00},
                        {0x4A,0x1E},
                        {0x4C,0x20},
                        {0x51,0x10},
                        {0x5E,0x10},
                        {0x60,0x27},
                        {0x80,0x42},
                        {0x81,0x44},
                        {0x82,0x04},
                        {0x8B,0x01},
                        {0x90,0x06},
                        //{0x91,0x0A}
                        {0x95,0x0A},
                        {0x96,0x0C},
                        {0x97,0x05},
                        {0x9A,0x14},
                        {0x9C,0x3F},
                        {0xA5,0x19},
                        {0xCC,0x19},
                        {0xCD,0x0B},
                        {0xCE,0x13},
                        {0xCF,0x64},
                        {0xD0,0x21},
                        {0xEF,0x01},
                        {0x02,0x0F},
                        {0x03,0x10},
                        {0x04,0x02},
                        {0x25,0x01},
                        {0x27,0x39},
                        {0x28,0x7F},
                        {0x29,0x08},
                        {0x3E,0xFF},
                        {0x5E,0x3D},
                        {0x65,0x96},
                        {0x67,0x97},
                        {0x69,0xCD},
                        {0x6A,0x01},
                        {0x6D,0x2C},
                        {0x6E,0x01},
                        {0x72,0x01},
                        {0x73,0x35},
                        {0x77,0x01},
                        {0xEF,0x00},
};

#define INIT_Ges7620_REG_ARRAY_SIZE (sizeof(init_ges7620_register_array)/sizeof(init_ges7620_register_array[0]))

const uint8_t init_ges7630_register_array[][2] = {
                        {0xEF,0x00},
                        {0x07,0x01},
                        {0x10,0x01},
                        {0x11,0x31},
                        {0x13,0x07},
                        {0x14,0x17},
                        {0x15,0x06},
                        {0x42,0x01},
                        {0x46,0x2D},
                        {0x47,0x0F},
                        {0x48,0x4B},
                        {0x49,0x00},
                        {0x4A,0x4B},
                        {0x4C,0x12},
                        {0x4D,0x14},
                        {0x4E,0x30},
                        {0x4F,0x50},
                        {0x51,0x10},
                        {0x54,0x01},
                        {0x5F,0xFF},
                        {0x61,0x4C},
                        {0x80,0xCA},
                        {0x81,0xCC},
                        {0x85,0x00},
                        {0x88,0x05},
                        {0x89,0x18},
                        {0x8A,0x00},
                        {0x8B,0x01},
                        {0x90,0x06},
                        {0x93,0x0F},
                        {0x94,0x0F},
                        {0x95,0x0A},
                        {0x96,0x0C},
                        {0x97,0x05},
                        {0x99,0x20},
                        {0x9A,0x14},
                        {0x9C,0x3F},
                        {0xA5,0x11},
                        {0xCA,0x64},
                        {0xCF,0x01},
                        {0xE0,0x01},
                        {0xE1,0x04},
                        {0xE2,0x1E},
                        {0xE3,0xD6},
                        {0xE4,0x00},
                        {0xE5,0x0C},
                        {0xE6,0x0A},
                        {0xE7,0x00},
                        {0xE8,0x00},
                        {0xE9,0x00},
                        {0xEF,0x01},
                        {0x04,0x03},
                        {0x25,0x01},
                        {0x26,0x1C},
                        {0x27,0x0A},
                        {0x28,0x78},
                        {0x29,0x07},
                        {0x32,0x1C},
                        {0x33,0x1C},
                        {0x42,0x80},
                        {0x44,0x20},
                        {0x5E,0x74},
                        {0x5F,0x19},
                        {0x64,0x0A},
                        {0x65,0xA3},
                        {0x74,0x09},
                        {0x77,0x31},
                        {0x7E,0x01},
                        {0xEF,0x00},
};

#define INIT_Ges7630_REG_ARRAY_SIZE (sizeof(init_ges7630_register_array)/sizeof(init_ges7630_register_array[0]))

//default, 15cm operation distance settings
const uint8_t set1_ges7630_register_array[][2] = {
                        {0xEF,0x00},
                        {0x48,0x4B},
                        {0x49,0x00},
                        {0x4A,0x4B},
                        {0x4B,0x00},
                        {0xAA,0x1E},
                        {0xAB,0x1E},
                        {0xCA,0x63},
                        {0xEF,0x01},
                        {0x00,0x1D},
                        {0x01,0x1D},
                        {0x02,0x00},
                        {0x03,0x00},
                        {0x4A,0x1D},
                        {0x4B,0x1D},
                        {0x4C,0x00},
                        {0x4D,0x00},
                        {0xEF,0x00},
                        {0x93,0x0F},
                        {0x94,0x0F},
};

#define SET1_Ges7630_REG_ARRAY_SIZE (sizeof(set1_ges7630_register_array)/sizeof(set1_ges7630_register_array[0]))

//20cm operation distance settings
const uint8_t set2_ges7630_register_array[][2] = {
                        {0xEF,0x00},
                        {0x48,0x6B},
                        {0x49,0x00},
                        {0x4A,0x6B},
                        {0x4B,0x00},
                        {0xAA,0x1E},
                        {0xAB,0x1E},
                        {0xCA,0x63},
                        {0xEF,0x01},
                        {0x00,0x1D},
                        {0x01,0x1D},
                        {0x02,0x00},
                        {0x03,0x00},
                        {0x4A,0x1D},
                        {0x4B,0x1D},
                        {0x4C,0x00},
                        {0x4D,0x00},
                        {0xEF,0x00},                        
                        {0x93,0x0F},
                        {0x94,0x0F},
};

#define SET2_Ges7630_REG_ARRAY_SIZE (sizeof(set2_ges7630_register_array)/sizeof(set2_ges7630_register_array[0]))

//30cm operation distance settings
const uint8_t set3_ges7630_register_array[][2] = {
                        {0xEF,0x00},
                        {0x48,0x00},
                        {0x49,0x02},
                        {0x4A,0x00},
                        {0x4B,0x02},
                        {0xAA,0x10},
                        {0xAB,0x10},
                        {0xCA,0x62},
                        {0xEF,0x01},
                        {0x00,0x0F},
                        {0x01,0x0F},
                        {0x02,0x08},
                        {0x03,0x08},
                        {0x4A,0x0F},
                        {0x4B,0x0F},
                        {0x4C,0x00},
                        {0x4D,0x00},
                        {0xEF,0x00},                        
                        {0x93,0x07},
                        {0x94,0x07},
};

#define SET3_Ges7630_REG_ARRAY_SIZE (sizeof(set3_ges7630_register_array)/sizeof(set3_ges7630_register_array[0]))