djsundog/circuitpython
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert changes in lib/

Browse Source
This commit is contained in:
hathach 2023-03-23 14:01:20 +07:00
parent a8abe8e705
commit bce1e7e280
No known key found for this signature in database
GPG Key ID: F5D50C6D51D17CBA
16 changed files with 58 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/cmsis/inc/core_armv81mml.h
View File

@ -2162,7 +2162,7 @@ __STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */
reg_value = (reg_value |
((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
(PriorityGroupTmp << 8U) ); /* Insert write key and priority group */
(PriorityGroupTmp << 8U) ); /* Insert write key and priorty group */
SCB->AIRCR = reg_value;
}
@ -2536,7 +2536,7 @@ __STATIC_INLINE void TZ_NVIC_SetPriorityGrouping_NS(uint32_t PriorityGroup)
reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */
reg_value = (reg_value |
((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
(PriorityGroupTmp << 8U) ); /* Insert write key and priority group */
(PriorityGroupTmp << 8U) ); /* Insert write key and priorty group */
SCB_NS->AIRCR = reg_value;
}

2
lib/cmsis/inc/core_sc300.h
View File

@ -1467,7 +1467,7 @@ __STATIC_INLINE void __NVIC_SetPriorityGrouping(uint32_t PriorityGroup)
reg_value &= ~((uint32_t)(SCB_AIRCR_VECTKEY_Msk | SCB_AIRCR_PRIGROUP_Msk)); /* clear bits to change */
reg_value = (reg_value |
((uint32_t)0x5FAUL << SCB_AIRCR_VECTKEY_Pos) |
(PriorityGroupTmp << 8U) ); /* Insert write key and priority group */
(PriorityGroupTmp << 8U) ); /* Insert write key and priorty group */
SCB->AIRCR = reg_value;
}

2
lib/cmsis/inc/mpu_armv8.h
View File

@ -84,7 +84,7 @@
* \param SH Defines the Shareability domain for this memory region.
* \param RO Read-Only: Set to 1 for a read-only memory region.
* \param NP Non-Privileged: Set to 1 for a non-privileged memory region.
* \param XN eXecute Never: Set to 1 for a non-executable memory region.
* \oaram XN eXecute Never: Set to 1 for a non-executable memory region.
*/
#define ARM_MPU_RBAR(BASE, SH, RO, NP, XN) \
((BASE & MPU_RBAR_BASE_Msk) | \

6
lib/libm_dbl/__rem_pio2_large.c
View File

@ -40,14 +40,14 @@
* z = (z-x[i])*2**24
*
*
* y[] output result in an array of double precision numbers.
* y[] ouput result in an array of double precision numbers.
* The dimension of y[] is:
* 24-bit precision 1
* 53-bit precision 2
* 64-bit precision 2
* 113-bit precision 3
* The actual value is the sum of them. Thus for 113-bit
* precision, one may have to do something like:
* precison, one may have to do something like:
*
* long double t,w,r_head, r_tail;
* t = (long double)y[2] + (long double)y[1];
@ -78,7 +78,7 @@
* jk+1 must be 2 larger than you might expect so that our
* recomputation test works. (Up to 24 bits in the integer
* part (the 24 bits of it that we compute) and 23 bits in
* the fraction part may be lost to cancellation before we
* the fraction part may be lost to cancelation before we
* recompute.)
*
* jz local integer variable indicating the number of

2
lib/libm_dbl/fmod.c
View File

@ -9,7 +9,7 @@ double fmod(double x, double y)
int sx = ux.i>>63;
uint64_t i;
/* in the following uxi should be ux.i, but then gcc wrongly adds */
/* in the followings uxi should be ux.i, but then gcc wrongly adds */
/* float load/store to inner loops ruining performance and code size */
uint64_t uxi = ux.i;

2
lib/libm_dbl/sqrt.c
View File

@ -37,7 +37,7 @@
* If (2) is false, then q = q ; otherwise q = q + 2 .
* i+1 i i+1 i
*
* With some algebraic manipulation, it is not difficult to see
* With some algebric manipulation, it is not difficult to see
* that (2) is equivalent to
* -(i+1)
* s + 2 <= y (3)

12
lib/littlefs/lfs1.h
View File

@ -94,7 +94,7 @@ enum lfs1_open_flags {
LFS1_F_DIRTY = 0x10000, // File does not match storage
LFS1_F_WRITING = 0x20000, // File has been written since last flush
LFS1_F_READING = 0x40000, // File has been read since last flush
LFS1_F_ERRED = 0x80000, // An error occurred during write
LFS1_F_ERRED = 0x80000, // An error occured during write
};
// File seek flags
@ -111,25 +111,25 @@ struct lfs1_config {
// information to the block device operations
void *context;
// Read a region in a block. Negative error codes are propagated
// Read a region in a block. Negative error codes are propogated
// to the user.
int (*read)(const struct lfs1_config *c, lfs1_block_t block,
lfs1_off_t off, void *buffer, lfs1_size_t size);
// Program a region in a block. The block must have previously
// been erased. Negative error codes are propagated to the user.
// been erased. Negative error codes are propogated to the user.
// May return LFS1_ERR_CORRUPT if the block should be considered bad.
int (*prog)(const struct lfs1_config *c, lfs1_block_t block,
lfs1_off_t off, const void *buffer, lfs1_size_t size);
// Erase a block. A block must be erased before being programmed.
// The state of an erased block is undefined. Negative error codes
// are propagated to the user.
// are propogated to the user.
// May return LFS1_ERR_CORRUPT if the block should be considered bad.
int (*erase)(const struct lfs1_config *c, lfs1_block_t block);
// Sync the state of the underlying block device. Negative error codes
// are propagated to the user.
// are propogated to the user.
int (*sync)(const struct lfs1_config *c);
// Minimum size of a block read. This determines the size of read buffers.
@ -484,7 +484,7 @@ int lfs1_dir_rewind(lfs1_t *lfs1, lfs1_dir_t *dir);
// Returns a negative error code on failure.
int lfs1_traverse(lfs1_t *lfs1, int (*cb)(void*, lfs1_block_t), void *data);
// Prunes any recoverable errors that may have occurred in the filesystem
// Prunes any recoverable errors that may have occured in the filesystem
//
// Not needed to be called by user unless an operation is interrupted
// but the filesystem is still mounted. This is already called on first

6
lib/littlefs/lfs2.c
View File

@ -1449,7 +1449,7 @@ static int lfs2_dir_alloc(lfs2_t *lfs2, lfs2_mdir_t *dir) {
}
}
// zero for reproducibility in case initial block is unreadable
// zero for reproducability in case initial block is unreadable
dir->rev = 0;
// rather than clobbering one of the blocks we just pretend
@ -1643,7 +1643,7 @@ static int lfs2_dir_compact(lfs2_t *lfs2,
return err;
}
// whelp, we tried, if we ran out of space there's not much
// welp, we tried, if we ran out of space there's not much
// we can do, we'll error later if we've become frozen
if (!err) {
end = begin;
@ -4037,7 +4037,7 @@ static int lfs2_fs_relocate(lfs2_t *lfs2,
lfs2_fs_prepmove(lfs2, 0x3ff, NULL);
}
// replace bad pair, either we clean up desync, or no desync occurred
// replace bad pair, either we clean up desync, or no desync occured
lfs2_pair_tole32(newpair);
err = lfs2_dir_commit(lfs2, &parent, LFS2_MKATTRS(
{LFS2_MKTAG_IF(moveid != 0x3ff,

14
lib/littlefs/lfs2.h
View File

@ -159,34 +159,34 @@ struct lfs2_config {
// information to the block device operations
void *context;
// Read a region in a block. Negative error codes are propagated
// Read a region in a block. Negative error codes are propogated
// to the user.
int (*read)(const struct lfs2_config *c, lfs2_block_t block,
lfs2_off_t off, void *buffer, lfs2_size_t size);
// Program a region in a block. The block must have previously
// been erased. Negative error codes are propagated to the user.
// been erased. Negative error codes are propogated to the user.
// May return LFS2_ERR_CORRUPT if the block should be considered bad.
int (*prog)(const struct lfs2_config *c, lfs2_block_t block,
lfs2_off_t off, const void *buffer, lfs2_size_t size);
// Erase a block. A block must be erased before being programmed.
// The state of an erased block is undefined. Negative error codes
// are propagated to the user.
// are propogated to the user.
// May return LFS2_ERR_CORRUPT if the block should be considered bad.
int (*erase)(const struct lfs2_config *c, lfs2_block_t block);
// Sync the state of the underlying block device. Negative error codes
// are propagated to the user.
// are propogated to the user.
int (*sync)(const struct lfs2_config *c);
#ifdef LFS2_THREADSAFE
// Lock the underlying block device. Negative error codes
// are propagated to the user.
// are propogated to the user.
int (*lock)(const struct lfs2_config *c);
// Unlock the underlying block device. Negative error codes
// are propagated to the user.
// are propogated to the user.
int (*unlock)(const struct lfs2_config *c);
#endif
@ -479,7 +479,7 @@ int lfs2_stat(lfs2_t *lfs2, const char *path, struct lfs2_info *info);
// Returns the size of the attribute, or a negative error code on failure.
// Note, the returned size is the size of the attribute on disk, irrespective
// of the size of the buffer. This can be used to dynamically allocate a buffer
// or check for existence.
// or check for existance.
lfs2_ssize_t lfs2_getattr(lfs2_t *lfs2, const char *path,
uint8_t type, void *buffer, lfs2_size_t size);

4
lib/oofatfs/diskio.h
View File

@ -3,7 +3,7 @@
*/
/*-----------------------------------------------------------------------/
/ Low level disk interface module include file (C)ChaN, 2014 /
/ Low level disk interface modlue include file (C)ChaN, 2014 /
/-----------------------------------------------------------------------*/
#ifndef _DISKIO_DEFINED
@ -42,7 +42,7 @@ DRESULT disk_ioctl (void *drv, BYTE cmd, void* buff);
#define STA_PROTECT 0x04 /* Write protected */
/* Command code for disk_ioctrl function */
/* Command code for disk_ioctrl fucntion */
/* Generic command (Used by FatFs) */
#define CTRL_SYNC 0 /* Complete pending write process (needed at FF_FS_READONLY == 0) */

48
lib/oofatfs/ff.c
View File

@ -996,7 +996,7 @@ static FRESULT dec_lock ( /* Decrement object open counter */
if (n == 0) Files[i].fs = 0; /* Delete the entry if open count gets zero */
res = FR_OK;
} else {
res = FR_INT_ERR; /* Invalid index number */
res = FR_INT_ERR; /* Invalid index nunber */
}
return res;
}
@ -1990,7 +1990,7 @@ static void gen_numname (
seq = (UINT)sr;
}
/* itoa (hexadecimal) */
/* itoa (hexdecimal) */
i = 7;
do {
c = (BYTE)((seq % 16) + '0');
@ -2098,7 +2098,7 @@ static DWORD xsum32 ( /* Returns 32-bit checksum */
/*------------------------------------------------------*/
static void get_xfileinfo (
BYTE* dirb, /* Pointer to the directory entry block 85+C0+C1s */
BYTE* dirb, /* Pointer to the direcotry entry block 85+C0+C1s */
FILINFO* fno /* Buffer to store the extracted file information */
)
{
@ -2135,16 +2135,16 @@ static void get_xfileinfo (
/*-----------------------------------*/
/* exFAT: Get a directory entry block */
/* exFAT: Get a directry entry block */
/*-----------------------------------*/
static FRESULT load_xdir ( /* FR_INT_ERR: invalid entry block */
DIR* dp /* Reading directory object pointing top of the entry block to load */
DIR* dp /* Reading direcotry object pointing top of the entry block to load */
)
{
FRESULT res;
UINT i, sz_ent;
BYTE* dirb = dp->obj.fs->dirbuf; /* Pointer to the on-memory directory entry block 85+C0+C1s */
BYTE* dirb = dp->obj.fs->dirbuf; /* Pointer to the on-memory direcotry entry block 85+C0+C1s */
/* Load file-directory entry */
@ -2208,7 +2208,7 @@ static void init_alloc_info (
/*------------------------------------------------*/
static FRESULT load_obj_xdir (
DIR* dp, /* Blank directory object to be used to access containing directory */
DIR* dp, /* Blank directory object to be used to access containing direcotry */
const FFOBJID* obj /* Object with its containing directory information */
)
{
@ -2237,18 +2237,18 @@ static FRESULT load_obj_xdir (
/*----------------------------------------*/
static FRESULT store_xdir (
DIR* dp /* Pointer to the directory object */
DIR* dp /* Pointer to the direcotry object */
)
{
FRESULT res;
UINT nent;
BYTE* dirb = dp->obj.fs->dirbuf; /* Pointer to the directory entry block 85+C0+C1s */
BYTE* dirb = dp->obj.fs->dirbuf; /* Pointer to the direcotry entry block 85+C0+C1s */
/* Create set sum */
st_word(dirb + XDIR_SetSum, xdir_sum(dirb));
nent = dirb[XDIR_NumSec] + 1;
/* Store the directory entry block to the directory */
/* Store the direcotry entry block to the directory */
res = dir_sdi(dp, dp->blk_ofs);
while (res == FR_OK) {
res = move_window(dp->obj.fs, dp->sect);
@ -2265,11 +2265,11 @@ static FRESULT store_xdir (
/*-------------------------------------------*/
/* exFAT: Create a new directory entry block */
/* exFAT: Create a new directory enrty block */
/*-------------------------------------------*/
static void create_xdir (
BYTE* dirb, /* Pointer to the directory entry block buffer */
BYTE* dirb, /* Pointer to the direcotry entry block buffer */
const WCHAR* lfn /* Pointer to the object name */
)
{
@ -2690,7 +2690,7 @@ static void get_fileinfo (
fno->altname[di] = 0; /* Terminate the SFN (null string means SFN is invalid) */
if (fno->fname[0] == 0) { /* If LFN is invalid, altname[] needs to be copied to fname[] */
if (di == 0) { /* If LFN and SFN both are invalid, this object is inaccessible */
if (di == 0) { /* If LFN and SFN both are invalid, this object is inaccesible */
fno->fname[di++] = '?';
} else {
for (si = di = 0, lcf = NS_BODY; fno->altname[si]; si++, di++) { /* Copy altname[] to fname[] with case information */
@ -2764,7 +2764,7 @@ static DWORD get_achar ( /* Get a character and advances ptr */
static int pattern_matching ( /* 0:not matched, 1:matched */
const TCHAR* pat, /* Matching pattern */
const TCHAR* name, /* String to be tested */
const TCHAR* nam, /* String to be tested */
int skip, /* Number of pre-skip chars (number of ?s) */
int inf /* Infinite search (* specified) */
)
@ -2775,12 +2775,12 @@ static int pattern_matching ( /* 0:not matched, 1:matched */
while (skip--) { /* Pre-skip name chars */
if (!get_achar(&name)) return 0; /* Branch mismatched if less name chars */
if (!get_achar(&nam)) return 0; /* Branch mismatched if less name chars */
}
if (*pat == 0 && inf) return 1; /* (short circuit) */
do {
pp = pat; np = name; /* Top of pattern and name to match */
pp = pat; np = nam; /* Top of pattern and name to match */
for (;;) {
if (*pp == '?' || *pp == '*') { /* Wildcard? */
nm = nx = 0;
@ -2795,7 +2795,7 @@ static int pattern_matching ( /* 0:not matched, 1:matched */
if (pc != nc) break; /* Branch mismatched? */
if (pc == 0) return 1; /* Branch matched? (matched at end of both strings) */
}
get_achar(&name); /* name++ */
get_achar(&nam); /* nam++ */
} while (inf && nc); /* Retry until end of name if infinite search is specified */
return 0;
@ -3183,7 +3183,7 @@ static FRESULT find_volume ( /* FR_OK(0): successful, !=0: an error occurred
fmt = bsect ? check_fs(fs, bsect) : 3; /* Check the partition */
} while (LD2PT(fs) == 0 && fmt >= 2 && ++i < 4);
}
if (fmt == 4) return FR_DISK_ERR; /* An error occurred in the disk I/O layer */
if (fmt == 4) return FR_DISK_ERR; /* An error occured in the disk I/O layer */
if (fmt >= 2) return FR_NO_FILESYSTEM; /* No FAT volume is found */
/* An FAT volume is found (bsect). Following code initializes the filesystem object */
@ -3221,7 +3221,7 @@ static FRESULT find_volume ( /* FR_OK(0): successful, !=0: an error occurred
fs->volbase = bsect;
fs->database = bsect + ld_dword(fs->win + BPB_DataOfsEx);
fs->fatbase = bsect + ld_dword(fs->win + BPB_FatOfsEx);
if (maxlba < (QWORD)fs->database + nclst * fs->csize) return FR_NO_FILESYSTEM; /* (Volume size must not be smaller than the size required) */
if (maxlba < (QWORD)fs->database + nclst * fs->csize) return FR_NO_FILESYSTEM; /* (Volume size must not be smaller than the size requiered) */
fs->dirbase = ld_dword(fs->win + BPB_RootClusEx);
/* Get bitmap location and check if it is contiguous (implementation assumption) */
@ -3365,7 +3365,7 @@ static FRESULT validate ( /* Returns FR_OK or FR_INVALID_OBJECT */
if (obj && obj->fs && obj->fs->fs_type && obj->id == obj->fs->id) { /* Test if the object is valid */
#if FF_FS_REENTRANT
if (lock_fs(obj->fs)) { /* Obtain the filesystem object */
if (disk_ioctl(obj->fs->drv, IOCTL_STATUS, &stat) == RES_OK && !(stat & STA_NOINIT)) { /* Test if the physical drive is kept initialized */
if (disk_ioctl(obj->fs->drv, IOCTL_STATUS, &stat) == RES_OK && !(stat & STA_NOINIT)) { /* Test if the phsical drive is kept initialized */
res = FR_OK;
} else {
unlock_fs(obj->fs, FR_OK);
@ -3374,7 +3374,7 @@ static FRESULT validate ( /* Returns FR_OK or FR_INVALID_OBJECT */
res = FR_TIMEOUT;
}
#else
if (disk_ioctl(obj->fs->drv, IOCTL_STATUS, &stat) == RES_OK && !(stat & STA_NOINIT)) { /* Test if the physical drive is kept initialized */
if (disk_ioctl(obj->fs->drv, IOCTL_STATUS, &stat) == RES_OK && !(stat & STA_NOINIT)) { /* Test if the phsical drive is kept initialized */
res = FR_OK;
}
#endif
@ -3528,7 +3528,7 @@ FRESULT f_open (
}
}
else { /* Open an existing file */
if (res == FR_OK) { /* Is the object existing? */
if (res == FR_OK) { /* Is the object exsiting? */
if (dj.obj.attr & AM_DIR) { /* File open against a directory */
res = FR_NO_FILE;
} else {
@ -4339,7 +4339,7 @@ FRESULT f_opendir (
FREE_NAMBUF();
if (res == FR_NO_FILE) res = FR_NO_PATH;
}
if (res != FR_OK) dp->obj.fs = 0; /* Invalidate the directory object if function failed */
if (res != FR_OK) dp->obj.fs = 0; /* Invalidate the directory object if function faild */
LEAVE_FF(fs, res);
}
@ -4779,7 +4779,7 @@ FRESULT f_mkdir (
st_clust(fs, fs->win + SZDIRE, pcl);
fs->wflag = 1;
}
res = dir_register(&dj); /* Register the object to the parent directory */
res = dir_register(&dj); /* Register the object to the parent directoy */
}
}
if (res == FR_OK) {

2
lib/oofatfs/ff.h
View File

@ -240,7 +240,7 @@ typedef struct {
WORD ftime; /* Modified time */
BYTE fattrib; /* File attribute */
#if FF_USE_LFN
TCHAR altname[FF_SFN_BUF + 1];/* Alternative file name */
TCHAR altname[FF_SFN_BUF + 1];/* Altenative file name */
TCHAR fname[FF_LFN_BUF + 1]; /* Primary file name */
#else
TCHAR fname[12 + 1]; /* File name */

6
lib/oofatfs/ffconf.h
View File

@ -188,7 +188,7 @@
#define FF_LFN_BUF 255
#define FF_SFN_BUF 12
/* This set of options defines size of file name members in the FILINFO structure
/ which is used to read out directory items. These values should be sufficient for
/ which is used to read out directory items. These values should be suffcient for
/ the file names to read. The maximum possible length of the read file name depends
/ on character encoding. When LFN is not enabled, these options have no effect. */
@ -251,7 +251,7 @@
/ number and only an FAT volume found on the physical drive will be mounted.
/ When this function is enabled (1), each logical drive number can be bound to
/ arbitrary physical drive and partition listed in the VolToPart[]. Also f_fdisk()
/ function will be available. */
/ funciton will be available. */
#define FF_MIN_SS 512
@ -316,7 +316,7 @@
#define FF_NORTC_MON 1
#define FF_NORTC_MDAY 1
#define FF_NORTC_YEAR 2018
/* The option FF_FS_NORTC switches timestamp function. If the system does not have
/* The option FF_FS_NORTC switches timestamp functiton. If the system does not have
/ any RTC function or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable
/ the timestamp function. Every object modified by FatFs will have a fixed timestamp
/ defined by FF_NORTC_MON, FF_NORTC_MDAY and FF_NORTC_YEAR in local time.

2
lib/oofatfs/ffunicode.c
View File

@ -3,7 +3,7 @@
/*------------------------------------------------------------------------*/
/* This module will occupy a huge memory in the .const section when the /
/ FatFs is configured for LFN with DBCS. If the system has any Unicode /
/ utility for the code conversion, this module should be modified to use /
/ utilitiy for the code conversion, this module should be modified to use /
/ that function to avoid silly memory consumption. /
/-------------------------------------------------------------------------*/
/*

2
lib/sdmmc/sdmmc_io.c
View File

@ -282,7 +282,7 @@ sdmmc_err_t sdmmc_io_rw_extended(sdmmc_card_t* card, int func,
return SDMMC_ERR_INVALID_SIZE;
}
if (datalen == max_byte_transfer_size) {
count = 0; // See 5.3.1 SDIO simplified spec
count = 0; // See 5.3.1 SDIO simplifed spec
} else {
count = datalen;
}

2
lib/uzlib/tinflate.c
View File

@ -597,7 +597,7 @@ next_blk:
if (res == TINF_DONE && !d->bfinal) {
/* the block has ended (without producing more data), but we
can't return without data, so start processing next block */
can't return without data, so start procesing next block */
goto next_blk;
}