t9/qmk-firmware
Watch
1
0
Fork
You've already forked qmk-firmware
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial USB2422 driver (#14835)

Browse source
This commit is contained in:
Joel Challis 2021-10-22 00:49:58 +01:00 • committed by GitHub
commit 0093d3d761
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 278 additions and 206 deletions
Download patch file Download diff file Expand all files Collapse all files

402
drivers/usb2422.c Normal file
View file

@ -0,0 +1,402 @@
/* Copyright 2021 QMK
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <string.h>
#include "usb2422.h"
#include "i2c_master.h"
#include "wait.h"
#include "gpio.h"
/* -------- USB2422_VID : (USB2422L Offset: 0x00) (R/W 16) Vendor ID -------- */
typedef union {
struct {
uint16_t VID_LSB : 8;
uint16_t VID_MSB : 8;
} bit; /*!< Structure used for bit access */
uint16_t reg; /*!< Type used for register access */
} USB2422_VID_Type;
/* -------- USB2422_PID : (USB2422L Offset: 0x02) (R/W 16) Product ID -------- */
typedef union {
struct {
uint16_t PID_LSB : 8;
uint16_t PID_MSB : 8;
} bit; /*!< Structure used for bit access */
uint16_t reg; /*!< Type used for register access */
} USB2422_PID_Type;
/* -------- USB2422_DID : (USB2422L Offset: 0x04) (R/W 16) Device ID -------- */
typedef union {
struct {
uint16_t DID_LSB : 8;
uint16_t DID_MSB : 8;
} bit; /*!< Structure used for bit access */
uint16_t reg; /*!< Type used for register access */
} USB2422_DID_Type;
/* -------- USB2422_CFG1 : (USB2422L Offset: 0x06) (R/W 8) Configuration Data Byte 1-------- */
typedef union {
struct {
uint8_t PORT_PWR : 1;
uint8_t CURRENT_SNS : 2;
uint8_t EOP_DISABLE : 1;
uint8_t MTT_ENABLE : 1;
uint8_t HS_DISABLE : 1;
uint8_t : 1;
uint8_t SELF_BUS_PWR : 1;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_CFG1_Type;
/* -------- USB2422_CFG2 : (USB2422L Offset: 0x07) (R/W 8) Configuration Data Byte 2-------- */
typedef union {
struct {
uint8_t : 3;
uint8_t COMPOUND : 1;
uint8_t OC_TIMER : 2;
uint8_t : 1;
uint8_t DYNAMIC : 1;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_CFG2_Type;
/* -------- USB2422_CFG3 : (USB2422L Offset: 0x08) (R/W 16) Configuration Data Byte 3-------- */
typedef union {
struct {
uint8_t STRING_EN : 1;
uint8_t : 2;
uint8_t PRTMAP_EN : 1;
uint8_t : 4;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_CFG3_Type;
/* -------- USB2422_NRD : (USB2422L Offset: 0x09) (R/W 8) Non Removable Device -------- */
typedef union {
struct {
uint8_t : 5;
uint8_t PORT2_NR : 1;
uint8_t PORT1_NR : 1;
uint8_t : 1;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_NRD_Type;
/* -------- USB2422_PDS : (USB2422L Offset: 0x0A) (R/W 8) Port Diable for Self-Powered Operation -------- */
typedef union {
struct {
uint8_t : 1;
uint8_t PORT1_DIS : 1;
uint8_t PORT2_DIS : 1;
uint8_t : 5;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_PDS_Type;
/* -------- USB2422_PDB : (USB2422L Offset: 0x0B) (R/W 8) Port Diable for Bus-Powered Operation -------- */
typedef union {
struct {
uint8_t : 1;
uint8_t PORT1_DIS : 1;
uint8_t PORT2_DIS : 1;
uint8_t : 5;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_PDB_Type;
/* -------- USB2422_MAXPS : (USB2422L Offset: 0x0C) (R/W 8) Max Power for Self-Powered Operation -------- */
typedef union {
struct {
uint8_t MAX_PWR_SP : 8;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_MAXPS_Type;
/* -------- USB2422_MAXPB : (USB2422L Offset: 0x0D) (R/W 8) Max Power for Bus-Powered Operation -------- */
typedef union {
struct {
uint8_t MAX_PWR_BP : 8;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_MAXPB_Type;
/* -------- USB2422_HCMCS : (USB2422L Offset: 0x0E) (R/W 8) Hub Controller Max Current for Self-Powered Operation -------- */
typedef union {
struct {
uint8_t HC_MAX_C_SP : 8;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_HCMCS_Type;
/* -------- USB2422_HCMCB : (USB2422L Offset: 0x0F) (R/W 8) Hub Controller Max Current for Bus-Powered Operation -------- */
typedef union {
struct {
uint8_t HC_MAX_C_BP : 8;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_HCMCB_Type;
/* -------- USB2422_PWRT : (USB2422L Offset: 0x10) (R/W 8) Power On Time -------- */
typedef union {
struct {
uint8_t POWER_ON_TIME : 8;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_PWRT_Type;
/* -------- USB2422_LANGID LSB : (USB2422L Offset: 0x11) (R/W 16) Language ID -------- */
typedef union {
struct {
uint8_t LANGID_LSB : 8;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_LANGID_LSB_Type;
/* -------- USB2422_LANGID MSB : (USB2422L Offset: 0x12) (R/W 16) Language ID -------- */
typedef union {
struct {
uint8_t LANGID_MSB : 8;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_LANGID_MSB_Type;
/* -------- USB2422_MFRSL : (USB2422L Offset: 0x13) (R/W 8) Manufacturer String Length -------- */
typedef union {
struct {
uint8_t MFR_STR_LEN : 8;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_MFRSL_Type;
/* -------- USB2422_PRDSL : (USB2422L Offset: 0x14) (R/W 8) Product String Length -------- */
typedef union {
struct {
uint8_t PRD_STR_LEN : 8;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_PRDSL_Type;
/* -------- USB2422_SERSL : (USB2422L Offset: 0x15) (R/W 8) Serial String Length -------- */
typedef union {
struct {
uint8_t SER_STR_LEN : 8;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_SERSL_Type;
/* -------- USB2422_MFRSTR : (USB2422L Offset: 0x16-53) (R/W 8) Maufacturer String -------- */
typedef uint16_t USB2422_MFRSTR_Type;
/* -------- USB2422_PRDSTR : (USB2422L Offset: 0x54-91) (R/W 8) Product String -------- */
typedef uint16_t USB2422_PRDSTR_Type;
/* -------- USB2422_SERSTR : (USB2422L Offset: 0x92-CF) (R/W 8) Serial String -------- */
typedef uint16_t USB2422_SERSTR_Type;
/* -------- USB2422_BCEN : (USB2422L Offset: 0xD0) (R/W 8) Battery Charging Enable -------- */
typedef union {
struct {
uint8_t : 1;
uint8_t PORT1_BCE : 1;
uint8_t PORT2_BCE : 1;
uint8_t : 5;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_BCEN_Type;
/* -------- USB2422_BOOSTUP : (USB2422L Offset: 0xF6) (R/W 8) Boost Upstream -------- */
typedef union {
struct {
uint8_t BOOST : 2;
uint8_t : 6;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_BOOSTUP_Type;
/* -------- USB2422_BOOSTDOWN : (USB2422L Offset: 0xF8) (R/W 8) Boost Downstream -------- */
typedef union {
struct {
uint8_t BOOST1 : 2;
uint8_t BOOST2 : 2;
uint8_t : 4;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_BOOSTDOWN_Type;
/* -------- USB2422_PRTSP : (USB2422L Offset: 0xFA) (R/W 8) Port Swap -------- */
typedef union {
struct {
uint8_t : 1;
uint8_t PORT1_SP : 1;
uint8_t PORT2_SP : 1;
uint8_t : 5;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_PRTSP_Type;
/* -------- USB2422_PRTR12 : (USB2422L Offset: 0xFB) (R/W 8) Port 1/2 Remap -------- */
typedef union {
struct {
uint8_t PORT1_REMAP : 4;
uint8_t PORT2_REMAP : 4;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_PRTR12_Type;
#define USB2422_PRTR12_DISABLE 0
#define USB2422_PRT12_P2TOL1 1
#define USB2422_PRT12_P2XTOL2 2
#define USB2422_PRT12_P1TOL1 1
#define USB2422_PRT12_P1XTOL2 2
/* -------- USB2422_STCD : (USB2422L Offset: 0xFF) (R/W 8) Status Command -------- */
typedef union {
struct {
uint8_t USB_ATTACH : 1;
uint8_t RESET : 1;
uint8_t INTF_PWRDN : 1;
uint8_t : 5;
} bit; /*!< Structure used for bit access */
uint8_t reg; /*!< Type used for register access */
} USB2422_STCD_Type;
/** \brief USB2422 device hardware registers */
typedef struct {
USB2422_VID_Type VID; /**< \brief Offset: 0x00*/
USB2422_PID_Type PID; /**< \brief Offset: 0x02*/
USB2422_DID_Type DID; /**< \brief Offset: 0x04*/
USB2422_CFG1_Type CFG1; /**< \brief Offset: 0x06*/
USB2422_CFG2_Type CFG2; /**< \brief Offset: 0x07*/
USB2422_CFG3_Type CFG3; /**< \brief Offset: 0x08*/
USB2422_NRD_Type NRD; /**< \brief Offset: 0x09*/
USB2422_PDS_Type PDS; /**< \brief Offset: 0x0A*/
USB2422_PDB_Type PDB; /**< \brief Offset: 0x0B*/
USB2422_MAXPS_Type MAXPS; /**< \brief Offset: 0x0C*/
USB2422_MAXPB_Type MAXPB; /**< \brief Offset: 0x0D*/
USB2422_HCMCS_Type HCMCS; /**< \brief Offset: 0x0E*/
USB2422_HCMCB_Type HCMCB; /**< \brief Offset: 0x0F*/
USB2422_PWRT_Type PWRT; /**< \brief Offset: 0x10*/
USB2422_LANGID_LSB_Type LANGID_LSB; /**< \brief Offset: 0x11*/
USB2422_LANGID_MSB_Type LANGID_MSB; /**< \brief Offset: 0x12*/
USB2422_MFRSL_Type MFRSL; /**< \brief Offset: 0x13*/
USB2422_PRDSL_Type PRDSL; /**< \brief Offset: 0x14*/
USB2422_SERSL_Type SERSL; /**< \brief Offset: 0x15*/
USB2422_MFRSTR_Type MFRSTR[31]; /**< \brief Offset: 0x16*/
USB2422_PRDSTR_Type PRDSTR[31]; /**< \brief Offset: 0x54*/
USB2422_SERSTR_Type SERSTR[31]; /**< \brief Offset: 0x92*/
USB2422_BCEN_Type BCEN; /**< \brief Offset: 0xD0*/
uint8_t Reserved1[0x25];
USB2422_BOOSTUP_Type BOOSTUP; /**< \brief Offset: 0xF6*/
uint8_t Reserved2[0x1];
USB2422_BOOSTDOWN_Type BOOSTDOWN; /**< \brief Offset: 0xF8*/
uint8_t Reserved3[0x1];
USB2422_PRTSP_Type PRTSP; /**< \brief Offset: 0xFA*/
USB2422_PRTR12_Type PRTR12; /**< \brief Offset: 0xFB*/
uint8_t Reserved4[0x3];
USB2422_STCD_Type STCD; /**< \brief Offset: 0xFF*/
} Usb2422_t;
// ***************************************************************
static Usb2422_t config;
// ***************************************************************
/** \brief Handle the conversion to allow simple strings
*/
static void USB2422_strcpy(const char* str, USB2422_MFRSTR_Type* dest, uint8_t len) {
for (uint8_t i = 0; i < len; i++) {
dest[i] = str[i];
}
}
/** \brief Handle the conversion to allow simple strings
*/
static void USB2422_write_block(void) {
static unsigned char i2c0_buf[34];
unsigned char* dest = i2c0_buf;
unsigned char* src;
unsigned char* base = (unsigned char*)&config;
for (src = base; src < base + 256; src += 32) {
dest[0] = src - base;
dest[1] = 32;
memcpy(&dest[2], src, 32);
i2c_transmit(USB2422_ADDRESS, dest, 34, 50000);
wait_us(100);
}
}
// ***************************************************************
void USB2422_init() {
#ifdef USB2422_RESET_PIN
setPinOutput(USB2422_RESET_PIN);
#endif
#ifdef USB2422_ACTIVE_PIN
setPinInput(USB2422_ACTIVE_PIN);
#endif
i2c_init(); // IC2 clk must be high at USB2422 reset release time to signal SMB configuration
}
void USB2422_configure() {
static const char SERNAME[] = "Unavailable";
memset(&config, 0, sizeof(Usb2422_t));
// configure Usb2422 registers
config.VID.reg = USB2422_VENDOR_ID;
config.PID.reg = USB2422_PRODUCT_ID;
config.DID.reg = USB2422_DEVICE_VER; // BCD format, eg 01.01
config.CFG1.bit.SELF_BUS_PWR = 1; // self powered for now
config.CFG1.bit.HS_DISABLE = 1; // full or high speed
// config.CFG2.bit.COMPOUND = 0; // compound device
config.CFG3.bit.STRING_EN = 1; // strings enabled
// config.NRD.bit.PORT2_NR = 0; // MCU is non-removable
config.MAXPB.reg = 20; // 0mA
config.HCMCB.reg = 20; // 0mA
config.MFRSL.reg = sizeof(USB2422_MANUFACTURER);
config.PRDSL.reg = sizeof(USB2422_PRODUCT);
config.SERSL.reg = sizeof(SERNAME);
USB2422_strcpy(USB2422_MANUFACTURER, config.MFRSTR, sizeof(USB2422_MANUFACTURER));
USB2422_strcpy(USB2422_PRODUCT, config.PRDSTR, sizeof(USB2422_PRODUCT));
USB2422_strcpy(SERNAME, config.SERSTR, sizeof(SERNAME));
// config.BOOSTUP.bit.BOOST=3; //upstream port
// config.BOOSTDOWN.bit.BOOST1=0; // extra port
// config.BOOSTDOWN.bit.BOOST2=2; //MCU is close
config.STCD.bit.USB_ATTACH = 1;
USB2422_write_block();
}
void USB2422_reset() {
#ifdef USB2422_RESET_PIN
writePinLow(USB2422_RESET_PIN);
wait_us(2);
writePinHigh(USB2422_RESET_PIN);
#endif
}
bool USB2422_active() {
#ifdef USB2422_ACTIVE_PIN
return readPin(USB2422_ACTIVE_PIN);
#else
return 1;
#endif
}

59
drivers/usb2422.h Normal file
View file

@ -0,0 +1,59 @@
/* Copyright 2021 QMK
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <stdbool.h>
#ifndef USB2422_ADDRESS
# define USB2422_ADDRESS 0x58
#endif
#ifndef USB2422_VENDOR_ID
# define USB2422_VENDOR_ID 0xFEED
#endif
#ifndef USB2422_PRODUCT_ID
# define USB2422_PRODUCT_ID 0x0001
#endif
#ifndef USB2422_DEVICE_VER
# define USB2422_DEVICE_VER 0x0001
#endif
#ifndef USB2422_MANUFACTURER
# define USB2422_MANUFACTURER "QMK"
#endif
#ifndef USB2422_PRODUCT
# define USB2422_PRODUCT "QMK Hub"
#endif
/** \brief Initialises the dependent subsystems */
void USB2422_init(void);
/** \brief Push configuration to the USB2422 device */
void USB2422_configure(void);
/** \brief Reset the chip (RESET_N)
*
* NOTE:
* Depends on a valid USB2422_RESET_PIN configuration
*/
void USB2422_reset(void);
/** \brief Indicates the USB state of the hub (SUSP_IND)
*
* NOTE:
* Depends on a valid USB2422_ACTIVE_PIN configuration
*/
bool USB2422_active(void);

2
keyboards/massdrop/alt/alt.h
View file

@ -7,7 +7,7 @@
#include "i2c_master.h"
#include "md_rgb_matrix.h" //For led keycodes
#include "usb/udi_cdc.h"
#include "usb/usb2422.h"
#include "usb/usb_hub.h"
#define LAYOUT_65_ansi_blocker( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K10, K11, K12, K13, K14, K15, \

9
keyboards/massdrop/alt/config.h
View file

@ -90,6 +90,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define DEBUG_BOOT_TRACING_PORT PB
#define DEBUG_BOOT_TRACING_PIN 23
/* USB2422 config */
#define USB2422_ADDRESS 0x58
#define USB2422_VENDOR_ID 0x04D8
#define USB2422_PRODUCT_ID 0xEEC5
#define USB2422_DEVICE_VER 0x0101
#define USB2422_MANUFACTURER "Massdrop Inc."
#define USB2422_PRODUCT "Massdrop Hub"
#define USB2422_ACTIVE_PIN A18
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
#define DEBOUNCE 5

9
keyboards/massdrop/ctrl/config.h
View file

@ -89,6 +89,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#define DEBUG_BOOT_TRACING_PORT PB
#define DEBUG_BOOT_TRACING_PIN 23
/* USB2422 config */
#define USB2422_ADDRESS 0x58
#define USB2422_VENDOR_ID 0x04D8
#define USB2422_PRODUCT_ID 0xEEC5
#define USB2422_DEVICE_VER 0x0101
#define USB2422_MANUFACTURER "Massdrop Inc."
#define USB2422_PRODUCT "Massdrop Hub"
#define USB2422_ACTIVE_PIN A18
/* Debounce reduces chatter (unintended double-presses) - set 0 if debouncing is not needed */
#define DEBOUNCE 5

2
keyboards/massdrop/ctrl/ctrl.h
View file

@ -7,7 +7,7 @@
#include "i2c_master.h"
#include "md_rgb_matrix.h" //For led keycodes
#include "usb/udi_cdc.h"
#include "usb/usb2422.h"
#include "usb/usb_hub.h"
#define LAYOUT( \
K01, K02, K03, K04, K05, K06, K07, K08, K09, K10, K11, K12, K13, K14, K15, \

4
tmk_core/protocol/arm_atsam.mk
View file

@ -20,10 +20,12 @@ SRC += $(ARM_ATSAM_DIR)/usb/udi_hid.c
SRC += $(ARM_ATSAM_DIR)/usb/udi_hid_kbd.c
SRC += $(ARM_ATSAM_DIR)/usb/udi_hid_kbd_desc.c
SRC += $(ARM_ATSAM_DIR)/usb/ui.c
SRC += $(ARM_ATSAM_DIR)/usb/usb2422.c
SRC += $(ARM_ATSAM_DIR)/usb/usb.c
SRC += $(ARM_ATSAM_DIR)/usb/usb_device_udd.c
SRC += $(ARM_ATSAM_DIR)/usb/usb_hub.c
SRC += $(ARM_ATSAM_DIR)/usb/usb_util.c
SRC += $(DRIVER_PATH)/usb2422.c
# Search Path
VPATH += $(TMK_DIR)/$(ARM_ATSAM_DIR)

2
tmk_core/protocol/arm_atsam/arm_atsam_protocol.h
View file

@ -29,7 +29,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "i2c_master.h"
#include "shift_register.h"
#include "./usb/usb2422.h"
#include "./usb/usb_hub.h"
#ifndef MD_BOOTLOADER

19
tmk_core/protocol/arm_atsam/i2c_master.c
View file

@ -564,4 +564,23 @@ uint8_t i2c_led_q_run(void) {
return 1;
}
__attribute__((weak)) void i2c_init(void) {
static bool is_initialised = false;
if (!is_initialised) {
is_initialised = true;
i2c0_init();
}
}
i2c_status_t i2c_transmit(uint8_t address, const uint8_t *data, uint16_t length, uint16_t timeout) {
uint8_t ret = i2c0_transmit(address, (uint8_t *)data, length, timeout);
SERCOM0->I2CM.CTRLB.bit.CMD = 0x03;
while (SERCOM0->I2CM.SYNCBUSY.bit.SYSOP) {
DBGC(DC_USB_WRITE2422_BLOCK_SYNC_SYSOP);
}
return ret ? I2C_STATUS_SUCCESS : I2C_STATUS_ERROR;
}
#endif // !defined(MD_BOOTLOADER) && defined(RGB_MATRIX_ENABLE)

9
tmk_core/protocol/arm_atsam/i2c_master.h
View file

@ -101,4 +101,13 @@ void i2c0_init(void);
uint8_t i2c0_transmit(uint8_t address, uint8_t *data, uint16_t length, uint16_t timeout);
void i2c0_stop(void);
// Terrible interface compatiblity...
#define I2C_STATUS_SUCCESS (0)
#define I2C_STATUS_ERROR (-1)
typedef int16_t i2c_status_t;
void i2c_init(void);
i2c_status_t i2c_transmit(uint8_t address, const uint8_t *data, uint16_t length, uint16_t timeout);
#endif // _I2C_MASTER_H_

4
tmk_core/protocol/arm_atsam/main_arm_atsam.c
View file

@ -296,7 +296,7 @@ int main(void) {
matrix_init();
USB2422_init();
USB_Hub_init();
DBGC(DC_MAIN_UDC_START_BEGIN);
udc_start();
@ -306,7 +306,7 @@ int main(void) {
CDC_init();
DBGC(DC_MAIN_CDC_INIT_COMPLETE);
while (USB2422_Port_Detect_Init() == 0) {
while (USB_Hub_Port_Detect_Init() == 0) {
}
DBG_LED_OFF;

340
tmk_core/protocol/arm_atsam/usb/usb_hub.c Normal file
View file

@ -0,0 +1,340 @@
/*
Copyright 2018 Massdrop Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "arm_atsam_protocol.h"
#include "drivers/usb2422.h"
#include <string.h>
uint8_t usb_host_port;
#ifndef MD_BOOTLOADER
uint8_t usb_extra_state;
uint8_t usb_extra_manual;
uint8_t usb_gcr_auto;
#endif // MD_BOOTLOADER
uint16_t adc_extra;
void USB_Hub_init(void) {
Gclk * pgclk = GCLK;
Mclk * pmclk = MCLK;
Port * pport = PORT;
Oscctrl *posc = OSCCTRL;
Usb * pusb = USB;
DBGC(DC_USB2422_INIT_BEGIN);
while ((v_5v = adc_get(ADC_5V)) < ADC_5V_START_LEVEL) {
DBGC(DC_USB2422_INIT_WAIT_5V_LOW);
}
// setup peripheral and synchronous bus clocks to USB
pgclk->PCHCTRL[10].bit.GEN = 0;
pgclk->PCHCTRL[10].bit.CHEN = 1;
pmclk->AHBMASK.bit.USB_ = 1;
pmclk->APBBMASK.bit.USB_ = 1;
// setup port pins for D-, D+, and SOF_1KHZ
pport->Group[0].PMUX[12].reg = 0x77; // PA24, PA25, function column H for USB D-, D+
pport->Group[0].PINCFG[24].bit.PMUXEN = 1;
pport->Group[0].PINCFG[25].bit.PMUXEN = 1;
pport->Group[1].PMUX[11].bit.PMUXE = 7; // PB22, function column H for USB SOF_1KHz output
pport->Group[1].PINCFG[22].bit.PMUXEN = 1;
// configure and enable DFLL for USB clock recovery mode at 48MHz
posc->DFLLCTRLA.bit.ENABLE = 0;
while (posc->DFLLSYNC.bit.ENABLE) {
DBGC(DC_USB2422_INIT_OSC_SYNC_DISABLING);
}
while (posc->DFLLSYNC.bit.DFLLCTRLB) {
DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_1);
}
posc->DFLLCTRLB.bit.USBCRM = 1;
while (posc->DFLLSYNC.bit.DFLLCTRLB) {
DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_2);
}
posc->DFLLCTRLB.bit.MODE = 1;
while (posc->DFLLSYNC.bit.DFLLCTRLB) {
DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_3);
}
posc->DFLLCTRLB.bit.QLDIS = 0;
while (posc->DFLLSYNC.bit.DFLLCTRLB) {
DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLCTRLB_4);
}
posc->DFLLCTRLB.bit.CCDIS = 1;
posc->DFLLMUL.bit.MUL = 0xBB80; // 4800 x 1KHz
while (posc->DFLLSYNC.bit.DFLLMUL) {
DBGC(DC_USB2422_INIT_OSC_SYNC_DFLLMUL);
}
posc->DFLLCTRLA.bit.ENABLE = 1;
while (posc->DFLLSYNC.bit.ENABLE) {
DBGC(DC_USB2422_INIT_OSC_SYNC_ENABLING);
}
pusb->DEVICE.CTRLA.bit.SWRST = 1;
while (pusb->DEVICE.SYNCBUSY.bit.SWRST) {
DBGC(DC_USB2422_INIT_USB_SYNC_SWRST);
}
while (pusb->DEVICE.CTRLA.bit.SWRST) {
DBGC(DC_USB2422_INIT_USB_WAIT_SWRST);
}
// calibration from factory presets
pusb->DEVICE.PADCAL.bit.TRANSN = (USB_FUSES_TRANSN_ADDR >> USB_FUSES_TRANSN_Pos) & USB_FUSES_TRANSN_Msk;
pusb->DEVICE.PADCAL.bit.TRANSP = (USB_FUSES_TRANSP_ADDR >> USB_FUSES_TRANSP_Pos) & USB_FUSES_TRANSP_Msk;
pusb->DEVICE.PADCAL.bit.TRIM = (USB_FUSES_TRIM_ADDR >> USB_FUSES_TRIM_Pos) & USB_FUSES_TRIM_Msk;
// device mode, enabled
pusb->DEVICE.CTRLB.bit.SPDCONF = 0; // full speed
pusb->DEVICE.CTRLA.bit.MODE = 0;
pusb->DEVICE.CTRLA.bit.ENABLE = 1;
while (pusb->DEVICE.SYNCBUSY.bit.ENABLE) {
DBGC(DC_USB2422_INIT_USB_SYNC_ENABLING);
}
pusb->DEVICE.QOSCTRL.bit.DQOS = 2;
pusb->DEVICE.QOSCTRL.bit.CQOS = 2;
USB2422_init();
sr_exp_data.bit.HUB_CONNECT = 1; // connect signal
sr_exp_data.bit.HUB_RESET_N = 1; // reset high
SR_EXP_WriteData();
wait_us(100);
#ifndef MD_BOOTLOADER
usb_extra_manual = 0;
usb_gcr_auto = 1;
#endif // MD_BOOTLOADER
DBGC(DC_USB2422_INIT_COMPLETE);
}
void USB_reset(void) {
DBGC(DC_USB_RESET_BEGIN);
// pulse reset for at least 1 usec
sr_exp_data.bit.HUB_RESET_N = 0; // reset low
SR_EXP_WriteData();
wait_us(2);
sr_exp_data.bit.HUB_RESET_N = 1; // reset high to run
SR_EXP_WriteData();
DBGC(DC_USB_RESET_COMPLETE);
}
void USB_configure(void) {
DBGC(DC_USB_CONFIGURE_BEGIN);
USB2422_configure();
adc_extra = 0;
DBGC(DC_USB_CONFIGURE_COMPLETE);
}
uint16_t USB_active(void) { return USB2422_active(); }
void USB_set_host_by_voltage(void) {
// UP is upstream device (HOST)
// DN1 is downstream device (EXTRA)
// DN2 is keyboard (KEYB)
DBGC(DC_USB_SET_HOST_BY_VOLTAGE_BEGIN);
usb_host_port = USB_HOST_PORT_UNKNOWN;
#ifndef MD_BOOTLOADER
usb_extra_state = USB_EXTRA_STATE_UNKNOWN;
#endif // MD_BOOTLOADER
sr_exp_data.bit.SRC_1 = 1; // USBC-1 available for test
sr_exp_data.bit.SRC_2 = 1; // USBC-2 available for test
sr_exp_data.bit.E_UP_N = 1; // HOST disable
sr_exp_data.bit.E_DN1_N = 1; // EXTRA disable
sr_exp_data.bit.E_VBUS_1 = 0; // USBC-1 disable full power I/O
sr_exp_data.bit.E_VBUS_2 = 0; // USBC-2 disable full power I/O
SR_EXP_WriteData();
wait_ms(250);
while ((v_5v = adc_get(ADC_5V)) < ADC_5V_START_LEVEL) {
DBGC(DC_USB_SET_HOST_5V_LOW_WAITING);
}
v_con_1 = adc_get(ADC_CON1);
v_con_2 = adc_get(ADC_CON2);
v_con_1_boot = v_con_1;
v_con_2_boot = v_con_2;
if (v_con_1 > v_con_2) {
sr_exp_data.bit.S_UP = 0; // HOST to USBC-1
sr_exp_data.bit.S_DN1 = 1; // EXTRA to USBC-2
sr_exp_data.bit.SRC_1 = 1; // HOST on USBC-1
sr_exp_data.bit.SRC_2 = 0; // EXTRA available on USBC-2
sr_exp_data.bit.E_VBUS_1 = 1; // USBC-1 enable full power I/O
sr_exp_data.bit.E_VBUS_2 = 0; // USBC-2 disable full power I/O
SR_EXP_WriteData();
sr_exp_data.bit.E_UP_N = 0; // HOST enable
SR_EXP_WriteData();
usb_host_port = USB_HOST_PORT_1;
} else {
sr_exp_data.bit.S_UP = 1; // EXTRA to USBC-1
sr_exp_data.bit.S_DN1 = 0; // HOST to USBC-2
sr_exp_data.bit.SRC_1 = 0; // EXTRA available on USBC-1
sr_exp_data.bit.SRC_2 = 1; // HOST on USBC-2
sr_exp_data.bit.E_VBUS_1 = 0; // USBC-1 disable full power I/O
sr_exp_data.bit.E_VBUS_2 = 1; // USBC-2 enable full power I/O
SR_EXP_WriteData();
sr_exp_data.bit.E_UP_N = 0; // HOST enable
SR_EXP_WriteData();
usb_host_port = USB_HOST_PORT_2;
}
#ifndef MD_BOOTLOADER
usb_extra_state = USB_EXTRA_STATE_DISABLED;
#endif // MD_BOOTLOADER
USB_reset();
USB_configure();
DBGC(DC_USB_SET_HOST_BY_VOLTAGE_COMPLETE);
}
uint8_t USB_Hub_Port_Detect_Init(void) {
uint32_t port_detect_retry_ms;
uint32_t tmod;
DBGC(DC_PORT_DETECT_INIT_BEGIN);
USB_set_host_by_voltage();
port_detect_retry_ms = timer_read64() + PORT_DETECT_RETRY_INTERVAL;
while (!USB_active()) {
tmod = timer_read64() % PORT_DETECT_RETRY_INTERVAL;
if (v_con_1 > v_con_2) // Values updated from USB_set_host_by_voltage();
{
// 1 flash for port 1 detected
if (tmod > 500 && tmod < 600) {
DBG_LED_ON;
} else {
DBG_LED_OFF;
}
} else if (v_con_2 > v_con_1) // Values updated from USB_set_host_by_voltage();
{
// 2 flash for port 2 detected
if (tmod > 500 && tmod < 600) {
DBG_LED_ON;
} else if (tmod > 700 && tmod < 800) {
DBG_LED_ON;
} else {
DBG_LED_OFF;
}
}
if (timer_read64() > port_detect_retry_ms) {
DBGC(DC_PORT_DETECT_INIT_FAILED);
return 0;
}
}
DBGC(DC_PORT_DETECT_INIT_COMPLETE);
return 1;
}
#ifndef MD_BOOTLOADER
void USB_ExtraSetState(uint8_t state) {
uint8_t state_save = state;
if (state == USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG) state = USB_EXTRA_STATE_DISABLED;
if (usb_host_port == USB_HOST_PORT_1)
sr_exp_data.bit.E_VBUS_2 = state;
else if (usb_host_port == USB_HOST_PORT_2)
sr_exp_data.bit.E_VBUS_1 = state;
else
return;
sr_exp_data.bit.E_DN1_N = !state;
SR_EXP_WriteData();
usb_extra_state = state_save;
if (usb_extra_state == USB_EXTRA_STATE_ENABLED)
CDC_print("USB: Extra enabled\r\n");
else if (usb_extra_state == USB_EXTRA_STATE_DISABLED) {
CDC_print("USB: Extra disabled\r\n");
# ifdef USE_MASSDROP_CONFIGURATOR
if (led_animation_breathing) gcr_breathe = gcr_desired;
# endif
} else if (usb_extra_state == USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG)
CDC_print("USB: Extra disabled until replug\r\n");
else
CDC_print("USB: Extra state unknown\r\n");
}
void USB_HandleExtraDevice(void) {
uint16_t adcval;
if (usb_host_port == USB_HOST_PORT_1)
adcval = adc_get(ADC_CON2);
else if (usb_host_port == USB_HOST_PORT_2)
adcval = adc_get(ADC_CON1);
else
return;
adc_extra = adc_extra * 0.9 + adcval * 0.1;
// Check for a forced disable state (such as overload prevention)
if (usb_extra_state == USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG) {
// Detect unplug and reset state to disabled
if (adc_extra > USB_EXTRA_ADC_THRESHOLD) usb_extra_state = USB_EXTRA_STATE_DISABLED;
return; // Return even if unplug detected
}
if (usb_extra_manual) {
if (usb_extra_state == USB_EXTRA_STATE_DISABLED) USB_ExtraSetState(USB_EXTRA_STATE_ENABLED);
return;
}
// dpf("a %i %i\r\n",adcval, adc_extra);
if (usb_extra_state == USB_EXTRA_STATE_DISABLED && adc_extra < USB_EXTRA_ADC_THRESHOLD)
USB_ExtraSetState(USB_EXTRA_STATE_ENABLED);
else if (usb_extra_state == USB_EXTRA_STATE_ENABLED && adc_extra > USB_EXTRA_ADC_THRESHOLD)
USB_ExtraSetState(USB_EXTRA_STATE_DISABLED);
}
#endif // MD_BOOTLOADER

51
tmk_core/protocol/arm_atsam/usb/usb_hub.h Normal file
View file

@ -0,0 +1,51 @@
/*
Copyright 2018 Massdrop Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _USB2422_H_
#define _USB2422_H_
#define REV_USB2422 0x100
#define PORT_DETECT_RETRY_INTERVAL 2000
#define USB_EXTRA_ADC_THRESHOLD 900
#define USB_EXTRA_STATE_DISABLED 0
#define USB_EXTRA_STATE_ENABLED 1
#define USB_EXTRA_STATE_UNKNOWN 2
#define USB_EXTRA_STATE_DISABLED_UNTIL_REPLUG 3
#define USB_HOST_PORT_1 0
#define USB_HOST_PORT_2 1
#define USB_HOST_PORT_UNKNOWN 2
extern uint8_t usb_host_port;
extern uint8_t usb_extra_state;
extern uint8_t usb_extra_manual;
extern uint8_t usb_gcr_auto;
void USB_Hub_init(void);
uint8_t USB_Hub_Port_Detect_Init(void);
void USB_reset(void);
void USB_configure(void);
uint16_t USB_active(void);
void USB_set_host_by_voltage(void);
uint16_t adc_get(uint8_t muxpos);
void USB_HandleExtraDevice(void);
void USB_ExtraSetState(uint8_t state);
#endif //_USB2422_H_