~ruther/qmk_firmware

071eb2478f039e21effb981a8a98e6181238b53b — Joel Challis 5 years ago 770a4ee
Remove mbed files (#7605)

* Remove mbed files

* Remove mbed files - fix comment

* Remove mbed logic blocks
16 files changed, 1 insertions(+), 524 deletions(-)

M docs/faq_build.md
M docs/fr-fr/faq_build.md
M docs/zh-cn/faq_build.md
M doxygen-todo
D tmk_core/common/mbed/bootloader.c
D tmk_core/common/mbed/suspend.c
D tmk_core/common/mbed/timer.c
D tmk_core/common/mbed/xprintf.cpp
D tmk_core/common/mbed/xprintf.h
M tmk_core/common/print.h
M tmk_core/common/wait.h
D tmk_core/protocol/mbed/HIDKeyboard.cpp
D tmk_core/protocol/mbed/HIDKeyboard.h
D tmk_core/protocol/mbed/mbed_driver.cpp
D tmk_core/protocol/mbed/mbed_driver.h
D tmk_core/protocol/ps2_io_mbed.c
M docs/faq_build.md => docs/faq_build.md +0 -8
@@ 99,14 99,6 @@ You can buy a really unique VID:PID here. I don't think you need this for person
- http://www.obdev.at/products/vusb/license.html
- http://www.mcselec.com/index.php?page=shop.product_details&flypage=shop.flypage&product_id=92&option=com_phpshop&Itemid=1

## Cortex: `cstddef: No such file or directory`
GCC 4.8 of Ubuntu 14.04 had this problem and had to update to 4.9 with this PPA.
https://launchpad.net/~terry.guo/+archive/ubuntu/gcc-arm-embedded

https://github.com/tmk/tmk_keyboard/issues/212
https://github.com/tmk/tmk_keyboard/wiki/mbed-cortex-porting#compile-error-cstddef
https://developer.mbed.org/forum/mbed/topic/5205/

## BOOTLOADER_SIZE for AVR
Note that Teensy2.0++ bootloader size is 2048byte. Some Makefiles may have wrong comment.


M docs/fr-fr/faq_build.md => docs/fr-fr/faq_build.md +0 -9
@@ 99,15 99,6 @@ Vous pouvez acheter un VID:PID unique ici. Je ne pense pas que ce soit nécessai
- http://www.obdev.at/products/vusb/license.html
- http://www.mcselec.com/index.php?page=shop.product_details&flypage=shop.flypage&product_id=92&option=com_phpshop&Itemid=1

## Cortex: `cstddef: No such file or directory`

Ce problème existait avec le GCC 4.8 d'Ubuntu 14.04, la solution a nécessité de mettre à jour vers 4.9 avec ce PPA.
https://launchpad.net/~terry.guo/+archive/ubuntu/gcc-arm-embedded

https://github.com/tmk/tmk_keyboard/issues/212
https://github.com/tmk/tmk_keyboard/wiki/mbed-cortex-porting#compile-error-cstddef
https://developer.mbed.org/forum/mbed/topic/5205/

## BOOTLOADER_SIZE pour AVR

Notez que la taille du bootloader pour les Teensy2.0++ est de 2048bytes. Quelques Makefiles peuvent contenir une erreur et avoir le mauvais commentaire.

M docs/zh-cn/faq_build.md => docs/zh-cn/faq_build.md +0 -8
@@ 68,14 68,6 @@ https://github.com/tmk/tmk_keyboard/issues/150
- http://www.obdev.at/products/vusb/license.html
- http://www.mcselec.com/index.php?page=shop.product_details&flypage=shop.flypage&product_id=92&option=com_phpshop&Itemid=1

## Cortex: `cstddef: No such file or directory`
在Ubuntu 14.04上的GCC 4.8 会出现这种问题需要用这个PPA升级到4.9。
https://launchpad.net/~terry.guo/+archive/ubuntu/gcc-arm-embedded

https://github.com/tmk/tmk_keyboard/issues/212
https://github.com/tmk/tmk_keyboard/wiki/mbed-cortex-porting#compile-error-cstddef
https://developer.mbed.org/forum/mbed/topic/5205/

## AVR的BOOTLOADER_SIZE
注意Teensy2.0++ bootloader的大小是2048字节。有些Makefile注释错了。


M doxygen-todo => doxygen-todo +0 -1
@@ 3,7 3,6 @@ tmk_core/protocol/bluefruit
tmk_core/protocol/chibios
tmk_core/protocol/iwrap
tmk_core/protocol/lufa
tmk_core/protocol/mbed
tmk_core/protocol/midi
tmk_core/protocol/midi/bytequeue
tmk_core/protocol/midi/Config

D tmk_core/common/mbed/bootloader.c => tmk_core/common/mbed/bootloader.c +0 -3
@@ 1,3 0,0 @@
#include "bootloader.h"

void bootloader_jump(void) {}

D tmk_core/common/mbed/suspend.c => tmk_core/common/mbed/suspend.c +0 -5
@@ 1,5 0,0 @@
#include <stdbool.h>

void suspend_power_down(void) {}
bool suspend_wakeup_condition(void) { return true; }
void suspend_wakeup_init(void) {}

D tmk_core/common/mbed/timer.c => tmk_core/common/mbed/timer.c +0 -23
@@ 1,23 0,0 @@
#include "cmsis.h"
#include "timer.h"

/* Mill second tick count */
volatile uint32_t timer_count = 0;

/* Timer interrupt handler */
void SysTick_Handler(void) { timer_count++; }

void timer_init(void) {
    timer_count = 0;
    SysTick_Config(SystemCoreClock / 1000); /* 1ms tick */
}

void timer_clear(void) { timer_count = 0; }

uint16_t timer_read(void) { return (uint16_t)(timer_count & 0xFFFF); }

uint32_t timer_read32(void) { return timer_count; }

uint16_t timer_elapsed(uint16_t last) { return TIMER_DIFF_16(timer_read(), last); }

uint32_t timer_elapsed32(uint32_t last) { return TIMER_DIFF_32(timer_read32(), last); }

D tmk_core/common/mbed/xprintf.cpp => tmk_core/common/mbed/xprintf.cpp +0 -50
@@ 1,50 0,0 @@
#include <cstdarg>
//#include <stdarg.h>
#include "mbed.h"
#include "mbed/xprintf.h"

#define STRING_STACK_LIMIT 120

// TODO
int __xprintf(const char* format, ...) { return 0; }

#if 0
/* mbed Serial */
Serial ser(UART_TX, UART_RX);

/* TODO: Need small implementation for embedded */
int xprintf(const char* format, ...)
{
    /* copy from mbed/common/RawSerial.cpp */
    std::va_list arg;
    va_start(arg, format);
    int len = vsnprintf(NULL, 0, format, arg);
    if (len < STRING_STACK_LIMIT) {
        char temp[STRING_STACK_LIMIT];
        vsprintf(temp, format, arg);
        ser.puts(temp);
    } else {
        char *temp = new char[len + 1];
        vsprintf(temp, format, arg);
        ser.puts(temp);
        delete[] temp;
    }
    va_end(arg);
    return len;

/* Fail: __builtin_va_arg_pack?
 * https://gcc.gnu.org/onlinedocs/gcc-4.3.5/gcc/Constructing-Calls.html#Constructing-Calls
    void *arg = __builtin_apply_args();
    void *ret = __builtin_apply((void*)(&(ser.printf)), arg, 100);
    __builtin_return(ret)
*/
/* Fail: varargs can not be passed to printf
    //int r = ser.printf("test %i\r\n", 123);
    va_list arg;
    va_start(arg, format);
    int r = ser.printf(format, arg);
    va_end(arg);
    return r;
*/
}
#endif

D tmk_core/common/mbed/xprintf.h => tmk_core/common/mbed/xprintf.h +0 -16
@@ 1,16 0,0 @@
#ifndef XPRINTF_H
#define XPRINTF_H

//#define xprintf(format, ...)            __xprintf(format, ##__VA_ARGS__)

#ifdef __cplusplus
extern "C" {
#endif

int __xprintf(const char *format, ...);

#ifdef __cplusplus
}
#endif

#endif

M tmk_core/common/print.h => tmk_core/common/print.h +1 -32
@@ 128,38 128,7 @@ extern "C"

#        endif /* USER_PRINT / NORMAL PRINT */

#    elif defined(__arm__) /* __arm__ */

#        include "mbed/xprintf.h"

#        ifdef USER_PRINT /* USER_PRINT */

// Remove normal print defines
#            define print(s)
#            define println(s)
#            define xprintf(fmt, ...)

// Create user print defines
#            define uprintf(fmt, ...) __xprintf(fmt, ##__VA_ARGS__)
#            define uprint(s) xprintf(s)
#            define uprintln(s) xprintf(s "\r\n")

#        else /* NORMAL PRINT */

// Create user & normal print defines
#            define xprintf(fmt, ...) __xprintf(fmt, ##__VA_ARGS__)
#            define print(s) xprintf(s)
#            define println(s) xprintf(s "\r\n")
#            define uprint(s) print(s)
#            define uprintln(s) println(s)
#            define uprintf(fmt, ...) xprintf(fmt, ##__VA_ARGS__)

#        endif /* USER_PRINT / NORMAL PRINT */

/* TODO: to select output destinations: UART/USBSerial */
#        define print_set_sendchar(func)

#    endif /* __AVR__ / PROTOCOL_CHIBIOS / PROTOCOL_ARM_ATSAM / __arm__ */
#    endif /* __AVR__ / PROTOCOL_CHIBIOS / PROTOCOL_ARM_ATSAM */

// User print disables the normal print messages in the body of QMK/TMK code and
// is meant as a lightweight alternative to NOPRINT. Use it when you only want to do

M tmk_core/common/wait.h => tmk_core/common/wait.h +0 -2
@@ 33,8 33,6 @@ extern "C" {
#    include "clks.h"
#    define wait_ms(ms) CLK_delay_ms(ms)
#    define wait_us(us) CLK_delay_us(us)
#elif defined(__arm__)
#    include "wait_api.h"
#else  // Unit tests
void wait_ms(uint32_t ms);
#    define wait_us(us) wait_ms(us / 1000)

D tmk_core/protocol/mbed/HIDKeyboard.cpp => tmk_core/protocol/mbed/HIDKeyboard.cpp +0 -260
@@ 1,260 0,0 @@
#include <stdint.h>
#include "USBHID.h"
#include "USBHID_Types.h"
#include "USBDescriptor.h"
#include "HIDKeyboard.h"

#define DEFAULT_CONFIGURATION (1)

HIDKeyboard::HIDKeyboard(uint16_t vendor_id, uint16_t product_id, uint16_t product_release) : USBDevice(vendor_id, product_id, product_release) { USBDevice::connect(); }

bool HIDKeyboard::sendReport(report_keyboard_t report) {
    USBDevice::write(EP1IN, report.raw, sizeof(report), MAX_PACKET_SIZE_EP1);
    return true;
}

uint8_t HIDKeyboard::leds() { return led_state; }

bool HIDKeyboard::USBCallback_setConfiguration(uint8_t configuration) {
    if (configuration != DEFAULT_CONFIGURATION) {
        return false;
    }

    // Configure endpoints > 0
    addEndpoint(EPINT_IN, MAX_PACKET_SIZE_EPINT);
    // addEndpoint(EPINT_OUT, MAX_PACKET_SIZE_EPINT);

    // We activate the endpoint to be able to recceive data
    // readStart(EPINT_OUT, MAX_PACKET_SIZE_EPINT);
    return true;
}

uint8_t *HIDKeyboard::stringImanufacturerDesc() {
    static uint8_t stringImanufacturerDescriptor[] = {
        0x18,              /*bLength*/
        STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
        't',
        0,
        'm',
        0,
        'k',
        0,
        '-',
        0,
        'k',
        0,
        'b',
        0,
        'd',
        0,
        '.',
        0,
        'c',
        0,
        'o',
        0,
        'm',
        0 /*bString iManufacturer*/
    };
    return stringImanufacturerDescriptor;
}

uint8_t *HIDKeyboard::stringIproductDesc() {
    static uint8_t stringIproductDescriptor[] = {
        0x0a,              /*bLength*/
        STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
        'm',
        0,
        'b',
        0,
        'e',
        0,
        'd',
        0 /*bString iProduct*/
    };
    return stringIproductDescriptor;
}

uint8_t *HIDKeyboard::stringIserialDesc() {
    static uint8_t stringIserialDescriptor[] = {
        0x04,              /*bLength*/
        STRING_DESCRIPTOR, /*bDescriptorType 0x03*/
        '0', 0             /*bString iSerial*/
    };
    return stringIserialDescriptor;
}

uint8_t *HIDKeyboard::reportDesc() {
    static uint8_t reportDescriptor[] = {
        USAGE_PAGE(1),     0x01,  // Generic Desktop
        USAGE(1),          0x06,  // Keyboard
        COLLECTION(1),     0x01,  // Application

        USAGE_PAGE(1),     0x07,                                                                                                                                           // Key Codes
        USAGE_MINIMUM(1),  0xE0, USAGE_MAXIMUM(1), 0xE7, LOGICAL_MINIMUM(1), 0x00, LOGICAL_MAXIMUM(1), 0x01, REPORT_SIZE(1), 0x01, REPORT_COUNT(1), 0x08, INPUT(1), 0x02,  // Data, Variable, Absolute

        REPORT_COUNT(1),   0x01, REPORT_SIZE(1),   0x08, INPUT(1),           0x01,  // Constant

        REPORT_COUNT(1),   0x05, REPORT_SIZE(1),   0x01, USAGE_PAGE(1),      0x08,  // LEDs
        USAGE_MINIMUM(1),  0x01, USAGE_MAXIMUM(1), 0x05, OUTPUT(1),          0x02,  // Data, Variable, Absolute

        REPORT_COUNT(1),   0x01, REPORT_SIZE(1),   0x03, OUTPUT(1),          0x01,  // Constant

        REPORT_COUNT(1),   0x06, REPORT_SIZE(1),   0x08, LOGICAL_MINIMUM(1), 0x00, LOGICAL_MAXIMUM(1), 0xFF, USAGE_PAGE(1),  0x07,  // Key Codes
        USAGE_MINIMUM(1),  0x00, USAGE_MAXIMUM(1), 0xFF, INPUT(1),           0x00,                                                  // Data, Array
        END_COLLECTION(0),
    };
    reportLength = sizeof(reportDescriptor);
    return reportDescriptor;
}

uint16_t HIDKeyboard::reportDescLength() {
    reportDesc();
    return reportLength;
}

#define TOTAL_DESCRIPTOR_LENGTH ((1 * CONFIGURATION_DESCRIPTOR_LENGTH) + (1 * INTERFACE_DESCRIPTOR_LENGTH) + (1 * HID_DESCRIPTOR_LENGTH) + (1 * ENDPOINT_DESCRIPTOR_LENGTH))
uint8_t *HIDKeyboard::configurationDesc() {
    static uint8_t configurationDescriptor[] = {
        CONFIGURATION_DESCRIPTOR_LENGTH,  // bLength
        CONFIGURATION_DESCRIPTOR,         // bDescriptorType
        LSB(TOTAL_DESCRIPTOR_LENGTH),     // wTotalLength (LSB)
        MSB(TOTAL_DESCRIPTOR_LENGTH),     // wTotalLength (MSB)
        0x01,                             // bNumInterfaces
        DEFAULT_CONFIGURATION,            // bConfigurationValue
        0x00,                             // iConfiguration
        C_RESERVED | C_REMOTE_WAKEUP,     // bmAttributes
        C_POWER(100),                     // bMaxPowerHello World from Mbed

        INTERFACE_DESCRIPTOR_LENGTH,  // bLength
        INTERFACE_DESCRIPTOR,         // bDescriptorType
        0x00,                         // bInterfaceNumber
        0x00,                         // bAlternateSetting
        0x01,                         // bNumEndpoints
        HID_CLASS,                    // bInterfaceClass
        1,                            // bInterfaceSubClass (boot)
        1,                            // bInterfaceProtocol (keyboard)
        0x00,                         // iInterface

        HID_DESCRIPTOR_LENGTH,               // bLength
        HID_DESCRIPTOR,                      // bDescriptorType
        LSB(HID_VERSION_1_11),               // bcdHID (LSB)
        MSB(HID_VERSION_1_11),               // bcdHID (MSB)
        0x00,                                // bCountryCode
        0x01,                                // bNumDescriptors
        REPORT_DESCRIPTOR,                   // bDescriptorType
        (uint8_t)(LSB(reportDescLength())),  // wDescriptorLength (LSB)
        (uint8_t)(MSB(reportDescLength())),  // wDescriptorLength (MSB)

        ENDPOINT_DESCRIPTOR_LENGTH,  // bLength
        ENDPOINT_DESCRIPTOR,         // bDescriptorType
        PHY_TO_DESC(EP1IN),          // bEndpointAddress
        E_INTERRUPT,                 // bmAttributes
        LSB(MAX_PACKET_SIZE_EPINT),  // wMaxPacketSize (LSB)
        MSB(MAX_PACKET_SIZE_EPINT),  // wMaxPacketSize (MSB)
        1,                           // bInterval (milliseconds)
    };
    return configurationDescriptor;
}

#if 0
uint8_t * HIDKeyboard::deviceDesc() {
    static uint8_t deviceDescriptor[] = {
        DEVICE_DESCRIPTOR_LENGTH,       /* bLength */
        DEVICE_DESCRIPTOR,              /* bDescriptorType */
        LSB(USB_VERSION_2_0),           /* bcdUSB (LSB) */
        MSB(USB_VERSION_2_0),           /* bcdUSB (MSB) */
        0x00,                           /* bDeviceClass */
        0x00,                           /* bDeviceSubClass */
        0x00,                           /* bDeviceprotocol */
        MAX_PACKET_SIZE_EP0,            /* bMaxPacketSize0 */
        (uint8_t)(LSB(0xfeed)),                 /* idVendor (LSB) */
        (uint8_t)(MSB(0xfeed)),                 /* idVendor (MSB) */
        (uint8_t)(LSB(0x1bed)),                /* idProduct (LSB) */
        (uint8_t)(MSB(0x1bed)),                /* idProduct (MSB) */
        (uint8_t)(LSB(0x0002)),           /* bcdDevice (LSB) */
        (uint8_t)(MSB(0x0002)),           /* bcdDevice (MSB) */
        0,    /* iManufacturer */
        0,         /* iProduct */
        0,          /* iSerialNumber */
        0x01                            /* bNumConfigurations */
    };
    return deviceDescriptor;
}
#endif

bool HIDKeyboard::USBCallback_request() {
    bool              success  = false;
    CONTROL_TRANSFER *transfer = getTransferPtr();
    uint8_t *         hidDescriptor;

    // Process additional standard requests

    if ((transfer->setup.bmRequestType.Type == STANDARD_TYPE)) {
        switch (transfer->setup.bRequest) {
            case GET_DESCRIPTOR:
                switch (DESCRIPTOR_TYPE(transfer->setup.wValue)) {
                    case REPORT_DESCRIPTOR:
                        if ((reportDesc() != NULL) && (reportDescLength() != 0)) {
                            transfer->remaining = reportDescLength();
                            transfer->ptr       = reportDesc();
                            transfer->direction = DEVICE_TO_HOST;
                            success             = true;
                        }
                        break;
                    case HID_DESCRIPTOR:
                        // Find the HID descriptor, after the configuration descriptor
                        hidDescriptor = findDescriptor(HID_DESCRIPTOR);
                        if (hidDescriptor != NULL) {
                            transfer->remaining = HID_DESCRIPTOR_LENGTH;
                            transfer->ptr       = hidDescriptor;
                            transfer->direction = DEVICE_TO_HOST;
                            success             = true;
                        }
                        break;

                    default:
                        break;
                }
                break;
            default:
                break;
        }
    }

    // Process class-specific requests
    if (transfer->setup.bmRequestType.Type == CLASS_TYPE) {
        switch (transfer->setup.bRequest) {
            case SET_REPORT:
                // LED indicator
                // TODO: check Interface and Report length?
                // if (transfer->setup.wIndex == INTERFACE_KEYBOAD) { }
                // if (transfer->setup.wLength == 1)

                transfer->remaining = 1;
                // transfer->ptr = ?? what ptr should be set when OUT(not used?)
                transfer->direction = HOST_TO_DEVICE;
                transfer->notify    = true; /* notify with USBCallback_requestCompleted */
                success             = true;
            default:
                break;
        }
    }

    return success;
}

void HIDKeyboard::USBCallback_requestCompleted(uint8_t *buf, uint32_t length) {
    if (length > 0) {
        CONTROL_TRANSFER *transfer = getTransferPtr();
        if (transfer->setup.bmRequestType.Type == CLASS_TYPE) {
            switch (transfer->setup.bRequest) {
                case SET_REPORT:
                    led_state = buf[0];
                    break;
                default:
                    break;
            }
        }
    }
}

D tmk_core/protocol/mbed/HIDKeyboard.h => tmk_core/protocol/mbed/HIDKeyboard.h +0 -32
@@ 1,32 0,0 @@
#ifndef HIDKEYBOARD_H

#    include "stdint.h"
#    include "stdbool.h"
#    include "USBHID.h"
#    include "report.h"

class HIDKeyboard : public USBDevice {
   public:
    HIDKeyboard(uint16_t vendor_id = 0xFEED, uint16_t product_id = 0xabed, uint16_t product_release = 0x0001);

    bool    sendReport(report_keyboard_t report);
    uint8_t leds(void);

   protected:
    uint16_t         reportLength;
    virtual bool     USBCallback_setConfiguration(uint8_t configuration);
    virtual uint8_t* stringImanufacturerDesc();
    virtual uint8_t* stringIproductDesc();
    virtual uint8_t* stringIserialDesc();
    virtual uint16_t reportDescLength();
    virtual uint8_t* reportDesc();
    virtual uint8_t* configurationDesc();
    // virtual uint8_t * deviceDesc();
    virtual bool USBCallback_request();
    virtual void USBCallback_requestCompleted(uint8_t* buf, uint32_t length);

   private:
    uint8_t led_state;
};

#endif

D tmk_core/protocol/mbed/mbed_driver.cpp => tmk_core/protocol/mbed/mbed_driver.cpp +0 -21
@@ 1,21 0,0 @@
#include "HIDKeyboard.h"
#include "host.h"
#include "host_driver.h"
#include "mbed_driver.h"

HIDKeyboard keyboard;

/* Host driver */
static uint8_t keyboard_leds(void);
static void    send_keyboard(report_keyboard_t *report);
static void    send_mouse(report_mouse_t *report);
static void    send_system(uint16_t data);
static void    send_consumer(uint16_t data);

host_driver_t mbed_driver = {keyboard_leds, send_keyboard, send_mouse, send_system, send_consumer};

static uint8_t keyboard_leds(void) { return keyboard.leds(); }
static void    send_keyboard(report_keyboard_t *report) { keyboard.sendReport(*report); }
static void    send_mouse(report_mouse_t *report) {}
static void    send_system(uint16_t data) {}
static void    send_consumer(uint16_t data) {}

D tmk_core/protocol/mbed/mbed_driver.h => tmk_core/protocol/mbed/mbed_driver.h +0 -3
@@ 1,3 0,0 @@
#include "host_driver.h"

extern host_driver_t mbed_driver;

D tmk_core/protocol/ps2_io_mbed.c => tmk_core/protocol/ps2_io_mbed.c +0 -51
@@ 1,51 0,0 @@
#include <stdbool.h>
#include "ps2_io.h"
#include "gpio_api.h"

static gpio_t clock;
static gpio_t data;

/*
 * Clock
 */
void clock_init(void) {
    gpio_init(&clock, P0_9);
    gpio_mode(&clock, OpenDrain | PullNone);
}

void clock_lo(void) {
    gpio_dir(&clock, PIN_OUTPUT);
    gpio_write(&clock, 0);
}
void clock_hi(void) {
    gpio_dir(&clock, PIN_OUTPUT);
    gpio_write(&clock, 1);
}

bool clock_in(void) {
    gpio_dir(&clock, PIN_INPUT);
    return gpio_read(&clock);
}

/*
 * Data
 */
void data_init(void) {
    gpio_init(&data, P0_8);
    gpio_mode(&data, OpenDrain | PullNone);
}

void data_lo(void) {
    gpio_dir(&data, PIN_OUTPUT);
    gpio_write(&data, 0);
}

void data_hi(void) {
    gpio_dir(&data, PIN_OUTPUT);
    gpio_write(&data, 1);
}

bool data_in(void) {
    gpio_dir(&data, PIN_INPUT);
    return gpio_read(&data);
}