SunRed/Marlin-Artillery-M600
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Standardize some hexadecimals

Browse source
This commit is contained in:
Scott Lahteine 2018-05-08 09:17:44 -05:00
parent ec05408453
commit d1b619be52
27 changed files with 204 additions and 204 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Marlin/src/HAL/HAL_DUE/HAL_spi_Due.cpp
View file

@ -839,7 +839,7 @@
REG_PMC_PCER0 = (1UL << ID_PIOA) | (1UL << ID_SPI0); REG_PMC_PCER0 = (1UL << ID_PIOA) | (1UL << ID_SPI0);
// Disable PIO on A26 and A27 // Disable PIO on A26 and A27
REG_PIOA_PDR = 0x0c000000; REG_PIOA_PDR = 0x0C000000;
OUT_WRITE(SDSS, 1); OUT_WRITE(SDSS, 1);
// Reset SPI0 (from sam lib) // Reset SPI0 (from sam lib)

6
Marlin/src/HAL/HAL_DUE/u8g_com_HAL_DUE_st7920_sw_spi.cpp
View file

@ -122,16 +122,16 @@ static void u8g_com_DUE_st7920_write_byte_sw_spi(uint8_t rs, uint8_t val) {
if ( rs == 0 ) if ( rs == 0 )
/* command */ /* command */
spiSend_sw_DUE(0x0f8); spiSend_sw_DUE(0x0F8);
else else
/* data */ /* data */
spiSend_sw_DUE(0x0fa); spiSend_sw_DUE(0x0FA);
for (i = 0; i < 4; i++) // give the controller some time to process the data for (i = 0; i < 4; i++) // give the controller some time to process the data
u8g_10MicroDelay(); // 2 is bad, 3 is OK, 4 is safe u8g_10MicroDelay(); // 2 is bad, 3 is OK, 4 is safe
} }
spiSend_sw_DUE(val & 0x0f0); spiSend_sw_DUE(val & 0x0F0);
spiSend_sw_DUE(val << 4); spiSend_sw_DUE(val << 4);
} }

2
Marlin/src/HAL/HAL_DUE/usb/pll.h
View file

@ -74,7 +74,7 @@ extern "C" {
#define PLL_UPLL_HZ 480000000 #define PLL_UPLL_HZ 480000000
#define PLL_COUNT 0x3fU #define PLL_COUNT 0x3FU
enum pll_source { enum pll_source {
PLL_SRC_MAINCK_4M_RC = OSC_MAINCK_4M_RC, //!< Internal 4MHz RC oscillator. PLL_SRC_MAINCK_4M_RC = OSC_MAINCK_4M_RC, //!< Internal 4MHz RC oscillator.

24
Marlin/src/HAL/HAL_DUE/usb/spc_protocol.h
View file

@ -96,13 +96,13 @@ struct scsi_inquiry_data {
#define SCSI_INQ_DT_CD_DVD 0x05 //!< CD/DVD device #define SCSI_INQ_DT_CD_DVD 0x05 //!< CD/DVD device
#define SCSI_INQ_DT_OPTICAL 0x07 //!< Optical Memory #define SCSI_INQ_DT_OPTICAL 0x07 //!< Optical Memory
#define SCSI_INQ_DT_MC 0x08 //!< Medium Changer #define SCSI_INQ_DT_MC 0x08 //!< Medium Changer
#define SCSI_INQ_DT_ARRAY 0x0c //!< Storage Array Controller #define SCSI_INQ_DT_ARRAY 0x0C //!< Storage Array Controller
#define SCSI_INQ_DT_ENCLOSURE 0x0d //!< Enclosure Services #define SCSI_INQ_DT_ENCLOSURE 0x0D //!< Enclosure Services
#define SCSI_INQ_DT_RBC 0x0e //!< Simplified Direct Access #define SCSI_INQ_DT_RBC 0x0E //!< Simplified Direct Access
#define SCSI_INQ_DT_OCRW 0x0f //!< Optical card reader/writer #define SCSI_INQ_DT_OCRW 0x0F //!< Optical card reader/writer
#define SCSI_INQ_DT_BCC 0x10 //!< Bridge Controller Commands #define SCSI_INQ_DT_BCC 0x10 //!< Bridge Controller Commands
#define SCSI_INQ_DT_OSD 0x11 //!< Object-based Storage #define SCSI_INQ_DT_OSD 0x11 //!< Object-based Storage
#define SCSI_INQ_DT_NONE 0x1f //!< No Peripheral #define SCSI_INQ_DT_NONE 0x1F //!< No Peripheral
uint8_t flags1; //!< Flags (byte 1) uint8_t flags1; //!< Flags (byte 1)
#define SCSI_INQ_RMB 0x80 //!< Removable Medium #define SCSI_INQ_RMB 0x80 //!< Removable Medium
uint8_t version; //!< Version uint8_t version; //!< Version
@ -213,17 +213,17 @@ enum scsi_sense_key {
SCSI_SK_DATA_PROTECT = 0x7, SCSI_SK_DATA_PROTECT = 0x7,
SCSI_SK_BLANK_CHECK = 0x8, SCSI_SK_BLANK_CHECK = 0x8,
SCSI_SK_VENDOR_SPECIFIC = 0x9, SCSI_SK_VENDOR_SPECIFIC = 0x9,
SCSI_SK_COPY_ABORTED = 0xa, SCSI_SK_COPY_ABORTED = 0xA,
SCSI_SK_ABORTED_COMMAND = 0xb, SCSI_SK_ABORTED_COMMAND = 0xB,
SCSI_SK_VOLUME_OVERFLOW = 0xd, SCSI_SK_VOLUME_OVERFLOW = 0xD,
SCSI_SK_MISCOMPARE = 0xe, SCSI_SK_MISCOMPARE = 0xE,
}; };
/* Additional Sense Code / Additional Sense Code Qualifier pairs */ /* Additional Sense Code / Additional Sense Code Qualifier pairs */
enum scsi_asc_ascq { enum scsi_asc_ascq {
SCSI_ASC_NO_ADDITIONAL_SENSE_INFO = 0x0000, SCSI_ASC_NO_ADDITIONAL_SENSE_INFO = 0x0000,
SCSI_ASC_LU_NOT_READY_REBUILD_IN_PROGRESS = 0x0405, SCSI_ASC_LU_NOT_READY_REBUILD_IN_PROGRESS = 0x0405,
SCSI_ASC_WRITE_ERROR = 0x0c00, SCSI_ASC_WRITE_ERROR = 0x0C00,
SCSI_ASC_UNRECOVERED_READ_ERROR = 0x1100, SCSI_ASC_UNRECOVERED_READ_ERROR = 0x1100,
SCSI_ASC_INVALID_COMMAND_OPERATION_CODE = 0x2000, SCSI_ASC_INVALID_COMMAND_OPERATION_CODE = 0x2000,
SCSI_ASC_INVALID_FIELD_IN_CDB = 0x2400, SCSI_ASC_INVALID_FIELD_IN_CDB = 0x2400,
@ -242,7 +242,7 @@ enum scsi_asc_ascq {
enum scsi_spc_mode { enum scsi_spc_mode {
SCSI_MS_MODE_VENDOR_SPEC = 0x00, SCSI_MS_MODE_VENDOR_SPEC = 0x00,
SCSI_MS_MODE_INFEXP = 0x1C, // Informational exceptions control page SCSI_MS_MODE_INFEXP = 0x1C, // Informational exceptions control page
SCSI_MS_MODE_ALL = 0x3f, SCSI_MS_MODE_ALL = 0x3F,
}; };
/** /**
@ -289,7 +289,7 @@ static inline bool scsi_mode_sense_dbd_is_set(const uint8_t * cdb)
static inline uint8_t scsi_mode_sense_get_page_code(const uint8_t * cdb) static inline uint8_t scsi_mode_sense_get_page_code(const uint8_t * cdb)
{ {
return cdb[2] & 0x3f; return cdb[2] & 0x3F;
} }
static inline uint8_t scsi_mode_sense_get_pc(const uint8_t * cdb) static inline uint8_t scsi_mode_sense_get_pc(const uint8_t * cdb)

6
Marlin/src/HAL/HAL_DUE/usb/udc.c
View file

@ -527,7 +527,7 @@ static bool udc_req_std_dev_set_feature(void)
if (!udd_is_high_speed()) { if (!udd_is_high_speed()) {
break; break;
} }
if (udd_g_ctrlreq.req.wIndex & 0xff) { if (udd_g_ctrlreq.req.wIndex & 0xFF) {
break; break;
} }
// Unconfigure the device, terminating all ongoing requests // Unconfigure the device, terminating all ongoing requests
@ -618,7 +618,7 @@ static bool udc_req_std_dev_get_str_desc(void)
uint8_t str_length = 0; uint8_t str_length = 0;
// Link payload pointer to the string corresponding at request // Link payload pointer to the string corresponding at request
switch (udd_g_ctrlreq.req.wValue & 0xff) { switch (udd_g_ctrlreq.req.wValue & 0xFF) {
case 0: case 0:
udd_set_setup_payload((uint8_t *) &udc_string_desc_languageid, udd_set_setup_payload((uint8_t *) &udc_string_desc_languageid,
sizeof(udc_string_desc_languageid)); sizeof(udc_string_desc_languageid));
@ -674,7 +674,7 @@ static bool udc_req_std_dev_get_descriptor(void)
{ {
uint8_t conf_num; uint8_t conf_num;
conf_num = udd_g_ctrlreq.req.wValue & 0xff; conf_num = udd_g_ctrlreq.req.wValue & 0xFF;
// Check descriptor ID // Check descriptor ID
switch ((uint8_t) (udd_g_ctrlreq.req.wValue >> 8)) { switch ((uint8_t) (udd_g_ctrlreq.req.wValue >> 8)) {

2
Marlin/src/HAL/HAL_DUE/usb/usb_protocol.h
View file

@ -271,7 +271,7 @@ enum usb_langid {
/** /**
* \brief Mask selecting the index part of an endpoint address * \brief Mask selecting the index part of an endpoint address
*/ */
#define USB_EP_ADDR_MASK 0x0f #define USB_EP_ADDR_MASK 0x0F
//! \brief USB address identifier //! \brief USB address identifier
typedef uint8_t usb_add_t; typedef uint8_t usb_add_t;

2
Marlin/src/HAL/HAL_DUE/usb/usb_task.c
View file

@ -225,7 +225,7 @@ bool usb_task_extra_string(void) {
uint8_t str_lgt = 0; uint8_t str_lgt = 0;
// Link payload pointer to the string corresponding at request // Link payload pointer to the string corresponding at request
switch (udd_g_ctrlreq.req.wValue & 0xff) { switch (udd_g_ctrlreq.req.wValue & 0xFF) {
case UDI_CDC_IAD_STRING_ID: case UDI_CDC_IAD_STRING_ID:
str_lgt = sizeof(udi_cdc_name) - 1; str_lgt = sizeof(udi_cdc_name) - 1;
str = udi_cdc_name; str = udi_cdc_name;

2
Marlin/src/HAL/HAL_LPC1768/HAL.cpp
View file

@ -247,7 +247,7 @@ uint16_t HAL_adc_get_result(void) {
data = lowpass_filter[adc_channel].update(data); data = lowpass_filter[adc_channel].update(data);
#endif #endif
return ((data >> 2) & 0x3ff); // return 10bit value as Marlin expects return ((data >> 2) & 0x3FF); // return 10bit value as Marlin expects
} }
#define SBIT_CNTEN 0 #define SBIT_CNTEN 0

4
Marlin/src/HAL/HAL_LPC1768/HAL_spi.cpp
View file

@ -83,14 +83,14 @@
} }
uint8_t spiRec() { uint8_t spiRec() {
uint8_t b = spiTransfer(0xff); uint8_t b = spiTransfer(0xFF);
return b; return b;
} }
void spiRead(uint8_t*buf, uint16_t nbyte) { void spiRead(uint8_t*buf, uint16_t nbyte) {
if (nbyte == 0) return; if (nbyte == 0) return;
for (int i = 0; i < nbyte; i++) { for (int i = 0; i < nbyte; i++) {
buf[i] = spiTransfer(0xff); buf[i] = spiTransfer(0xFF);
} }
} }

2
Marlin/src/HAL/HAL_LPC1768/LPC1768_PWM.cpp
View file

@ -213,7 +213,7 @@ void LPC1768_PWM_sort(void) {
} }
} }
bool LPC1768_PWM_attach_pin(pin_t pin, uint32_t min /* = 1 */, uint32_t max /* = (LPC_PWM1_MR0 - 1) */, uint8_t servo_index /* = 0xff */) { bool LPC1768_PWM_attach_pin(pin_t pin, uint32_t min /* = 1 */, uint32_t max /* = (LPC_PWM1_MR0 - 1) */, uint8_t servo_index /* = 0xFF */) {
pin = GET_PIN_MAP_PIN(GET_PIN_MAP_INDEX(pin & 0xFF)); // Sometimes the upper byte is garbled pin = GET_PIN_MAP_PIN(GET_PIN_MAP_INDEX(pin & 0xFF)); // Sometimes the upper byte is garbled

2
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_hw_i2c.cpp
View file

@ -79,7 +79,7 @@
#include <U8glib.h> #include <U8glib.h>
#define I2C_SLA (0x3c*2) #define I2C_SLA (0x3C*2)
//#define I2C_CMD_MODE 0x080 //#define I2C_CMD_MODE 0x080
#define I2C_CMD_MODE 0x000 #define I2C_CMD_MODE 0x000
#define I2C_DATA_MODE 0x040 #define I2C_DATA_MODE 0x040

2
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_ssd_sw_i2c.cpp under construction
View file

@ -68,7 +68,7 @@ void delayMicroseconds(uint32_t us);
//void digitalWrite(int16_t pin, uint8_t pin_status); //void digitalWrite(int16_t pin, uint8_t pin_status);
#define I2C_SLA (0x3c*2) #define I2C_SLA (0x3C*2)
//#define I2C_CMD_MODE 0x080 //#define I2C_CMD_MODE 0x080
#define I2C_CMD_MODE 0x000 #define I2C_CMD_MODE 0x000
#define I2C_DATA_MODE 0x040 #define I2C_DATA_MODE 0x040

6
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_hw_spi.cpp
View file

@ -87,16 +87,16 @@
if ( rs == 0 ) if ( rs == 0 )
/* command */ /* command */
spiSend(0x0f8); spiSend(0x0F8);
else else
/* data */ /* data */
spiSend(0x0fa); spiSend(0x0FA);
for( i = 0; i < 4; i++ ) // give the controller some time to process the data for( i = 0; i < 4; i++ ) // give the controller some time to process the data
u8g_10MicroDelay(); // 2 is bad, 3 is OK, 4 is safe u8g_10MicroDelay(); // 2 is bad, 3 is OK, 4 is safe
} }
spiSend(val & 0x0f0); spiSend(val & 0x0F0);
spiSend(val << 4); spiSend(val << 4);
} }

6
Marlin/src/HAL/HAL_LPC1768/u8g_com_HAL_LPC1768_st7920_sw_spi.cpp
View file

@ -73,16 +73,16 @@
if ( rs == 0 ) if ( rs == 0 )
/* command */ /* command */
swSpiTransfer(0x0f8, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL); swSpiTransfer(0x0F8, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
else else
/* data */ /* data */
swSpiTransfer(0x0fa, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL); swSpiTransfer(0x0FA, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
for( i = 0; i < 4; i++ ) // give the controller some time to process the data for( i = 0; i < 4; i++ ) // give the controller some time to process the data
u8g_10MicroDelay(); // 2 is bad, 3 is OK, 4 is safe u8g_10MicroDelay(); // 2 is bad, 3 is OK, 4 is safe
} }
swSpiTransfer(val & 0x0f0, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL); swSpiTransfer(val & 0x0F0, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
swSpiTransfer(val << 4, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL); swSpiTransfer(val << 4, SPI_speed, SCK_pin_ST7920_HAL, -1, MOSI_pin_ST7920_HAL_HAL);
} }

4
Marlin/src/HAL/HAL_STM32F7/TMC2660.cpp
View file

@ -68,7 +68,7 @@
//definitions for the chopper config register //definitions for the chopper config register
#define CHOPPER_MODE_STANDARD 0x0ul #define CHOPPER_MODE_STANDARD 0x0ul
#define CHOPPER_MODE_T_OFF_FAST_DECAY 0x4000ul #define CHOPPER_MODE_T_OFF_FAST_DECAY 0x4000ul
#define T_OFF_PATTERN 0xful #define T_OFF_PATTERN 0xFul
#define RANDOM_TOFF_TIME 0x2000ul #define RANDOM_TOFF_TIME 0x2000ul
#define BLANK_TIMING_PATTERN 0x18000ul #define BLANK_TIMING_PATTERN 0x18000ul
#define BLANK_TIMING_SHIFT 15 #define BLANK_TIMING_SHIFT 15
@ -85,7 +85,7 @@
#define CURRENT_DOWN_STEP_SPEED_PATTERN 0x6000ul #define CURRENT_DOWN_STEP_SPEED_PATTERN 0x6000ul
#define SE_MAX_PATTERN 0xF00ul #define SE_MAX_PATTERN 0xF00ul
#define SE_CURRENT_STEP_WIDTH_PATTERN 0x60ul #define SE_CURRENT_STEP_WIDTH_PATTERN 0x60ul
#define SE_MIN_PATTERN 0xful #define SE_MIN_PATTERN 0xFul
//definitions for stall guard2 current register //definitions for stall guard2 current register
#define STALL_GUARD_FILTER_ENABLED 0x10000ul #define STALL_GUARD_FILTER_ENABLED 0x10000ul

2
Marlin/src/backtrace/unwarm.cpp
View file

@ -80,7 +80,7 @@ void UnwInitState(UnwState * const state, /**< Pointer to structure to fill.
// Detect if function names are available // Detect if function names are available
static int __attribute__ ((noinline)) has_function_names(void) { static int __attribute__ ((noinline)) has_function_names(void) {
uint32_t flag_word = ((uint32_t*)(((uint32_t)(&has_function_names)) & (-4))) [-1]; uint32_t flag_word = ((uint32_t*)(((uint32_t)(&has_function_names)) & (-4))) [-1];
return ((flag_word & 0xff000000) == 0xff000000) ? 1 : 0; return ((flag_word & 0xFF000000) == 0xFF000000) ? 1 : 0;
} }
/** /**

2
Marlin/src/backtrace/unwarm.h
View file

@ -104,7 +104,7 @@ typedef struct {
* Macros * Macros
**************************************************************************/ **************************************************************************/
#define M_IsOriginValid(v) (((v) & 0x7f) ? true : false) #define M_IsOriginValid(v) (((v) & 0x7F) ? true : false)
#define M_Origin2Str(v) ((v) ? "VALID" : "INVALID") #define M_Origin2Str(v) ((v) ? "VALID" : "INVALID")
#if defined(UNW_DEBUG) #if defined(UNW_DEBUG)

114
Marlin/src/backtrace/unwarm_thumb.cpp
View file

@ -28,7 +28,7 @@
static int32_t signExtend11(uint16_t value) { static int32_t signExtend11(uint16_t value) {
if(value & 0x400) { if(value & 0x400) {
value |= 0xfffff800; value |= 0xFFFFF800;
} }
return value; return value;
@ -66,7 +66,7 @@ UnwResult UnwStartThumb(UnwState * const state) {
/* /*
* Detect 32bit thumb instructions * Detect 32bit thumb instructions
*/ */
if ((instr & 0xe000) == 0xe000 && (instr & 0x1800) != 0) { if ((instr & 0xE000) == 0xE000 && (instr & 0x1800) != 0) {
uint16_t instr2; uint16_t instr2;
/* Check next address */ /* Check next address */
@ -83,7 +83,7 @@ UnwResult UnwStartThumb(UnwState * const state) {
* Load/Store multiple: Only interpret * Load/Store multiple: Only interpret
* PUSH and POP * PUSH and POP
*/ */
if ((instr & 0xfe6f) == 0xe82d) { if ((instr & 0xFE6F) == 0xE82D) {
bool L = (instr & 0x10) ? true : false; bool L = (instr & 0x10) ? true : false;
uint16_t rList = instr2; uint16_t rList = instr2;
@ -171,7 +171,7 @@ UnwResult UnwStartThumb(UnwState * const state) {
/* /*
* PUSH register * PUSH register
*/ */
else if (instr == 0xf84d && (instr2 & 0x0fff) == 0x0d04) { else if (instr == 0xF84D && (instr2 & 0x0FFF) == 0x0D04) {
uint8_t r = instr2 >> 12; uint8_t r = instr2 >> 12;
/* Store to memory: PUSH */ /* Store to memory: PUSH */
@ -187,7 +187,7 @@ UnwResult UnwStartThumb(UnwState * const state) {
/* /*
* POP register * POP register
*/ */
else if (instr == 0xf85d && (instr2 & 0x0fff) == 0x0b04) { else if (instr == 0xF85D && (instr2 & 0x0FFF) == 0x0B04) {
uint8_t r = instr2 >> 12; uint8_t r = instr2 >> 12;
/* Load from memory: POP */ /* Load from memory: POP */
@ -246,7 +246,7 @@ UnwResult UnwStartThumb(UnwState * const state) {
/* /*
* TBB / TBH * TBB / TBH
*/ */
else if ((instr & 0xfff0) == 0xe8d0 && (instr2 & 0xffe0) == 0xf000) { else if ((instr & 0xFFF0) == 0xE8D0 && (instr2 & 0xFFE0) == 0xF000) {
/* We are only interested in /* We are only interested in
* the forms * the forms
* TBB [PC, ...] * TBB [PC, ...]
@ -254,8 +254,8 @@ UnwResult UnwStartThumb(UnwState * const state) {
* as those are used by the C compiler to implement * as those are used by the C compiler to implement
* the switch clauses * the switch clauses
*/ */
uint8_t rn = instr & 0xf; uint8_t rn = instr & 0xF;
uint8_t rm = instr2 & 0xf; uint8_t rm = instr2 & 0xF;
bool H = (instr2 & 0x10) ? true : false; bool H = (instr2 & 0x10) ? true : false;
UnwPrintd5("TB%c [r%d,r%d%s]\n", H ? 'H' : 'B', rn, rm, H ? ",LSL #1" : ""); UnwPrintd5("TB%c [r%d,r%d%s]\n", H ? 'H' : 'B', rn, rm, H ? ",LSL #1" : "");
@ -280,19 +280,19 @@ UnwResult UnwStartThumb(UnwState * const state) {
/* /*
* Unconditional branch * Unconditional branch
*/ */
else if ((instr & 0xf800) == 0xf000 && (instr2 & 0xd000) == 0x9000) { else if ((instr & 0xF800) == 0xF000 && (instr2 & 0xD000) == 0x9000) {
uint32_t v; uint32_t v;
uint8_t S = (instr & 0x400) >> 10; uint8_t S = (instr & 0x400) >> 10;
uint16_t imm10 = (instr & 0x3ff); uint16_t imm10 = (instr & 0x3FF);
uint8_t J1 = (instr2 & 0x2000) >> 13; uint8_t J1 = (instr2 & 0x2000) >> 13;
uint8_t J2 = (instr2 & 0x0800) >> 11; uint8_t J2 = (instr2 & 0x0800) >> 11;
uint16_t imm11 = (instr2 & 0x7ff); uint16_t imm11 = (instr2 & 0x7FF);
uint8_t I1 = J1 ^ S ^ 1; uint8_t I1 = J1 ^ S ^ 1;
uint8_t I2 = J2 ^ S ^ 1; uint8_t I2 = J2 ^ S ^ 1;
uint32_t imm32 = (S << 24) | (I1 << 23) | (I2 << 22) |(imm10 << 12) | (imm11 << 1); uint32_t imm32 = (S << 24) | (I1 << 23) | (I2 << 22) |(imm10 << 12) | (imm11 << 1);
if (S) imm32 |= 0xfe000000; if (S) imm32 |= 0xFE000000;
UnwPrintd2("B %d \n", imm32); UnwPrintd2("B %d \n", imm32);
@ -321,18 +321,18 @@ UnwResult UnwStartThumb(UnwState * const state) {
/* /*
* Branch with link * Branch with link
*/ */
else if ((instr & 0xf800) == 0xf000 && (instr2 & 0xd000) == 0xd000) { else if ((instr & 0xF800) == 0xF000 && (instr2 & 0xD000) == 0xD000) {
uint8_t S = (instr & 0x400) >> 10; uint8_t S = (instr & 0x400) >> 10;
uint16_t imm10 = (instr & 0x3ff); uint16_t imm10 = (instr & 0x3FF);
uint8_t J1 = (instr2 & 0x2000) >> 13; uint8_t J1 = (instr2 & 0x2000) >> 13;
uint8_t J2 = (instr2 & 0x0800) >> 11; uint8_t J2 = (instr2 & 0x0800) >> 11;
uint16_t imm11 = (instr2 & 0x7ff); uint16_t imm11 = (instr2 & 0x7FF);
uint8_t I1 = J1 ^ S ^ 1; uint8_t I1 = J1 ^ S ^ 1;
uint8_t I2 = J2 ^ S ^ 1; uint8_t I2 = J2 ^ S ^ 1;
uint32_t imm32 = (S << 24) | (I1 << 23) | (I2 << 22) |(imm10 << 12) | (imm11 << 1); uint32_t imm32 = (S << 24) | (I1 << 23) | (I2 << 22) |(imm10 << 12) | (imm11 << 1);
if (S) imm32 |= 0xfe000000; if (S) imm32 |= 0xFE000000;
UnwPrintd2("BL %d \n", imm32); UnwPrintd2("BL %d \n", imm32);
@ -377,18 +377,18 @@ UnwResult UnwStartThumb(UnwState * const state) {
/* /*
* Conditional branches. Usually not taken, unless infinite loop is detected * Conditional branches. Usually not taken, unless infinite loop is detected
*/ */
else if ((instr & 0xf800) == 0xf000 && (instr2 & 0xd000) == 0x8000) { else if ((instr & 0xF800) == 0xF000 && (instr2 & 0xD000) == 0x8000) {
uint8_t S = (instr & 0x400) >> 10; uint8_t S = (instr & 0x400) >> 10;
uint16_t imm6 = (instr & 0x3f); uint16_t imm6 = (instr & 0x3F);
uint8_t J1 = (instr2 & 0x2000) >> 13; uint8_t J1 = (instr2 & 0x2000) >> 13;
uint8_t J2 = (instr2 & 0x0800) >> 11; uint8_t J2 = (instr2 & 0x0800) >> 11;
uint16_t imm11 = (instr2 & 0x7ff); uint16_t imm11 = (instr2 & 0x7FF);
uint8_t I1 = J1 ^ S ^ 1; uint8_t I1 = J1 ^ S ^ 1;
uint8_t I2 = J2 ^ S ^ 1; uint8_t I2 = J2 ^ S ^ 1;
uint32_t imm32 = (S << 20) | (I1 << 19) | (I2 << 18) |(imm6 << 12) | (imm11 << 1); uint32_t imm32 = (S << 20) | (I1 << 19) | (I2 << 18) |(imm6 << 12) | (imm11 << 1);
if (S) imm32 |= 0xffe00000; if (S) imm32 |= 0xFFE00000;
UnwPrintd2("Bcond %d\n", imm32); UnwPrintd2("Bcond %d\n", imm32);
@ -412,9 +412,9 @@ UnwResult UnwStartThumb(UnwState * const state) {
* PC-relative load * PC-relative load
* LDR Rd,[PC, #+/-imm] * LDR Rd,[PC, #+/-imm]
*/ */
else if((instr & 0xff7f) == 0xf85f) { else if((instr & 0xFF7F) == 0xF85F) {
uint8_t rt = (instr2 & 0xf000) >> 12; uint8_t rt = (instr2 & 0xF000) >> 12;
uint8_t imm12 = (instr2 & 0x0fff); uint8_t imm12 = (instr2 & 0x0FFF);
bool A = (instr & 0x80) ? true : false; bool A = (instr & 0x80) ? true : false;
uint32_t address; uint32_t address;
@ -434,10 +434,10 @@ UnwResult UnwStartThumb(UnwState * const state) {
* We are only interested when destination is PC. * We are only interested when destination is PC.
* LDR Rt,[Rn , #n] * LDR Rt,[Rn , #n]
*/ */
else if ((instr & 0xfff0) == 0xf8d0) { else if ((instr & 0xFFF0) == 0xF8D0) {
uint8_t rn = (instr & 0xf); uint8_t rn = (instr & 0xF);
uint8_t rt = (instr2 & 0xf000) >> 12; uint8_t rt = (instr2 & 0xF000) >> 12;
uint16_t imm12 = (instr2 & 0xfff); uint16_t imm12 = (instr2 & 0xFFF);
/* If destination is PC and we don't know the source value, then fail */ /* If destination is PC and we don't know the source value, then fail */
if (!M_IsOriginValid(state->regData[rn].o)) { if (!M_IsOriginValid(state->regData[rn].o)) {
@ -456,10 +456,10 @@ UnwResult UnwStartThumb(UnwState * const state) {
* LDR Rt,[Rn], #+/-n] * LDR Rt,[Rn], #+/-n]
* LDR Rt,[Rn, #+/-n]! * LDR Rt,[Rn, #+/-n]!
*/ */
else if ((instr & 0xfff0) == 0xf850 && (instr2 & 0x0800) == 0x0800) { else if ((instr & 0xFFF0) == 0xF850 && (instr2 & 0x0800) == 0x0800) {
uint8_t rn = (instr & 0xf); uint8_t rn = (instr & 0xF);
uint8_t rt = (instr2 & 0xf000) >> 12; uint8_t rt = (instr2 & 0xF000) >> 12;
uint16_t imm8 = (instr2 & 0xff); uint16_t imm8 = (instr2 & 0xFF);
bool P = (instr2 & 0x400) ? true : false; bool P = (instr2 & 0x400) ? true : false;
bool U = (instr2 & 0x200) ? true : false; bool U = (instr2 & 0x200) ? true : false;
bool W = (instr2 & 0x100) ? true : false; bool W = (instr2 & 0x100) ? true : false;
@ -493,10 +493,10 @@ UnwResult UnwStartThumb(UnwState * const state) {
* ldr Rt, [Rn, Rm, lsl #x] * ldr Rt, [Rn, Rm, lsl #x]
* Where Rt is PC, Rn value is known, Rm is not known or unknown * Where Rt is PC, Rn value is known, Rm is not known or unknown
*/ */
else if ((instr & 0xfff0) == 0xf850 && (instr2 & 0x0fc0) == 0x0000) { else if ((instr & 0xFFF0) == 0xF850 && (instr2 & 0x0FC0) == 0x0000) {
uint8_t rn = (instr & 0xf); uint8_t rn = (instr & 0xF);
uint8_t rt = (instr2 & 0xf000) >> 12; uint8_t rt = (instr2 & 0xF000) >> 12;
uint8_t rm = (instr2 & 0xf); uint8_t rm = (instr2 & 0xF);
uint8_t imm2 = (instr2 & 0x30) >> 4; uint8_t imm2 = (instr2 & 0x30) >> 4;
if (!M_IsOriginValid(state->regData[rn].o) || if (!M_IsOriginValid(state->regData[rn].o) ||
@ -534,10 +534,10 @@ UnwResult UnwStartThumb(UnwState * const state) {
* LSR Rd, Rs, #Offset5 * LSR Rd, Rs, #Offset5
* ASR Rd, Rs, #Offset5 * ASR Rd, Rs, #Offset5
*/ */
else if((instr & 0xe000) == 0x0000 && (instr & 0x1800) != 0x1800) { else if((instr & 0xE000) == 0x0000 && (instr & 0x1800) != 0x1800) {
bool signExtend; bool signExtend;
uint8_t op = (instr & 0x1800) >> 11; uint8_t op = (instr & 0x1800) >> 11;
uint8_t offset5 = (instr & 0x07c0) >> 6; uint8_t offset5 = (instr & 0x07C0) >> 6;
uint8_t rs = (instr & 0x0038) >> 3; uint8_t rs = (instr & 0x0038) >> 3;
uint8_t rd = (instr & 0x0007); uint8_t rd = (instr & 0x0007);
@ -562,7 +562,7 @@ UnwResult UnwStartThumb(UnwState * const state) {
signExtend = (state->regData[rs].v & 0x8000) ? true : false; signExtend = (state->regData[rs].v & 0x8000) ? true : false;
state->regData[rd].v = state->regData[rs].v >> offset5; state->regData[rd].v = state->regData[rs].v >> offset5;
if(signExtend) { if(signExtend) {
state->regData[rd].v |= 0xffffffff << (32 - offset5); state->regData[rd].v |= 0xFFFFFFFF << (32 - offset5);
} }
state->regData[rd].o = state->regData[rs].o; state->regData[rd].o = state->regData[rs].o;
state->regData[rd].o |= REG_VAL_ARITHMETIC; state->regData[rd].o |= REG_VAL_ARITHMETIC;
@ -575,10 +575,10 @@ UnwResult UnwStartThumb(UnwState * const state) {
* SUB Rd, Rs, Rn * SUB Rd, Rs, Rn
* SUB Rd, Rs, #Offset3 * SUB Rd, Rs, #Offset3
*/ */
else if((instr & 0xf800) == 0x1800) { else if((instr & 0xF800) == 0x1800) {
bool I = (instr & 0x0400) ? true : false; bool I = (instr & 0x0400) ? true : false;
bool op = (instr & 0x0200) ? true : false; bool op = (instr & 0x0200) ? true : false;
uint8_t rn = (instr & 0x01c0) >> 6; uint8_t rn = (instr & 0x01C0) >> 6;
uint8_t rs = (instr & 0x0038) >> 3; uint8_t rs = (instr & 0x0038) >> 3;
uint8_t rd = (instr & 0x0007); uint8_t rd = (instr & 0x0007);
@ -627,11 +627,11 @@ UnwResult UnwStartThumb(UnwState * const state) {
* ADD Rd, #Offset8 * ADD Rd, #Offset8
* SUB Rd, #Offset8 * SUB Rd, #Offset8
*/ */
else if((instr & 0xe000) == 0x2000) { else if((instr & 0xE000) == 0x2000) {
uint8_t op = (instr & 0x1800) >> 11; uint8_t op = (instr & 0x1800) >> 11;
uint8_t rd = (instr & 0x0700) >> 8; uint8_t rd = (instr & 0x0700) >> 8;
uint8_t offset8 = (instr & 0x00ff); uint8_t offset8 = (instr & 0x00FF);
switch(op) { switch(op) {
case 0: /* MOV */ case 0: /* MOV */
@ -676,8 +676,8 @@ UnwResult UnwStartThumb(UnwState * const state) {
* BIC Rd, Rs * BIC Rd, Rs
* MVN Rd, Rs * MVN Rd, Rs
*/ */
else if((instr & 0xfc00) == 0x4000) { else if((instr & 0xFC00) == 0x4000) {
uint8_t op = (instr & 0x03c0) >> 6; uint8_t op = (instr & 0x03C0) >> 6;
uint8_t rs = (instr & 0x0038) >> 3; uint8_t rs = (instr & 0x0038) >> 3;
uint8_t rd = (instr & 0x0007); uint8_t rd = (instr & 0x0007);
@ -741,7 +741,7 @@ UnwResult UnwStartThumb(UnwState * const state) {
case 4: /* ASR */ case 4: /* ASR */
if(state->regData[rd].v & 0x80000000) { if(state->regData[rd].v & 0x80000000) {
state->regData[rd].v >>= state->regData[rs].v; state->regData[rd].v >>= state->regData[rs].v;
state->regData[rd].v |= 0xffffffff << (32 - state->regData[rs].v); state->regData[rd].v |= 0xFFFFFFFF << (32 - state->regData[rs].v);
} }
else { else {
state->regData[rd].v >>= state->regData[rs].v; state->regData[rd].v >>= state->regData[rs].v;
@ -826,7 +826,7 @@ UnwResult UnwStartThumb(UnwState * const state) {
* CMP Hd, Rs * CMP Hd, Rs
* MOV Hd, Hs * MOV Hd, Hs
*/ */
else if((instr & 0xfc00) == 0x4400) { else if((instr & 0xFC00) == 0x4400) {
uint8_t op = (instr & 0x0300) >> 8; uint8_t op = (instr & 0x0300) >> 8;
bool h1 = (instr & 0x0080) ? true: false; bool h1 = (instr & 0x0080) ? true: false;
bool h2 = (instr & 0x0040) ? true: false; bool h2 = (instr & 0x0040) ? true: false;
@ -894,9 +894,9 @@ UnwResult UnwStartThumb(UnwState * const state) {
/* Format 9: PC-relative load /* Format 9: PC-relative load
* LDR Rd,[PC, #imm] * LDR Rd,[PC, #imm]
*/ */
else if((instr & 0xf800) == 0x4800) { else if((instr & 0xF800) == 0x4800) {
uint8_t rd = (instr & 0x0700) >> 8; uint8_t rd = (instr & 0x0700) >> 8;
uint8_t word8 = (instr & 0x00ff); uint8_t word8 = (instr & 0x00FF);
uint32_t address; uint32_t address;
/* Compute load address, adding a word to account for prefetch */ /* Compute load address, adding a word to account for prefetch */
@ -912,8 +912,8 @@ UnwResult UnwStartThumb(UnwState * const state) {
* ADD sp,#+imm * ADD sp,#+imm
* ADD sp,#-imm * ADD sp,#-imm
*/ */
else if((instr & 0xff00) == 0xB000) { else if((instr & 0xFF00) == 0xB000) {
uint8_t value = (instr & 0x7f) * 4; uint8_t value = (instr & 0x7F) * 4;
/* Check the negative bit */ /* Check the negative bit */
if((instr & 0x80) != 0) { if((instr & 0x80) != 0) {
@ -931,10 +931,10 @@ UnwResult UnwStartThumb(UnwState * const state) {
* POP {Rlist} * POP {Rlist}
* POP {Rlist, PC} * POP {Rlist, PC}
*/ */
else if((instr & 0xf600) == 0xb400) { else if((instr & 0xF600) == 0xB400) {
bool L = (instr & 0x0800) ? true : false; bool L = (instr & 0x0800) ? true : false;
bool R = (instr & 0x0100) ? true : false; bool R = (instr & 0x0100) ? true : false;
uint8_t rList = (instr & 0x00ff); uint8_t rList = (instr & 0x00FF);
if(L) { if(L) {
uint8_t r; uint8_t r;
@ -1038,9 +1038,9 @@ UnwResult UnwStartThumb(UnwState * const state) {
* Conditional branches * Conditional branches
* Bcond * Bcond
*/ */
else if((instr & 0xf000) == 0xd000) { else if((instr & 0xF000) == 0xD000) {
int32_t branchValue = (instr & 0xff); int32_t branchValue = (instr & 0xFF);
if (branchValue & 0x80) branchValue |= 0xffffff00; if (branchValue & 0x80) branchValue |= 0xFFFFFF00;
/* Branch distance is twice that specified in the instruction. */ /* Branch distance is twice that specified in the instruction. */
branchValue *= 2; branchValue *= 2;
@ -1067,9 +1067,9 @@ UnwResult UnwStartThumb(UnwState * const state) {
/* Format 18: unconditional branch /* Format 18: unconditional branch
* B label * B label
*/ */
else if((instr & 0xf800) == 0xe000) { else if((instr & 0xF800) == 0xE000) {
uint32_t v; uint32_t v;
int32_t branchValue = signExtend11(instr & 0x07ff); int32_t branchValue = signExtend11(instr & 0x07FF);
/* Branch distance is twice that specified in the instruction. */ /* Branch distance is twice that specified in the instruction. */
branchValue *= 2; branchValue *= 2;

72
Marlin/src/backtrace/unwarmbytab.cpp
View file

@ -29,7 +29,7 @@ void __aeabi_unwind_cpp_pr2(void) {};
static inline __attribute__((always_inline)) uint32_t prel31_to_addr(const uint32_t *prel31) { static inline __attribute__((always_inline)) uint32_t prel31_to_addr(const uint32_t *prel31) {
uint32_t offset = (((uint32_t)(*prel31)) << 1) >> 1; uint32_t offset = (((uint32_t)(*prel31)) << 1) >> 1;
return ((uint32_t)prel31 + offset) & 0x7fffffff; return ((uint32_t)prel31 + offset) & 0x7FFFFFFF;
} }
static const UnwTabEntry *UnwTabSearchIndex(const UnwTabEntry *start, const UnwTabEntry *end, uint32_t ip) { static const UnwTabEntry *UnwTabSearchIndex(const UnwTabEntry *start, const UnwTabEntry *end, uint32_t ip) {
@ -54,8 +54,8 @@ static const char *UnwTabGetFunctionName(const UnwindCallbacks *cb, uint32_t add
if (!cb->readW(address-4,&flag_word)) if (!cb->readW(address-4,&flag_word))
return NULL; return NULL;
if ((flag_word & 0xff000000) == 0xff000000) { if ((flag_word & 0xFF000000) == 0xFF000000) {
return (const char *)(address - 4 - (flag_word & 0x00ffffff)); return (const char *)(address - 4 - (flag_word & 0x00FFFFFF));
} }
return NULL; return NULL;
} }
@ -77,7 +77,7 @@ static int UnwTabGetNextInstruction(const UnwindCallbacks *cb, UnwTabState *ucb)
uint32_t v = 0; uint32_t v = 0;
if (!cb->readW(ucb->current, &v)) if (!cb->readW(ucb->current, &v))
return -1; return -1;
instruction = (v >> (ucb->byte << 3)) & 0xff; instruction = (v >> (ucb->byte << 3)) & 0xFF;
/* Move the next byte */ /* Move the next byte */
--ucb->byte; --ucb->byte;
@ -104,12 +104,12 @@ static UnwResult UnwTabStateInit(const UnwindCallbacks *cb, UnwTabState *ucb, ui
if (!cb->readW(instructions, &v)) if (!cb->readW(instructions, &v))
return UNWIND_DREAD_W_FAIL; return UNWIND_DREAD_W_FAIL;
if ((v & 0xff000000) == 0x80000000) { if ((v & 0xFF000000) == 0x80000000) {
ucb->remaining = 3; ucb->remaining = 3;
ucb->byte = 2; ucb->byte = 2;
/* Is a long unwind description */ /* Is a long unwind description */
} else if ((v & 0xff000000) == 0x81000000) { } else if ((v & 0xFF000000) == 0x81000000) {
ucb->remaining = ((v & 0x00ff0000) >> 14) + 2; ucb->remaining = ((v & 0x00FF0000) >> 14) + 2;
ucb->byte = 1; ucb->byte = 1;
} else } else
return UNWIND_UNSUPPORTED_DWARF_PERSONALITY; return UNWIND_UNSUPPORTED_DWARF_PERSONALITY;
@ -138,15 +138,15 @@ static UnwResult UnwTabExecuteInstructions(const UnwindCallbacks *cb, UnwTabStat
/* Consume all instruction byte */ /* Consume all instruction byte */
while ((instruction = UnwTabGetNextInstruction(cb, ucb)) != -1) { while ((instruction = UnwTabGetNextInstruction(cb, ucb)) != -1) {
if ((instruction & 0xc0) == 0x00) { // ARM_EXIDX_CMD_DATA_POP if ((instruction & 0xC0) == 0x00) { // ARM_EXIDX_CMD_DATA_POP
/* vsp = vsp + (xxxxxx << 2) + 4 */ /* vsp = vsp + (xxxxxx << 2) + 4 */
ucb->vrs[13] += ((instruction & 0x3f) << 2) + 4; ucb->vrs[13] += ((instruction & 0x3F) << 2) + 4;
} else } else
if ((instruction & 0xc0) == 0x40) { // ARM_EXIDX_CMD_DATA_PUSH if ((instruction & 0xC0) == 0x40) { // ARM_EXIDX_CMD_DATA_PUSH
/* vsp = vsp - (xxxxxx << 2) - 4 */ /* vsp = vsp - (xxxxxx << 2) - 4 */
ucb->vrs[13] -= ((instruction & 0x3f) << 2) - 4; ucb->vrs[13] -= ((instruction & 0x3F) << 2) - 4;
} else } else
if ((instruction & 0xf0) == 0x80) { if ((instruction & 0xF0) == 0x80) {
/* pop under mask {r15-r12},{r11-r4} or refuse to unwind */ /* pop under mask {r15-r12},{r11-r4} or refuse to unwind */
instruction = instruction << 8 | UnwTabGetNextInstruction(cb, ucb); instruction = instruction << 8 | UnwTabGetNextInstruction(cb, ucb);
@ -156,7 +156,7 @@ static UnwResult UnwTabExecuteInstructions(const UnwindCallbacks *cb, UnwTabStat
/* Pop registers using mask */ // ARM_EXIDX_CMD_REG_POP /* Pop registers using mask */ // ARM_EXIDX_CMD_REG_POP
vsp = ucb->vrs[13]; vsp = ucb->vrs[13];
mask = instruction & 0xfff; mask = instruction & 0xFFF;
reg = 4; reg = 4;
while (mask) { while (mask) {
@ -176,13 +176,13 @@ static UnwResult UnwTabExecuteInstructions(const UnwindCallbacks *cb, UnwTabStat
ucb->vrs[13] = vsp; ucb->vrs[13] = vsp;
} else } else
if ((instruction & 0xf0) == 0x90 && // ARM_EXIDX_CMD_REG_TO_SP if ((instruction & 0xF0) == 0x90 && // ARM_EXIDX_CMD_REG_TO_SP
instruction != 0x9d && instruction != 0x9D &&
instruction != 0x9f) { instruction != 0x9F) {
/* vsp = r[nnnn] */ /* vsp = r[nnnn] */
ucb->vrs[13] = ucb->vrs[instruction & 0x0f]; ucb->vrs[13] = ucb->vrs[instruction & 0x0F];
} else } else
if ((instruction & 0xf0) == 0xa0) { // ARM_EXIDX_CMD_REG_POP if ((instruction & 0xF0) == 0xA0) { // ARM_EXIDX_CMD_REG_POP
/* pop r4-r[4+nnn] or pop r4-r[4+nnn], r14*/ /* pop r4-r[4+nnn] or pop r4-r[4+nnn], r14*/
vsp = ucb->vrs[13]; vsp = ucb->vrs[13];
@ -206,7 +206,7 @@ static UnwResult UnwTabExecuteInstructions(const UnwindCallbacks *cb, UnwTabStat
ucb->vrs[13] = vsp; ucb->vrs[13] = vsp;
} else } else
if (instruction == 0xb0) { // ARM_EXIDX_CMD_FINISH if (instruction == 0xB0) { // ARM_EXIDX_CMD_FINISH
/* finished */ /* finished */
if (ucb->vrs[15] == 0) if (ucb->vrs[15] == 0)
ucb->vrs[15] = ucb->vrs[14]; ucb->vrs[15] = ucb->vrs[14];
@ -215,7 +215,7 @@ static UnwResult UnwTabExecuteInstructions(const UnwindCallbacks *cb, UnwTabStat
return UNWIND_SUCCESS; return UNWIND_SUCCESS;
} else } else
if (instruction == 0xb1) { // ARM_EXIDX_CMD_REG_POP if (instruction == 0xB1) { // ARM_EXIDX_CMD_REG_POP
/* pop register under mask {r3,r2,r1,r0} */ /* pop register under mask {r3,r2,r1,r0} */
vsp = ucb->vrs[13]; vsp = ucb->vrs[13];
mask = UnwTabGetNextInstruction(cb, ucb); mask = UnwTabGetNextInstruction(cb, ucb);
@ -236,14 +236,14 @@ static UnwResult UnwTabExecuteInstructions(const UnwindCallbacks *cb, UnwTabStat
ucb->vrs[13] = (uint32_t)vsp; ucb->vrs[13] = (uint32_t)vsp;
} else } else
if (instruction == 0xb2) { // ARM_EXIDX_CMD_DATA_POP if (instruction == 0xB2) { // ARM_EXIDX_CMD_DATA_POP
/* vps = vsp + 0x204 + (uleb128 << 2) */ /* vps = vsp + 0x204 + (uleb128 << 2) */
ucb->vrs[13] += 0x204 + (UnwTabGetNextInstruction(cb, ucb) << 2); ucb->vrs[13] += 0x204 + (UnwTabGetNextInstruction(cb, ucb) << 2);
} else } else
if (instruction == 0xb3 || // ARM_EXIDX_CMD_VFP_POP if (instruction == 0xB3 || // ARM_EXIDX_CMD_VFP_POP
instruction == 0xc8 || instruction == 0xC8 ||
instruction == 0xc9) { instruction == 0xC9) {
/* pop VFP double-precision registers */ /* pop VFP double-precision registers */
vsp = ucb->vrs[13]; vsp = ucb->vrs[13];
@ -256,12 +256,12 @@ static UnwResult UnwTabExecuteInstructions(const UnwindCallbacks *cb, UnwTabStat
ucb->vrs[14] = v; ucb->vrs[14] = v;
vsp += 4; vsp += 4;
if (instruction == 0xc8) { if (instruction == 0xC8) {
/* D[16+sssss]-D[16+ssss+cccc] */ /* D[16+sssss]-D[16+ssss+cccc] */
ucb->vrs[14] |= 1 << 16; ucb->vrs[14] |= 1 << 16;
} }
if (instruction != 0xb3) { if (instruction != 0xB3) {
/* D[sssss]-D[ssss+cccc] */ /* D[sssss]-D[ssss+cccc] */
ucb->vrs[14] |= 1 << 17; ucb->vrs[14] |= 1 << 17;
} }
@ -269,13 +269,13 @@ static UnwResult UnwTabExecuteInstructions(const UnwindCallbacks *cb, UnwTabStat
ucb->vrs[13] = vsp; ucb->vrs[13] = vsp;
} else } else
if ((instruction & 0xf8) == 0xb8 || if ((instruction & 0xF8) == 0xB8 ||
(instruction & 0xf8) == 0xd0) { (instruction & 0xF8) == 0xD0) {
/* Pop VFP double precision registers D[8]-D[8+nnn] */ /* Pop VFP double precision registers D[8]-D[8+nnn] */
ucb->vrs[14] = 0x80 | (instruction & 0x07); ucb->vrs[14] = 0x80 | (instruction & 0x07);
if ((instruction & 0xf8) == 0xd0) { if ((instruction & 0xF8) == 0xD0) {
ucb->vrs[14] = 1 << 17; ucb->vrs[14] = 1 << 17;
} }
@ -337,7 +337,7 @@ static UnwResult UnwTabUnwindFrame(const UnwindCallbacks *cb, UnwindFrame *frame
/* Check for exception return */ /* Check for exception return */
/* TODO Test with other ARM processors to verify this method. */ /* TODO Test with other ARM processors to verify this method. */
if ((ucb.vrs[15] & 0xf0000000) == 0xf0000000) { if ((ucb.vrs[15] & 0xF0000000) == 0xF0000000) {
/* According to the Cortex Programming Manual (p.44), the stack address is always 8-byte aligned (Cortex-M7). /* According to the Cortex Programming Manual (p.44), the stack address is always 8-byte aligned (Cortex-M7).
Depending on where the exception came from (MSP or PSP), we need the right SP value to work with. Depending on where the exception came from (MSP or PSP), we need the right SP value to work with.
@ -354,20 +354,20 @@ static UnwResult UnwTabUnwindFrame(const UnwindCallbacks *cb, UnwindFrame *frame
If we need to start from the PSP, we need to go up exactly 6 words to find the PC. If we need to start from the PSP, we need to go up exactly 6 words to find the PC.
See the ARMv7-M Architecture Reference Manual p.594 and Cortex-M7 Processor Programming Manual p.44/p.45 for details. See the ARMv7-M Architecture Reference Manual p.594 and Cortex-M7 Processor Programming Manual p.44/p.45 for details.
*/ */
if ((ucb.vrs[15] & 0xc) == 0) { if ((ucb.vrs[15] & 0xC) == 0) {
/* Return to Handler Mode: MSP (0xffffff-1) */ /* Return to Handler Mode: MSP (0xFFFFFF-1) */
stack = ucb.vrs[13]; stack = ucb.vrs[13];
/* The PC is always 2 words down from the MSP, if it was a non-floating-point exception */ /* The PC is always 2 words down from the MSP, if it was a non-floating-point exception */
stack -= 2*4; stack -= 2*4;
/* If there was a VFP exception (0xffffffe1), the PC is located another 18 words down */ /* If there was a VFP exception (0xFFFFFFE1), the PC is located another 18 words down */
if ((ucb.vrs[15] & 0xf0) == 0xe0) { if ((ucb.vrs[15] & 0xF0) == 0xE0) {
stack -= 18*4; stack -= 18*4;
} }
} }
else { else {
/* Return to Thread Mode: PSP (0xffffff-d) */ /* Return to Thread Mode: PSP (0xFFFFFF-d) */
stack = read_psp(); stack = read_psp();
/* The PC is always 6 words up from the PSP */ /* The PC is always 6 words up from the PSP */
@ -423,7 +423,7 @@ UnwResult UnwindByTableStart(UnwindFrame* frame, const UnwindCallbacks *cb, void
const UnwTabEntry *index = UnwTabSearchIndex(__exidx_start, __exidx_end, frame->pc); const UnwTabEntry *index = UnwTabSearchIndex(__exidx_start, __exidx_end, frame->pc);
/* Clear last bit (Thumb indicator) */ /* Clear last bit (Thumb indicator) */
frame->pc &= 0xfffffffeU; frame->pc &= 0xFFFFFFFEU;
/* Generate the backtrace information */ /* Generate the backtrace information */
entry.address = frame->pc; entry.address = frame->pc;

6
Marlin/src/backtrace/unwarmmem.cpp
View file

@ -91,9 +91,9 @@ bool UnwMemHashWrite(MemData * const memData, uint32_t addr, uint32_t val, bool
M_SetIdxUsed(memData->tracked, i); M_SetIdxUsed(memData->tracked, i);
} }
else { else {
#if defined(UNW_DEBUG) #if defined(UNW_DEBUG)
memData->v[i] = 0xdeadbeef; memData->v[i] = 0xDEADBEEF;
#endif #endif
M_ClrIdxUsed(memData->tracked, i); M_ClrIdxUsed(memData->tracked, i);
} }

24
Marlin/src/lcd/dogm/u8g_dev_ssd1306_sh1106_128x64_I2C.cpp
View file

@ -123,13 +123,13 @@ uint8_t u8g_dev_sh1106_128x64_2x_2_wire_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t m
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
u8g_SetAddress(u8g, dev, 0); // instruction mode u8g_SetAddress(u8g, dev, 0); // instruction mode
u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_sh1106_128x64_data_start_2_wire); u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_sh1106_128x64_data_start_2_wire);
u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2)); // select current page u8g_WriteByte(u8g, dev, 0x0B0 | (pb->p.page*2)); // select current page
u8g_SetAddress(u8g, dev, 1); // data mode u8g_SetAddress(u8g, dev, 1); // data mode
u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *) pb->buf); u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *) pb->buf);
u8g_SetChipSelect(u8g, dev, 0); u8g_SetChipSelect(u8g, dev, 0);
u8g_SetAddress(u8g, dev, 0); // instruction mode u8g_SetAddress(u8g, dev, 0); // instruction mode
u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_sh1106_128x64_data_start_2_wire); u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_sh1106_128x64_data_start_2_wire);
u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2+1)); // select current page u8g_WriteByte(u8g, dev, 0x0B0 | (pb->p.page*2+1)); // select current page
u8g_SetAddress(u8g, dev, 1); // data mode u8g_SetAddress(u8g, dev, 1); // data mode
u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
u8g_SetChipSelect(u8g, dev, 0); u8g_SetChipSelect(u8g, dev, 0);
@ -191,13 +191,13 @@ uint8_t u8g_dev_ssd1306_128x64_2x_2_wire_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
u8g_SetAddress(u8g, dev, 0); // instruction mode u8g_SetAddress(u8g, dev, 0); // instruction mode
u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_ssd1306_128x64_data_start_2_wire); u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_ssd1306_128x64_data_start_2_wire);
u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2)); // select current page u8g_WriteByte(u8g, dev, 0x0B0 | (pb->p.page*2)); // select current page
u8g_SetAddress(u8g, dev, 1); // data mode u8g_SetAddress(u8g, dev, 1); // data mode
u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *) pb->buf); u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *) pb->buf);
u8g_SetChipSelect(u8g, dev, 0); u8g_SetChipSelect(u8g, dev, 0);
u8g_SetAddress(u8g, dev, 0); // instruction mode u8g_SetAddress(u8g, dev, 0); // instruction mode
u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_ssd1306_128x64_data_start_2_wire); u8g_WriteEscSeqP_2_wire(u8g, dev, u8g_dev_ssd1306_128x64_data_start_2_wire);
u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page*2+1)); // select current page u8g_WriteByte(u8g, dev, 0x0B0 | (pb->p.page*2+1)); // select current page
u8g_SetAddress(u8g, dev, 1); // data mode u8g_SetAddress(u8g, dev, 1); // data mode
u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
u8g_SetChipSelect(u8g, dev, 0); u8g_SetChipSelect(u8g, dev, 0);
@ -250,25 +250,25 @@ uint8_t u8g_WriteEscSeqP_2_wire(u8g_t *u8g, u8g_dev_t *dev, const uint8_t *esc_s
else if (value == 254) { else if (value == 254) {
break; break;
} }
else if (value >= 0x0f0) { else if (value >= 0x0F0) {
/* not yet used, do nothing */ /* not yet used, do nothing */
} }
else if (value >= 0xe0 ) { else if (value >= 0xE0 ) {
u8g_SetAddress(u8g, dev, value & 0x0f); u8g_SetAddress(u8g, dev, value & 0x0F);
} }
else if (value >= 0xd0) { else if (value >= 0xD0) {
u8g_SetChipSelect(u8g, dev, value & 0x0f); u8g_SetChipSelect(u8g, dev, value & 0x0F);
} }
else if (value >= 0xc0) { else if (value >= 0xC0) {
u8g_SetResetLow(u8g, dev); u8g_SetResetLow(u8g, dev);
value &= 0x0f; value &= 0x0F;
value <<= 4; value <<= 4;
value+=2; value+=2;
u8g_Delay(value); u8g_Delay(value);
u8g_SetResetHigh(u8g, dev); u8g_SetResetHigh(u8g, dev);
u8g_Delay(value); u8g_Delay(value);
} }
else if (value >= 0xbe) { /* not yet implemented */ else if (value >= 0xBE) { /* not yet implemented */
/* u8g_SetVCC(u8g, dev, value & 0x01); */ /* u8g_SetVCC(u8g, dev, value & 0x01); */
} }
else if (value <= 127) { else if (value <= 127) {

30
Marlin/src/lcd/dogm/u8g_dev_st7565_64128n_HAL.cpp
View file

@ -72,10 +72,10 @@ static const uint8_t u8g_dev_st7565_64128n_HAL_init_seq[] PROGMEM = {
U8G_ESC_CS(1), // enable chip U8G_ESC_CS(1), // enable chip
U8G_ESC_RST(15), // do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/ U8G_ESC_RST(15), // do reset low pulse with (15*16)+2 milliseconds (=maximum delay)*/
0x0A2, // 0x0a2: LCD bias 1/9 (according to Displaytech 64128N datasheet) 0x0A2, // 0x0A2: LCD bias 1/9 (according to Displaytech 64128N datasheet)
0x0A0, // Normal ADC Select (according to Displaytech 64128N datasheet) 0x0A0, // Normal ADC Select (according to Displaytech 64128N datasheet)
0x0c8, // common output mode: set scan direction normal operation/SHL Select, 0x0c0 --> SHL = 0, normal, 0x0c8 --> SHL = 1 0x0C8, // common output mode: set scan direction normal operation/SHL Select, 0x0C0 --> SHL = 0, normal, 0x0C8 --> SHL = 1
0x040, // Display start line for Displaytech 64128N 0x040, // Display start line for Displaytech 64128N
0x028 | 0x04, // power control: turn on voltage converter 0x028 | 0x04, // power control: turn on voltage converter
@ -89,19 +89,19 @@ static const uint8_t u8g_dev_st7565_64128n_HAL_init_seq[] PROGMEM = {
0x010, // Set V0 voltage resistor ratio. Setting for controlling brightness of Displaytech 64128N 0x010, // Set V0 voltage resistor ratio. Setting for controlling brightness of Displaytech 64128N
0x0a6, // display normal, bit val 0: LCD pixel off. 0x0A6, // display normal, bit val 0: LCD pixel off.
0x081, // set contrast 0x081, // set contrast
0x01e, // Contrast value. Setting for controlling brightness of Displaytech 64128N 0x01E, // Contrast value. Setting for controlling brightness of Displaytech 64128N
0x0af, // display on 0x0AF, // display on
U8G_ESC_DLY(100), // delay 100 ms U8G_ESC_DLY(100), // delay 100 ms
0x0a5, // display all points, ST7565 0x0A5, // display all points, ST7565
U8G_ESC_DLY(100), // delay 100 ms U8G_ESC_DLY(100), // delay 100 ms
U8G_ESC_DLY(100), // delay 100 ms U8G_ESC_DLY(100), // delay 100 ms
0x0a4, // normal display 0x0A4, // normal display
U8G_ESC_CS(0), // disable chip U8G_ESC_CS(0), // disable chip
U8G_ESC_END // end of sequence U8G_ESC_END // end of sequence
}; };
@ -117,10 +117,10 @@ static const uint8_t u8g_dev_st7565_64128n_HAL_data_start[] PROGMEM = {
static const uint8_t u8g_dev_st7565_64128n_HAL_sleep_on[] PROGMEM = { static const uint8_t u8g_dev_st7565_64128n_HAL_sleep_on[] PROGMEM = {
U8G_ESC_ADR(0), // instruction mode U8G_ESC_ADR(0), // instruction mode
U8G_ESC_CS(1), // enable chip U8G_ESC_CS(1), // enable chip
0x0ac, // static indicator off 0x0AC, // static indicator off
0x000, // indicator register set (not sure if this is required) 0x000, // indicator register set (not sure if this is required)
0x0ae, // display off 0x0AE, // display off
0x0a5, // all points on 0x0A5, // all points on
U8G_ESC_CS(0), // disable chip, bugfix 12 nov 2014 U8G_ESC_CS(0), // disable chip, bugfix 12 nov 2014
U8G_ESC_END // end of sequence U8G_ESC_END // end of sequence
}; };
@ -128,8 +128,8 @@ static const uint8_t u8g_dev_st7565_64128n_HAL_sleep_on[] PROGMEM = {
static const uint8_t u8g_dev_st7565_64128n_HAL_sleep_off[] PROGMEM = { static const uint8_t u8g_dev_st7565_64128n_HAL_sleep_off[] PROGMEM = {
U8G_ESC_ADR(0), // instruction mode U8G_ESC_ADR(0), // instruction mode
U8G_ESC_CS(1), // enable chip U8G_ESC_CS(1), // enable chip
0x0a4, // all points off 0x0A4, // all points off
0x0af, // display on 0x0AF, // display on
U8G_ESC_DLY(50), // delay 50 ms U8G_ESC_DLY(50), // delay 50 ms
U8G_ESC_CS(0), // disable chip, bugfix 12 nov 2014 U8G_ESC_CS(0), // disable chip, bugfix 12 nov 2014
U8G_ESC_END // end of sequence U8G_ESC_END // end of sequence
@ -146,7 +146,7 @@ uint8_t u8g_dev_st7565_64128n_HAL_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, vo
case U8G_DEV_MSG_PAGE_NEXT: { case U8G_DEV_MSG_PAGE_NEXT: {
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start); u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start);
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (ST7565R) */ u8g_WriteByte(u8g, dev, 0x0B0 | pb->p.page); /* select current page (ST7565R) */
u8g_SetAddress(u8g, dev, 1); /* data mode */ u8g_SetAddress(u8g, dev, 1); /* data mode */
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
return 0; return 0;
@ -182,13 +182,13 @@ uint8_t u8g_dev_st7565_64128n_HAL_2x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg,
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start); u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start);
u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page)); /* select current page (ST7565R) */ u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page)); /* select current page (ST7565R) */
u8g_SetAddress(u8g, dev, 1); /* data mode */ u8g_SetAddress(u8g, dev, 1); /* data mode */
u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)pb->buf); u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)pb->buf);
u8g_SetChipSelect(u8g, dev, 0); u8g_SetChipSelect(u8g, dev, 0);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start); u8g_WriteEscSeqP(u8g, dev, u8g_dev_st7565_64128n_HAL_data_start);
u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page (ST7565R) */ u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page+1)); /* select current page (ST7565R) */
u8g_SetAddress(u8g, dev, 1); /* data mode */ u8g_SetAddress(u8g, dev, 1); /* data mode */
u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
u8g_SetChipSelect(u8g, dev, 0); u8g_SetChipSelect(u8g, dev, 0);

6
Marlin/src/lcd/dogm/u8g_dev_st7920_128x64_HAL.cpp
View file

@ -75,7 +75,7 @@ static const uint8_t u8g_dev_st7920_128x64_HAL_init_seq[] PROGMEM = {
U8G_ESC_DLY(50), // delay 50 ms U8G_ESC_DLY(50), // delay 50 ms
0x038, // 8 Bit interface (DL=1), basic instruction set (RE=0) 0x038, // 8 Bit interface (DL=1), basic instruction set (RE=0)
0x00c, // display on, cursor & blink off; 0x08: all off 0x00C, // display on, cursor & blink off; 0x08: all off
0x006, // Entry mode: Cursor move to right ,DDRAM address counter (AC) plus 1, no shift 0x006, // Entry mode: Cursor move to right ,DDRAM address counter (AC) plus 1, no shift
0x002, // disable scroll, enable CGRAM adress 0x002, // disable scroll, enable CGRAM adress
0x001, // clear RAM, needs 1.6 ms 0x001, // clear RAM, needs 1.6 ms
@ -125,7 +125,7 @@ uint8_t u8g_dev_st7920_128x64_HAL_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, vo
ptr = (uint8_t *)pb->buf; ptr = (uint8_t *)pb->buf;
for (i = 0; i < 8; i ++) { for (i = 0; i < 8; i ++) {
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ u8g_SetAddress(u8g, dev, 0); /* cmd mode */
u8g_WriteByte(u8g, dev, 0x03e ); /* enable extended mode */ u8g_WriteByte(u8g, dev, 0x03E ); /* enable extended mode */
if (y < 32) { if (y < 32) {
u8g_WriteByte(u8g, dev, 0x080 | y ); /* y pos */ u8g_WriteByte(u8g, dev, 0x080 | y ); /* y pos */
@ -170,7 +170,7 @@ uint8_t u8g_dev_st7920_128x64_HAL_4x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg,
ptr = (uint8_t *)pb->buf; ptr = (uint8_t *)pb->buf;
for (i = 0; i < 32; i ++) { for (i = 0; i < 32; i ++) {
u8g_SetAddress(u8g, dev, 0); /* cmd mode */ u8g_SetAddress(u8g, dev, 0); /* cmd mode */
u8g_WriteByte(u8g, dev, 0x03e ); /* enable extended mode */ u8g_WriteByte(u8g, dev, 0x03E ); /* enable extended mode */
if (y < 32) { if (y < 32) {
u8g_WriteByte(u8g, dev, 0x080 | y ); /* y pos */ u8g_WriteByte(u8g, dev, 0x080 | y ); /* y pos */

28
Marlin/src/lcd/dogm/u8g_dev_uc1701_mini12864_HAL.cpp
View file

@ -75,27 +75,27 @@ static const uint8_t u8g_dev_uc1701_mini12864_HAL_init_seq[] PROGMEM = {
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */ U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */
U8G_ESC_CS(1), /* enable chip */ U8G_ESC_CS(1), /* enable chip */
0x0e2, /* soft reset */ 0x0E2, /* soft reset */
0x040, /* set display start line to 0 */ 0x040, /* set display start line to 0 */
0x0a0, /* ADC set to reverse */ 0x0A0, /* ADC set to reverse */
0x0c8, /* common output mode */ 0x0C8, /* common output mode */
0x0a6, /* display normal, bit val 0: LCD pixel off. */ 0x0A6, /* display normal, bit val 0: LCD pixel off. */
0x0a2, /* LCD bias 1/9 */ 0x0A2, /* LCD bias 1/9 */
0x02f, /* all power control circuits on */ 0x02F, /* all power control circuits on */
0x0f8, /* set booster ratio to */ 0x0F8, /* set booster ratio to */
0x000, /* 4x */ 0x000, /* 4x */
0x023, /* set V0 voltage resistor ratio to large */ 0x023, /* set V0 voltage resistor ratio to large */
0x081, /* set contrast */ 0x081, /* set contrast */
0x027, /* contrast value */ 0x027, /* contrast value */
0x0ac, /* indicator */ 0x0AC, /* indicator */
0x000, /* disable */ 0x000, /* disable */
0x0af, /* display on */ 0x0AF, /* display on */
U8G_ESC_DLY(100), /* delay 100 ms */ U8G_ESC_DLY(100), /* delay 100 ms */
0x0a5, /* display all points, ST7565 */ 0x0A5, /* display all points, ST7565 */
U8G_ESC_DLY(100), /* delay 100 ms */ U8G_ESC_DLY(100), /* delay 100 ms */
U8G_ESC_DLY(100), /* delay 100 ms */ U8G_ESC_DLY(100), /* delay 100 ms */
0x0a4, /* normal display */ 0x0A4, /* normal display */
U8G_ESC_CS(0), /* disable chip */ U8G_ESC_CS(0), /* disable chip */
U8G_ESC_END /* end of sequence */ U8G_ESC_END /* end of sequence */
}; };
@ -122,7 +122,7 @@ uint8_t u8g_dev_uc1701_mini12864_HAL_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg,
{ {
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start); u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page */ u8g_WriteByte(u8g, dev, 0x0B0 | pb->p.page); /* select current page */
u8g_SetAddress(u8g, dev, 1); /* data mode */ u8g_SetAddress(u8g, dev, 1); /* data mode */
if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 ) if ( u8g_pb_WriteBuffer(pb, u8g, dev) == 0 )
return 0; return 0;
@ -155,13 +155,13 @@ uint8_t u8g_dev_uc1701_mini12864_HAL_2x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t m
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem); u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start); u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page)); /* select current page */ u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page)); /* select current page */
u8g_SetAddress(u8g, dev, 1); /* data mode */ u8g_SetAddress(u8g, dev, 1); /* data mode */
u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)pb->buf); u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)pb->buf);
u8g_SetChipSelect(u8g, dev, 0); u8g_SetChipSelect(u8g, dev, 0);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start); u8g_WriteEscSeqP(u8g, dev, u8g_dev_uc1701_mini12864_HAL_data_start);
u8g_WriteByte(u8g, dev, 0x0b0 | (2*pb->p.page+1)); /* select current page */ u8g_WriteByte(u8g, dev, 0x0B0 | (2*pb->p.page+1)); /* select current page */
u8g_SetAddress(u8g, dev, 1); /* data mode */ u8g_SetAddress(u8g, dev, 1); /* data mode */
u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width); u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf)+pb->width);
u8g_SetChipSelect(u8g, dev, 0); u8g_SetChipSelect(u8g, dev, 0);

8
Marlin/src/module/planner.cpp
View file

@ -322,19 +322,19 @@ void Planner::init() {
// // Get most significant bit set on divider // // Get most significant bit set on divider
// uint8_t idx = 0; // uint8_t idx = 0;
// uint32_t nr = d; // uint32_t nr = d;
// if (!(nr & 0xff0000)) { // if (!(nr & 0xFF0000)) {
// nr <<= 8; // nr <<= 8;
// idx += 8; // idx += 8;
// if (!(nr & 0xff0000)) { // if (!(nr & 0xFF0000)) {
// nr <<= 8; // nr <<= 8;
// idx += 8; // idx += 8;
// } // }
// } // }
// if (!(nr & 0xf00000)) { // if (!(nr & 0xF00000)) {
// nr <<= 4; // nr <<= 4;
// idx += 4; // idx += 4;
// } // }
// if (!(nr & 0xc00000)) { // if (!(nr & 0xC00000)) {
// nr <<= 2; // nr <<= 2;
// idx += 2; // idx += 2;
// } // }

4
Marlin/src/module/stepper.h
View file

@ -365,14 +365,14 @@ class Stepper {
step_rate -= F_CPU / 500000; // Correct for minimal speed step_rate -= F_CPU / 500000; // Correct for minimal speed
if (step_rate >= (8 * 256)) { // higher step rate if (step_rate >= (8 * 256)) { // higher step rate
unsigned short table_address = (unsigned short)&speed_lookuptable_fast[(unsigned char)(step_rate >> 8)][0]; unsigned short table_address = (unsigned short)&speed_lookuptable_fast[(unsigned char)(step_rate >> 8)][0];
unsigned char tmp_step_rate = (step_rate & 0x00ff); unsigned char tmp_step_rate = (step_rate & 0x00FF);
unsigned short gain = (unsigned short)pgm_read_word_near(table_address + 2); unsigned short gain = (unsigned short)pgm_read_word_near(table_address + 2);
MultiU16X8toH16(timer, tmp_step_rate, gain); MultiU16X8toH16(timer, tmp_step_rate, gain);
timer = (unsigned short)pgm_read_word_near(table_address) - timer; timer = (unsigned short)pgm_read_word_near(table_address) - timer;
} }
else { // lower step rates else { // lower step rates
unsigned short table_address = (unsigned short)&speed_lookuptable_slow[0][0]; unsigned short table_address = (unsigned short)&speed_lookuptable_slow[0][0];
table_address += ((step_rate) >> 1) & 0xfffc; table_address += ((step_rate) >> 1) & 0xFFFC;
timer = (unsigned short)pgm_read_word_near(table_address); timer = (unsigned short)pgm_read_word_near(table_address);
timer -= (((unsigned short)pgm_read_word_near(table_address + 2) * (unsigned char)(step_rate & 0x0007)) >> 3); timer -= (((unsigned short)pgm_read_word_near(table_address + 2) * (unsigned char)(step_rate & 0x0007)) >> 3);
} }

40
Marlin/src/sd/Sd2Card.cpp
View file

@ -45,22 +45,22 @@
#ifdef FAST_CRC #ifdef FAST_CRC
static const uint8_t crctab7[] PROGMEM = { static const uint8_t crctab7[] PROGMEM = {
0x00,0x09,0x12,0x1b,0x24,0x2d,0x36,0x3f,0x48,0x41,0x5a,0x53,0x6c,0x65,0x7e,0x77, 0x00,0x09,0x12,0x1B,0x24,0x2D,0x36,0x3F,0x48,0x41,0x5A,0x53,0x6C,0x65,0x7E,0x77,
0x19,0x10,0x0b,0x02,0x3d,0x34,0x2f,0x26,0x51,0x58,0x43,0x4a,0x75,0x7c,0x67,0x6e, 0x19,0x10,0x0B,0x02,0x3D,0x34,0x2F,0x26,0x51,0x58,0x43,0x4A,0x75,0x7C,0x67,0x6E,
0x32,0x3b,0x20,0x29,0x16,0x1f,0x04,0x0d,0x7a,0x73,0x68,0x61,0x5e,0x57,0x4c,0x45, 0x32,0x3B,0x20,0x29,0x16,0x1F,0x04,0x0D,0x7A,0x73,0x68,0x61,0x5E,0x57,0x4C,0x45,
0x2b,0x22,0x39,0x30,0x0f,0x06,0x1d,0x14,0x63,0x6a,0x71,0x78,0x47,0x4e,0x55,0x5c, 0x2B,0x22,0x39,0x30,0x0F,0x06,0x1D,0x14,0x63,0x6A,0x71,0x78,0x47,0x4E,0x55,0x5C,
0x64,0x6d,0x76,0x7f,0x40,0x49,0x52,0x5b,0x2c,0x25,0x3e,0x37,0x08,0x01,0x1a,0x13, 0x64,0x6D,0x76,0x7F,0x40,0x49,0x52,0x5B,0x2C,0x25,0x3E,0x37,0x08,0x01,0x1A,0x13,
0x7d,0x74,0x6f,0x66,0x59,0x50,0x4b,0x42,0x35,0x3c,0x27,0x2e,0x11,0x18,0x03,0x0a, 0x7D,0x74,0x6F,0x66,0x59,0x50,0x4B,0x42,0x35,0x3C,0x27,0x2E,0x11,0x18,0x03,0x0A,
0x56,0x5f,0x44,0x4d,0x72,0x7b,0x60,0x69,0x1e,0x17,0x0c,0x05,0x3a,0x33,0x28,0x21, 0x56,0x5F,0x44,0x4D,0x72,0x7B,0x60,0x69,0x1E,0x17,0x0C,0x05,0x3A,0x33,0x28,0x21,
0x4f,0x46,0x5d,0x54,0x6b,0x62,0x79,0x70,0x07,0x0e,0x15,0x1c,0x23,0x2a,0x31,0x38, 0x4F,0x46,0x5D,0x54,0x6B,0x62,0x79,0x70,0x07,0x0E,0x15,0x1C,0x23,0x2A,0x31,0x38,
0x41,0x48,0x53,0x5a,0x65,0x6c,0x77,0x7e,0x09,0x00,0x1b,0x12,0x2d,0x24,0x3f,0x36, 0x41,0x48,0x53,0x5A,0x65,0x6C,0x77,0x7E,0x09,0x00,0x1B,0x12,0x2D,0x24,0x3F,0x36,
0x58,0x51,0x4a,0x43,0x7c,0x75,0x6e,0x67,0x10,0x19,0x02,0x0b,0x34,0x3d,0x26,0x2f, 0x58,0x51,0x4A,0x43,0x7C,0x75,0x6E,0x67,0x10,0x19,0x02,0x0B,0x34,0x3D,0x26,0x2F,
0x73,0x7a,0x61,0x68,0x57,0x5e,0x45,0x4c,0x3b,0x32,0x29,0x20,0x1f,0x16,0x0d,0x04, 0x73,0x7A,0x61,0x68,0x57,0x5E,0x45,0x4C,0x3B,0x32,0x29,0x20,0x1F,0x16,0x0D,0x04,
0x6a,0x63,0x78,0x71,0x4e,0x47,0x5c,0x55,0x22,0x2b,0x30,0x39,0x06,0x0f,0x14,0x1d, 0x6A,0x63,0x78,0x71,0x4E,0x47,0x5C,0x55,0x22,0x2B,0x30,0x39,0x06,0x0F,0x14,0x1D,
0x25,0x2c,0x37,0x3e,0x01,0x08,0x13,0x1a,0x6d,0x64,0x7f,0x76,0x49,0x40,0x5b,0x52, 0x25,0x2C,0x37,0x3E,0x01,0x08,0x13,0x1A,0x6D,0x64,0x7F,0x76,0x49,0x40,0x5B,0x52,
0x3c,0x35,0x2e,0x27,0x18,0x11,0x0a,0x03,0x74,0x7d,0x66,0x6f,0x50,0x59,0x42,0x4b, 0x3C,0x35,0x2E,0x27,0x18,0x11,0x0A,0x03,0x74,0x7D,0x66,0x6F,0x50,0x59,0x42,0x4B,
0x17,0x1e,0x05,0x0c,0x33,0x3a,0x21,0x28,0x5f,0x56,0x4d,0x44,0x7b,0x72,0x69,0x60, 0x17,0x1E,0x05,0x0C,0x33,0x3A,0x21,0x28,0x5F,0x56,0x4D,0x44,0x7B,0x72,0x69,0x60,
0x0e,0x07,0x1c,0x15,0x2a,0x23,0x38,0x31,0x46,0x4f,0x54,0x5d,0x62,0x6b,0x70,0x79 0x0E,0x07,0x1C,0x15,0x2A,0x23,0x38,0x31,0x46,0x4F,0x54,0x5D,0x62,0x6B,0x70,0x79
}; };
static uint8_t CRC7(const uint8_t* data, uint8_t n) { static uint8_t CRC7(const uint8_t* data, uint8_t n) {
@ -79,9 +79,9 @@
d ^= crc << 1; d ^= crc << 1;
if (d & 0x80) d ^= 9; if (d & 0x80) d ^= 9;
crc = d ^ (crc & 0x78) ^ (crc << 4) ^ ((crc >> 3) & 15); crc = d ^ (crc & 0x78) ^ (crc << 4) ^ ((crc >> 3) & 15);
crc &= 0x7f; crc &= 0x7F;
} }
crc = (crc << 1) ^ (crc << 4) ^ (crc & 0x70) ^ ((crc >> 3) & 0x0f); crc = (crc << 1) ^ (crc << 4) ^ (crc & 0x70) ^ ((crc >> 3) & 0x0F);
return crc | 1; return crc | 1;
} }
#endif #endif
@ -438,9 +438,9 @@ bool Sd2Card::readData(uint8_t* dst) {
for (size_t i = 0; i < n; i++) { for (size_t i = 0; i < n; i++) {
crc = (uint8_t)(crc >> 8) | (crc << 8); crc = (uint8_t)(crc >> 8) | (crc << 8);
crc ^= data[i]; crc ^= data[i];
crc ^= (uint8_t)(crc & 0xff) >> 4; crc ^= (uint8_t)(crc & 0xFF) >> 4;
crc ^= crc << 12; crc ^= crc << 12;
crc ^= (crc & 0xff) << 5; crc ^= (crc & 0xFF) << 5;
} }
return crc; return crc;
} }