1 files changed, 503 insertions, 81 deletions

diff --git a/lib/python/qmk/info.py b/lib/python/qmk/info.py
index f476dc666..0ea5136a9 100644
--- a/lib/python/qmk/info.py
+++ b/lib/python/qmk/info.py
@@ -1,18 +1,64 @@
 """Functions that help us generate and use info.json files.
 """
 import json
+from collections.abc import Mapping
 from glob import glob
 from pathlib import Path
 
+import jsonschema
 from milc import cli
 
-from qmk.constants import CHIBIOS_PROCESSORS, LUFA_PROCESSORS, VUSB_PROCESSORS
+from qmk.constants import CHIBIOS_PROCESSORS, LUFA_PROCESSORS, VUSB_PROCESSORS, LED_INDICATORS
 from qmk.c_parse import find_layouts
 from qmk.keyboard import config_h, rules_mk
 from qmk.keymap import list_keymaps
 from qmk.makefile import parse_rules_mk_file
 from qmk.math import compute
 
+led_matrix_properties = {
+    'driver_count': 'LED_DRIVER_COUNT',
+    'driver_addr1': 'LED_DRIVER_ADDR_1',
+    'driver_addr2': 'LED_DRIVER_ADDR_2',
+    'driver_addr3': 'LED_DRIVER_ADDR_3',
+    'driver_addr4': 'LED_DRIVER_ADDR_4',
+    'led_count': 'LED_DRIVER_LED_COUNT',
+    'timeout': 'ISSI_TIMEOUT',
+    'persistence': 'ISSI_PERSISTENCE'
+}
+
+rgblight_properties = {
+    'led_count': ('RGBLED_NUM', int),
+    'pin': ('RGB_DI_PIN', str),
+    'max_brightness': ('RGBLIGHT_LIMIT_VAL', int),
+    'hue_steps': ('RGBLIGHT_HUE_STEP', int),
+    'saturation_steps': ('RGBLIGHT_SAT_STEP', int),
+    'brightness_steps': ('RGBLIGHT_VAL_STEP', int)
+}
+
+rgblight_toggles = {
+    'sleep': 'RGBLIGHT_SLEEP',
+    'split': 'RGBLIGHT_SPLIT',
+}
+
+rgblight_animations = {
+    'all': 'RGBLIGHT_ANIMATIONS',
+    'alternating': 'RGBLIGHT_EFFECT_ALTERNATING',
+    'breathing': 'RGBLIGHT_EFFECT_BREATHING',
+    'christmas': 'RGBLIGHT_EFFECT_CHRISTMAS',
+    'knight': 'RGBLIGHT_EFFECT_KNIGHT',
+    'rainbow_mood': 'RGBLIGHT_EFFECT_RAINBOW_MOOD',
+    'rainbow_swirl': 'RGBLIGHT_EFFECT_RAINBOW_SWIRL',
+    'rgb_test': 'RGBLIGHT_EFFECT_RGB_TEST',
+    'snake': 'RGBLIGHT_EFFECT_SNAKE',
+    'static_gradient': 'RGBLIGHT_EFFECT_STATIC_GRADIENT',
+    'twinkle': 'RGBLIGHT_EFFECT_TWINKLE'
+}
+
+usb_properties = {'vid': 'VENDOR_ID', 'pid': 'PRODUCT_ID', 'device_ver': 'DEVICE_VER'}
+
+true_values = ['1', 'on', 'yes']
+false_values = ['0', 'off', 'no']
+
 
 def info_json(keyboard):
     """Generate the info.json data for a specific keyboard.
@@ -38,8 +84,9 @@ def info_json(keyboard):
         info_data['keymaps'][keymap.name] = {'url': f'https://raw.githubusercontent.com/qmk/qmk_firmware/master/{keymap}/keymap.json'}
 
     # Populate layout data
-    for layout_name, layout_json in _find_all_layouts(info_data, keyboard, rules).items():
+    for layout_name, layout_json in _find_all_layouts(info_data, keyboard).items():
         if not layout_name.startswith('LAYOUT_kc'):
+            layout_json['c_macro'] = True
             info_data['layouts'][layout_name] = layout_json
 
     # Merge in the data from info.json, config.h, and rules.mk
@@ -47,54 +94,366 @@ def info_json(keyboard):
     info_data = _extract_config_h(info_data)
     info_data = _extract_rules_mk(info_data)
 
+    # Validate against the jsonschema
+    try:
+        keyboard_api_validate(info_data)
+
+    except jsonschema.ValidationError as e:
+        json_path = '.'.join([str(p) for p in e.absolute_path])
+        cli.log.error('Invalid API data: %s: %s: %s', keyboard, json_path, e.message)
+        print(dir(e))
+        exit()
+
+    # Make sure we have at least one layout
+    if not info_data.get('layouts'):
+        _log_error(info_data, 'No LAYOUTs defined! Need at least one layout defined in the keyboard.h or info.json.')
+
+    # Make sure we supply layout macros for the community layouts we claim to support
+    # FIXME(skullydazed): This should be populated into info.json and read from there instead
+    if 'LAYOUTS' in rules and info_data.get('layouts'):
+        # Match these up against the supplied layouts
+        supported_layouts = rules['LAYOUTS'].strip().split()
+        for layout_name in sorted(info_data['layouts']):
+            layout_name = layout_name[7:]
+
+            if layout_name in supported_layouts:
+                supported_layouts.remove(layout_name)
+
+        if supported_layouts:
+            for supported_layout in supported_layouts:
+                _log_error(info_data, 'Claims to support community layout %s but no LAYOUT_%s() macro found' % (supported_layout, supported_layout))
+
     return info_data
 
 
-def _extract_config_h(info_data):
-    """Pull some keyboard information from existing rules.mk files
+def _json_load(json_file):
+    """Load a json file from disk.
+
+    Note: file must be a Path object.
+    """
+    try:
+        return json.load(json_file.open())
+
+    except json.decoder.JSONDecodeError as e:
+        cli.log.error('Invalid JSON encountered attempting to load {fg_cyan}%s{fg_reset}:\n\t{fg_red}%s', json_file, e)
+        exit(1)
+
+
+def _jsonschema(schema_name):
+    """Read a jsonschema file from disk.
+
+    FIXME(skullydazed/anyone): Refactor to make this a public function.
+    """
+    schema_path = Path(f'data/schemas/{schema_name}.jsonschema')
+
+    if not schema_path.exists():
+        schema_path = Path('data/schemas/false.jsonschema')
+
+    return _json_load(schema_path)
+
+
+def keyboard_validate(data):
+    """Validates data against the keyboard jsonschema.
+    """
+    schema = _jsonschema('keyboard')
+    validator = jsonschema.Draft7Validator(schema).validate
+
+    return validator(data)
+
+
+def keyboard_api_validate(data):
+    """Validates data against the api_keyboard jsonschema.
+    """
+    base = _jsonschema('keyboard')
+    relative = _jsonschema('api_keyboard')
+    resolver = jsonschema.RefResolver.from_schema(base)
+    validator = jsonschema.Draft7Validator(relative, resolver=resolver).validate
+
+    return validator(data)
+
+
+def _extract_debounce(info_data, config_c):
+    """Handle debounce.
+    """
+    if 'debounce' in info_data and 'DEBOUNCE' in config_c:
+        _log_warning(info_data, 'Debounce is specified in both info.json and config.h, the config.h value wins.')
+
+    if 'DEBOUNCE' in config_c:
+        info_data['debounce'] = int(config_c['DEBOUNCE'])
+
+    return info_data
+
+
+def _extract_diode_direction(info_data, config_c):
+    """Handle the diode direction.
+    """
+    if 'diode_direction' in info_data and 'DIODE_DIRECTION' in config_c:
+        _log_warning(info_data, 'Diode direction is specified in both info.json and config.h, the config.h value wins.')
+
+    if 'DIODE_DIRECTION' in config_c:
+        info_data['diode_direction'] = config_c.get('DIODE_DIRECTION')
+
+    return info_data
+
+
+def _extract_indicators(info_data, config_c):
+    """Find the LED indicator information.
+    """
+    for json_key, config_key in LED_INDICATORS.items():
+        if json_key in info_data.get('indicators', []) and config_key in config_c:
+            _log_warning(info_data, f'Indicator {json_key} is specified in both info.json and config.h, the config.h value wins.')
+
+        if 'indicators' not in info_data:
+            info_data['indicators'] = {}
+
+        if config_key in config_c:
+            if 'indicators' not in info_data:
+                info_data['indicators'] = {}
+
+            info_data['indicators'][json_key] = config_c.get(config_key)
+
+    return info_data
+
+
+def _extract_community_layouts(info_data, rules):
+    """Find the community layouts in rules.mk.
+    """
+    community_layouts = rules['LAYOUTS'].split() if 'LAYOUTS' in rules else []
+
+    if 'community_layouts' in info_data:
+        for layout in community_layouts:
+            if layout not in info_data['community_layouts']:
+                community_layouts.append(layout)
+
+    else:
+        info_data['community_layouts'] = community_layouts
+
+    return info_data
+
+
+def _extract_features(info_data, rules):
+    """Find all the features enabled in rules.mk.
+    """
+    # Special handling for bootmagic which also supports a "lite" mode.
+    if rules.get('BOOTMAGIC_ENABLE') == 'lite':
+        rules['BOOTMAGIC_LITE_ENABLE'] = 'on'
+        del rules['BOOTMAGIC_ENABLE']
+    if rules.get('BOOTMAGIC_ENABLE') == 'full':
+        rules['BOOTMAGIC_ENABLE'] = 'on'
+
+    # Skip non-boolean features we haven't implemented special handling for
+    for feature in 'HAPTIC_ENABLE', 'QWIIC_ENABLE':
+        if rules.get(feature):
+            del rules[feature]
+
+    # Process the rest of the rules as booleans
+    for key, value in rules.items():
+        if key.endswith('_ENABLE'):
+            key = '_'.join(key.split('_')[:-1]).lower()
+            value = True if value.lower() in true_values else False if value.lower() in false_values else value
+
+            if 'config_h_features' not in info_data:
+                info_data['config_h_features'] = {}
+
+            if 'features' not in info_data:
+                info_data['features'] = {}
+
+            if key in info_data['features']:
+                _log_warning(info_data, 'Feature %s is specified in both info.json and rules.mk, the rules.mk value wins.' % (key,))
+
+            info_data['features'][key] = value
+            info_data['config_h_features'][key] = value
+
+    return info_data
+
+
+def _extract_led_drivers(info_data, rules):
+    """Find all the LED drivers set in rules.mk.
+    """
+    if 'LED_MATRIX_DRIVER' in rules:
+        if 'led_matrix' not in info_data:
+            info_data['led_matrix'] = {}
+
+        if info_data['led_matrix'].get('driver'):
+            _log_warning(info_data, 'LED Matrix driver is specified in both info.json and rules.mk, the rules.mk value wins.')
+
+        info_data['led_matrix']['driver'] = rules['LED_MATRIX_DRIVER']
+
+    return info_data
+
+
+def _extract_led_matrix(info_data, config_c):
+    """Handle the led_matrix configuration.
+    """
+    led_matrix = info_data.get('led_matrix', {})
+
+    for json_key, config_key in led_matrix_properties.items():
+        if config_key in config_c:
+            if json_key in led_matrix:
+                _log_warning(info_data, 'LED Matrix: %s is specified in both info.json and config.h, the config.h value wins.' % (json_key,))
+
+            led_matrix[json_key] = config_c[config_key]
+
+
+def _extract_rgblight(info_data, config_c):
+    """Handle the rgblight configuration.
+    """
+    rgblight = info_data.get('rgblight', {})
+    animations = rgblight.get('animations', {})
+
+    if 'RGBLED_SPLIT' in config_c:
+        raw_split = config_c.get('RGBLED_SPLIT', '').replace('{', '').replace('}', '').strip()
+        rgblight['split_count'] = [int(i) for i in raw_split.split(',')]
+
+    for json_key, config_key_type in rgblight_properties.items():
+        config_key, config_type = config_key_type
+
+        if config_key in config_c:
+            if json_key in rgblight:
+                _log_warning(info_data, 'RGB Light: %s is specified in both info.json and config.h, the config.h value wins.' % (json_key,))
+
+            try:
+                rgblight[json_key] = config_type(config_c[config_key])
+            except ValueError as e:
+                cli.log.error('%s: config.h: Could not convert "%s" to %s: %s', info_data['keyboard_folder'], config_c[config_key], config_type.__name__, e)
+
+    for json_key, config_key in rgblight_toggles.items():
+        if config_key in config_c and json_key in rgblight:
+            _log_warning(info_data, 'RGB Light: %s is specified in both info.json and config.h, the config.h value wins.', json_key)
+
+        rgblight[json_key] = config_key in config_c
+
+    for json_key, config_key in rgblight_animations.items():
+        if config_key in config_c:
+            if json_key in animations:
+                _log_warning(info_data, 'RGB Light: animations: %s is specified in both info.json and config.h, the config.h value wins.' % (json_key,))
+
+            animations[json_key] = config_c[config_key]
+
+    if animations:
+        rgblight['animations'] = animations
+
+    if rgblight:
+        info_data['rgblight'] = rgblight
+
+    return info_data
+
+
+def _pin_name(pin):
+    """Returns the proper representation for a pin.
+    """
+    pin = pin.strip()
+
+    if not pin:
+        return None
+
+    elif pin.isdigit():
+        return int(pin)
+
+    elif pin == 'NO_PIN':
+        return None
+
+    elif pin[0] in 'ABCDEFGHIJK' and pin[1].isdigit():
+        return pin
+
+    raise ValueError(f'Invalid pin: {pin}')
+
+
+def _extract_pins(pins):
+    """Returns a list of pins from a comma separated string of pins.
+    """
+    return [_pin_name(pin) for pin in pins.split(',')]
+
+
+def _extract_direct_matrix(info_data, direct_pins):
+    """
+    """
+    info_data['matrix_pins'] = {}
+    direct_pin_array = []
+
+    while direct_pins[-1] != '}':
+        direct_pins = direct_pins[:-1]
+
+    for row in direct_pins.split('},{'):
+        if row.startswith('{'):
+            row = row[1:]
+
+        if row.endswith('}'):
+            row = row[:-1]
+
+        direct_pin_array.append([])
+
+        for pin in row.split(','):
+            if pin == 'NO_PIN':
+                pin = None
+
+            direct_pin_array[-1].append(pin)
+
+    return direct_pin_array
+
+
+def _extract_matrix_info(info_data, config_c):
+    """Populate the matrix information.
     """
-    config_c = config_h(info_data['keyboard_folder'])
     row_pins = config_c.get('MATRIX_ROW_PINS', '').replace('{', '').replace('}', '').strip()
     col_pins = config_c.get('MATRIX_COL_PINS', '').replace('{', '').replace('}', '').strip()
     direct_pins = config_c.get('DIRECT_PINS', '').replace(' ', '')[1:-1]
 
-    info_data['diode_direction'] = config_c.get('DIODE_DIRECTION')
-    info_data['matrix_size'] = {
-        'rows': compute(config_c.get('MATRIX_ROWS', '0')),
-        'cols': compute(config_c.get('MATRIX_COLS', '0')),
-    }
-    info_data['matrix_pins'] = {}
+    if 'MATRIX_ROWS' in config_c and 'MATRIX_COLS' in config_c:
+        if 'matrix_size' in info_data:
+            _log_warning(info_data, 'Matrix size is specified in both info.json and config.h, the config.h values win.')
 
-    if row_pins:
-        info_data['matrix_pins']['rows'] = row_pins.split(',')
-    if col_pins:
-        info_data['matrix_pins']['cols'] = col_pins.split(',')
+        info_data['matrix_size'] = {
+            'cols': compute(config_c.get('MATRIX_COLS', '0')),
+            'rows': compute(config_c.get('MATRIX_ROWS', '0')),
+        }
+
+    if row_pins and col_pins:
+        if 'matrix_pins' in info_data:
+            _log_warning(info_data, 'Matrix pins are specified in both info.json and config.h, the config.h values win.')
+
+        info_data['matrix_pins'] = {
+            'cols': _extract_pins(col_pins),
+            'rows': _extract_pins(row_pins),
+        }
 
     if direct_pins:
-        direct_pin_array = []
-        for row in direct_pins.split('},{'):
-            if row.startswith('{'):
-                row = row[1:]
-            if row.endswith('}'):
-                row = row[:-1]
+        if 'matrix_pins' in info_data:
+            _log_warning(info_data, 'Direct pins are specified in both info.json and config.h, the config.h values win.')
 
-            direct_pin_array.append([])
+        info_data['matrix_pins']['direct'] = _extract_direct_matrix(info_data, direct_pins)
 
-            for pin in row.split(','):
-                if pin == 'NO_PIN':
-                    pin = None
+    return info_data
 
-                direct_pin_array[-1].append(pin)
 
-        info_data['matrix_pins']['direct'] = direct_pin_array
+def _extract_usb_info(info_data, config_c):
+    """Populate the USB information.
+    """
+    if 'usb' not in info_data:
+        info_data['usb'] = {}
 
-    info_data['usb'] = {
-        'vid': config_c.get('VENDOR_ID'),
-        'pid': config_c.get('PRODUCT_ID'),
-        'device_ver': config_c.get('DEVICE_VER'),
-        'manufacturer': config_c.get('MANUFACTURER'),
-        'product': config_c.get('PRODUCT'),
-    }
+    for info_name, config_name in usb_properties.items():
+        if config_name in config_c:
+            if info_name in info_data['usb']:
+                _log_warning(info_data, '%s in config.h is overwriting usb.%s in info.json' % (config_name, info_name))
+
+            info_data['usb'][info_name] = '0x' + config_c[config_name][2:].upper()
+
+    return info_data
+
+
+def _extract_config_h(info_data):
+    """Pull some keyboard information from existing config.h files
+    """
+    config_c = config_h(info_data['keyboard_folder'])
+
+    _extract_debounce(info_data, config_c)
+    _extract_diode_direction(info_data, config_c)
+    _extract_indicators(info_data, config_c)
+    _extract_matrix_info(info_data, config_c)
+    _extract_usb_info(info_data, config_c)
+    _extract_led_matrix(info_data, config_c)
+    _extract_rgblight(info_data, config_c)
 
     return info_data
 
@@ -106,16 +465,53 @@ def _extract_rules_mk(info_data):
     mcu = rules.get('MCU')
 
     if mcu in CHIBIOS_PROCESSORS:
-        return arm_processor_rules(info_data, rules)
+        arm_processor_rules(info_data, rules)
 
     elif mcu in LUFA_PROCESSORS + VUSB_PROCESSORS:
-        return avr_processor_rules(info_data, rules)
+        avr_processor_rules(info_data, rules)
+
+    else:
+        cli.log.warning("%s: Unknown MCU: %s" % (info_data['keyboard_folder'], mcu))
+        unknown_processor_rules(info_data, rules)
+
+    _extract_community_layouts(info_data, rules)
+    _extract_features(info_data, rules)
+    _extract_led_drivers(info_data, rules)
+
+    return info_data
+
 
-    msg = "Unknown MCU: " + str(mcu)
+def _merge_layouts(info_data, new_info_data):
+    """Merge new_info_data into info_data in an intelligent way.
+    """
+    for layout_name, layout_json in new_info_data['layouts'].items():
+        if layout_name in info_data['layouts']:
+            # Pull in layouts we have a macro for
+            if len(info_data['layouts'][layout_name]['layout']) != len(layout_json['layout']):
+                msg = '%s: %s: Number of elements in info.json does not match! info.json:%s != %s:%s'
+                _log_error(info_data, msg % (info_data['keyboard_folder'], layout_name, len(layout_json['layout']), layout_name, len(info_data['layouts'][layout_name]['layout'])))
+            else:
+                for i, key in enumerate(info_data['layouts'][layout_name]['layout']):
+                    key.update(layout_json['layout'][i])
+        else:
+            # Pull in layouts that have matrix data
+            missing_matrix = False
+            for key in layout_json.get('layout', {}):
+                if 'matrix' not in key:
+                    missing_matrix = True
+
+            if not missing_matrix:
+                if layout_name in info_data['layouts']:
+                    # Update an existing layout with new data
+                    for i, key in enumerate(info_data['layouts'][layout_name]['layout']):
+                        key.update(layout_json['layout'][i])
 
-    _log_warning(info_data, msg)
+                else:
+                    # Copy in the new layout wholesale
+                    layout_json['c_macro'] = False
+                    info_data['layouts'][layout_name] = layout_json
 
-    return unknown_processor_rules(info_data, rules)
+    return info_data
 
 
 def _search_keyboard_h(path):
@@ -131,34 +527,21 @@ def _search_keyboard_h(path):
     return layouts
 
 
-def _find_all_layouts(info_data, keyboard, rules):
+def _find_all_layouts(info_data, keyboard):
     """Looks for layout macros associated with this keyboard.
     """
     layouts = _search_keyboard_h(Path(keyboard))
 
     if not layouts:
-        # If we didn't find any layouts above we widen our search. This is error
-        # prone which is why we want to encourage people to follow the standard above.
-        _log_warning(info_data, 'Falling back to searching for KEYMAP/LAYOUT macros.')
+        # If we don't find any layouts from info.json or keyboard.h we widen our search. This is error prone which is why we want to encourage people to follow the standard above.
+        info_data['parse_warnings'].append('%s: Falling back to searching for KEYMAP/LAYOUT macros.' % (keyboard))
+
         for file in glob('keyboards/%s/*.h' % keyboard):
             if file.endswith('.h'):
                 these_layouts = find_layouts(file)
                 if these_layouts:
                     layouts.update(these_layouts)
 
-    if 'LAYOUTS' in rules:
-        # Match these up against the supplied layouts
-        supported_layouts = rules['LAYOUTS'].strip().split()
-        for layout_name in sorted(layouts):
-            if not layout_name.startswith('LAYOUT_'):
-                continue
-            layout_name = layout_name[7:]
-            if layout_name in supported_layouts:
-                supported_layouts.remove(layout_name)
-
-        if supported_layouts:
-            _log_error(info_data, 'Missing LAYOUT() macro for %s' % (', '.join(supported_layouts)))
-
     return layouts
 
 
@@ -180,13 +563,29 @@ def arm_processor_rules(info_data, rules):
     """Setup the default info for an ARM board.
     """
     info_data['processor_type'] = 'arm'
-    info_data['bootloader'] = rules['BOOTLOADER'] if 'BOOTLOADER' in rules else 'unknown'
-    info_data['processor'] = rules['MCU'] if 'MCU' in rules else 'unknown'
     info_data['protocol'] = 'ChibiOS'
 
-    if info_data['bootloader'] == 'unknown':
+    if 'MCU' in rules:
+        if 'processor' in info_data:
+            _log_warning(info_data, 'Processor/MCU is specified in both info.json and rules.mk, the rules.mk value wins.')
+
+        info_data['processor'] = rules['MCU']
+
+    elif 'processor' not in info_data:
+        info_data['processor'] = 'unknown'
+
+    if 'BOOTLOADER' in rules:
+        # FIXME(skullydazed/anyone): need to remove the massive amounts of duplication first
+        # if 'bootloader' in info_data:
+        #     _log_warning(info_data, 'Bootloader is specified in both info.json and rules.mk, the rules.mk value wins.')
+
+        info_data['bootloader'] = rules['BOOTLOADER']
+
+    else:
         if 'STM32' in info_data['processor']:
             info_data['bootloader'] = 'stm32-dfu'
+        else:
+            info_data['bootloader'] = 'unknown'
 
     if 'STM32' in info_data['processor']:
         info_data['platform'] = 'STM32'
@@ -204,9 +603,26 @@ def avr_processor_rules(info_data, rules):
     info_data['processor_type'] = 'avr'
     info_data['bootloader'] = rules['BOOTLOADER'] if 'BOOTLOADER' in rules else 'atmel-dfu'
     info_data['platform'] = rules['ARCH'] if 'ARCH' in rules else 'unknown'
-    info_data['processor'] = rules['MCU'] if 'MCU' in rules else 'unknown'
     info_data['protocol'] = 'V-USB' if rules.get('MCU') in VUSB_PROCESSORS else 'LUFA'
 
+    if 'MCU' in rules:
+        if 'processor' in info_data:
+            _log_warning(info_data, 'Processor/MCU is specified in both info.json and rules.mk, the rules.mk value wins.')
+
+        info_data['processor'] = rules['MCU']
+
+    elif 'processor' not in info_data:
+        info_data['processor'] = 'unknown'
+
+    if 'BOOTLOADER' in rules:
+        # FIXME(skullydazed/anyone): need to remove the massive amounts of duplication first
+        # if 'bootloader' in info_data:
+        #     _log_warning(info_data, 'Bootloader is specified in both info.json and rules.mk, the rules.mk value wins.')
+
+        info_data['bootloader'] = rules['BOOTLOADER']
+    else:
+        info_data['bootloader'] = 'atmel-dfu'
+
     # FIXME(fauxpark/anyone): Eventually we should detect the protocol by looking at PROTOCOL inherited from mcu_selection.mk:
     # info_data['protocol'] = 'V-USB' if rules.get('PROTOCOL') == 'VUSB' else 'LUFA'
 
@@ -225,38 +641,44 @@ def unknown_processor_rules(info_data, rules):
     return info_data
 
 
+def deep_update(origdict, newdict):
+    """Update a dictionary in place, recursing to do a deep copy.
+    """
+    for key, value in newdict.items():
+        if isinstance(value, Mapping):
+            origdict[key] = deep_update(origdict.get(key, {}), value)
+
+        else:
+            origdict[key] = value
+
+    return origdict
+
+
 def merge_info_jsons(keyboard, info_data):
     """Return a merged copy of all the info.json files for a keyboard.
     """
     for info_file in find_info_json(keyboard):
         # Load and validate the JSON data
-        try:
-            with info_file.open('r') as info_fd:
-                new_info_data = json.load(info_fd)
-        except Exception as e:
-            _log_error(info_data, "Invalid JSON in file %s: %s: %s" % (str(info_file), e.__class__.__name__, e))
-            continue
+        new_info_data = _json_load(info_file)
 
         if not isinstance(new_info_data, dict):
             _log_error(info_data, "Invalid file %s, root object should be a dictionary." % (str(info_file),))
             continue
 
-        # Copy whitelisted keys into `info_data`
-        for key in ('keyboard_name', 'manufacturer', 'identifier', 'url', 'maintainer', 'processor', 'bootloader', 'width', 'height'):
-            if key in new_info_data:
-                info_data[key] = new_info_data[key]
+        try:
+            keyboard_validate(new_info_data)
+        except jsonschema.ValidationError as e:
+            json_path = '.'.join([str(p) for p in e.absolute_path])
+            cli.log.error('Not including data from file: %s', info_file)
+            cli.log.error('\t%s: %s', json_path, e.message)
+            continue
 
-        # Merge the layouts in
-        if 'layouts' in new_info_data:
-            for layout_name, json_layout in new_info_data['layouts'].items():
-                # Only pull in layouts we have a macro for
-                if layout_name in info_data['layouts']:
-                    if info_data['layouts'][layout_name]['key_count'] != len(json_layout['layout']):
-                        msg = '%s: Number of elements in info.json does not match! info.json:%s != %s:%s'
-                        _log_error(info_data, msg % (layout_name, len(json_layout['layout']), layout_name, len(info_data['layouts'][layout_name]['layout'])))
-                    else:
-                        for i, key in enumerate(info_data['layouts'][layout_name]['layout']):
-                            key.update(json_layout['layout'][i])
+        # Mark the layouts as coming from json
+        for layout in new_info_data.get('layouts', {}).values():
+            layout['c_macro'] = False
+
+        # Update info_data with the new data
+        deep_update(info_data, new_info_data)
 
     return info_data