Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

ipod nano 2g: make functions/variables static where possible, add missing #includes

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@27752 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Bertrik Sikken 2010-08-08 10:49:32 +00:00
parent 82a2cdb2ad
commit 446445e916
7 changed files with 116 additions and 121 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

134
firmware/target/arm/s5l8700/ipodnano2g/ftl-nano2g.c
View file

@ -178,7 +178,7 @@ struct ftl_cxt_type
/* Seems to be unused, but gets loaded from flash by Whimory. */ /* Seems to be unused, but gets loaded from flash by Whimory. */
uint8_t field_130[0x15C]; uint8_t field_130[0x15C];
} __attribute__((packed)) FTLCxtType; } __attribute__((packed));
/* Keeps the state of the bank's VFL, both on flash and in memory. /* Keeps the state of the bank's VFL, both on flash and in memory.
@ -363,54 +363,54 @@ const struct nand_device_info_type* ftl_nand_type;
uint32_t ftl_banks; uint32_t ftl_banks;
/* Block map, used vor pBlock to vBlock mapping */ /* Block map, used vor pBlock to vBlock mapping */
uint16_t ftl_map[0x2000]; static uint16_t ftl_map[0x2000];
/* VFL context for each bank */ /* VFL context for each bank */
struct ftl_vfl_cxt_type ftl_vfl_cxt[4]; static struct ftl_vfl_cxt_type ftl_vfl_cxt[4];
/* FTL context */ /* FTL context */
struct ftl_cxt_type ftl_cxt; static struct ftl_cxt_type ftl_cxt;
/* Temporary data buffers for internal use by the FTL */ /* Temporary data buffers for internal use by the FTL */
uint8_t ftl_buffer[0x800] STORAGE_ALIGN_ATTR; static uint8_t ftl_buffer[0x800] STORAGE_ALIGN_ATTR;
/* Temporary spare byte buffer for internal use by the FTL */ /* Temporary spare byte buffer for internal use by the FTL */
union ftl_spare_data_type ftl_sparebuffer[FTL_WRITESPARE_SIZE] STORAGE_ALIGN_ATTR; static union ftl_spare_data_type ftl_sparebuffer[FTL_WRITESPARE_SIZE] STORAGE_ALIGN_ATTR;
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Lowlevel BBT for each bank */ /* Lowlevel BBT for each bank */
uint8_t ftl_bbt[4][0x410]; static uint8_t ftl_bbt[4][0x410];
/* Erase counters for the vBlocks */ /* Erase counters for the vBlocks */
uint16_t ftl_erasectr[0x2000]; static uint16_t ftl_erasectr[0x2000];
/* Used by ftl_log */ /* Used by ftl_log */
uint16_t ftl_offsets[0x11][0x200]; static uint16_t ftl_offsets[0x11][0x200];
/* Structs keeping record of scattered page blocks */ /* Structs keeping record of scattered page blocks */
struct ftl_log_type ftl_log[0x11]; static struct ftl_log_type ftl_log[0x11];
/* Global cross-bank update sequence number of the VFL context */ /* Global cross-bank update sequence number of the VFL context */
uint32_t ftl_vfl_usn; static uint32_t ftl_vfl_usn;
/* Keeps track (temporarily) of troublesome blocks */ /* Keeps track (temporarily) of troublesome blocks */
struct ftl_trouble_type ftl_troublelog[5]; static struct ftl_trouble_type ftl_troublelog[5];
/* Counts erase counter page changes, after 100 of them the affected /* Counts erase counter page changes, after 100 of them the affected
page will be committed to the flash. */ page will be committed to the flash. */
uint8_t ftl_erasectr_dirt[8]; static uint8_t ftl_erasectr_dirt[8];
/* Buffer needed for copying pages around while moving or committing blocks. /* Buffer needed for copying pages around while moving or committing blocks.
This can't be shared with ftl_buffer, because this one could be overwritten This can't be shared with ftl_buffer, because this one could be overwritten
during the copying operation in order to e.g. commit a CXT. */ during the copying operation in order to e.g. commit a CXT. */
uint8_t ftl_copybuffer[FTL_COPYBUF_SIZE][0x800] STORAGE_ALIGN_ATTR; static uint8_t ftl_copybuffer[FTL_COPYBUF_SIZE][0x800] STORAGE_ALIGN_ATTR;
union ftl_spare_data_type ftl_copyspare[FTL_COPYBUF_SIZE] STORAGE_ALIGN_ATTR; static union ftl_spare_data_type ftl_copyspare[FTL_COPYBUF_SIZE] STORAGE_ALIGN_ATTR;
/* Needed to store the old scattered page offsets in order to be able to roll /* Needed to store the old scattered page offsets in order to be able to roll
back if something fails while compacting a scattered page block. */ back if something fails while compacting a scattered page block. */
uint16_t ftl_offsets_backup[0x200] STORAGE_ALIGN_ATTR; static uint16_t ftl_offsets_backup[0x200] STORAGE_ALIGN_ATTR;
#endif #endif
@ -421,7 +421,7 @@ static struct mutex ftl_mtx;
/* Finds a device info page for the specified bank and returns its number. /* Finds a device info page for the specified bank and returns its number.
Used to check if one is present, and to read the lowlevel BBT. */ Used to check if one is present, and to read the lowlevel BBT. */
uint32_t ftl_find_devinfo(uint32_t bank) static uint32_t ftl_find_devinfo(uint32_t bank)
{ {
/* Scan the last 10% of the flash for device info pages */ /* Scan the last 10% of the flash for device info pages */
uint32_t lowestBlock = ftl_nand_type->blocks uint32_t lowestBlock = ftl_nand_type->blocks
@ -445,7 +445,7 @@ uint32_t ftl_find_devinfo(uint32_t bank)
/* Checks if all banks have proper device info pages */ /* Checks if all banks have proper device info pages */
uint32_t ftl_has_devinfo(void) static uint32_t ftl_has_devinfo(void)
{ {
uint32_t i; uint32_t i;
for (i = 0; i < ftl_banks; i++) if (ftl_find_devinfo(i) == 0) return 0; for (i = 0; i < ftl_banks; i++) if (ftl_find_devinfo(i) == 0) return 0;
@ -455,7 +455,7 @@ uint32_t ftl_has_devinfo(void)
/* Loads the lowlevel BBT for a bank to the specified buffer. /* Loads the lowlevel BBT for a bank to the specified buffer.
This is based on some cryptic disassembly and not fully understood yet. */ This is based on some cryptic disassembly and not fully understood yet. */
uint32_t ftl_load_bbt(uint32_t bank, uint8_t* bbt) static uint32_t ftl_load_bbt(uint32_t bank, uint8_t* bbt)
{ {
uint32_t i, j; uint32_t i, j;
uint32_t pagebase, page = ftl_find_devinfo(bank), page2; uint32_t pagebase, page = ftl_find_devinfo(bank), page2;
@ -489,8 +489,8 @@ uint32_t ftl_load_bbt(uint32_t bank, uint8_t* bbt)
/* Calculates the checksums for the VFL context page of the specified bank */ /* Calculates the checksums for the VFL context page of the specified bank */
void ftl_vfl_calculate_checksum(uint32_t bank, static void ftl_vfl_calculate_checksum(uint32_t bank,
uint32_t* checksum1, uint32_t* checksum2) uint32_t* checksum1, uint32_t* checksum2)
{ {
uint32_t i; uint32_t i;
*checksum1 = 0xAABBCCDD; *checksum1 = 0xAABBCCDD;
@ -505,7 +505,7 @@ void ftl_vfl_calculate_checksum(uint32_t bank,
/* Checks if the checksums of the VFL context /* Checks if the checksums of the VFL context
of the specified bank are correct */ of the specified bank are correct */
uint32_t ftl_vfl_verify_checksum(uint32_t bank) static uint32_t ftl_vfl_verify_checksum(uint32_t bank)
{ {
uint32_t checksum1, checksum2; uint32_t checksum1, checksum2;
ftl_vfl_calculate_checksum(bank, &checksum1, &checksum2); ftl_vfl_calculate_checksum(bank, &checksum1, &checksum2);
@ -520,7 +520,7 @@ uint32_t ftl_vfl_verify_checksum(uint32_t bank)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Updates the checksums of the VFL context of the specified bank */ /* Updates the checksums of the VFL context of the specified bank */
void ftl_vfl_update_checksum(uint32_t bank) static void ftl_vfl_update_checksum(uint32_t bank)
{ {
ftl_vfl_calculate_checksum(bank, &ftl_vfl_cxt[bank].checksum1, ftl_vfl_calculate_checksum(bank, &ftl_vfl_cxt[bank].checksum1,
&ftl_vfl_cxt[bank].checksum2); &ftl_vfl_cxt[bank].checksum2);
@ -531,7 +531,7 @@ void ftl_vfl_update_checksum(uint32_t bank)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Writes 8 copies of the VFL context of the specified bank to flash, /* Writes 8 copies of the VFL context of the specified bank to flash,
and succeeds if at least 4 can be read back properly. */ and succeeds if at least 4 can be read back properly. */
uint32_t ftl_vfl_store_cxt(uint32_t bank) static uint32_t ftl_vfl_store_cxt(uint32_t bank)
{ {
uint32_t i; uint32_t i;
ftl_vfl_cxt[bank].updatecount--; ftl_vfl_cxt[bank].updatecount--;
@ -575,7 +575,7 @@ uint32_t ftl_vfl_store_cxt(uint32_t bank)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Commits the VFL context of the specified bank to flash, /* Commits the VFL context of the specified bank to flash,
retries until it works or all available pages have been tried */ retries until it works or all available pages have been tried */
uint32_t ftl_vfl_commit_cxt(uint32_t bank) static uint32_t ftl_vfl_commit_cxt(uint32_t bank)
{ {
if (ftl_vfl_cxt[bank].nextcxtpage + 8 <= ftl_nand_type->pagesperblock) if (ftl_vfl_cxt[bank].nextcxtpage + 8 <= ftl_nand_type->pagesperblock)
if (ftl_vfl_store_cxt(bank) == 0) return 0; if (ftl_vfl_store_cxt(bank) == 0) return 0;
@ -604,7 +604,7 @@ uint32_t ftl_vfl_commit_cxt(uint32_t bank)
/* Returns a pointer to the most recently updated VFL context, /* Returns a pointer to the most recently updated VFL context,
used to find out the current FTL context vBlock numbers used to find out the current FTL context vBlock numbers
(planetbeing's "maxthing") */ (planetbeing's "maxthing") */
struct ftl_vfl_cxt_type* ftl_vfl_get_newest_cxt(void) static struct ftl_vfl_cxt_type* ftl_vfl_get_newest_cxt(void)
{ {
uint32_t i, maxusn; uint32_t i, maxusn;
struct ftl_vfl_cxt_type* cxt = (struct ftl_vfl_cxt_type*)0; struct ftl_vfl_cxt_type* cxt = (struct ftl_vfl_cxt_type*)0;
@ -621,7 +621,7 @@ struct ftl_vfl_cxt_type* ftl_vfl_get_newest_cxt(void)
/* Checks if the specified pBlock is marked bad in the supplied lowlevel BBT. /* Checks if the specified pBlock is marked bad in the supplied lowlevel BBT.
Only used while mounting the VFL. */ Only used while mounting the VFL. */
uint32_t ftl_is_good_block(uint8_t* bbt, uint32_t block) static uint32_t ftl_is_good_block(uint8_t* bbt, uint32_t block)
{ {
if ((bbt[block >> 3] & (1 << (block & 7))) == 0) return 0; if ((bbt[block >> 3] & (1 << (block & 7))) == 0) return 0;
else return 1; else return 1;
@ -629,7 +629,7 @@ uint32_t ftl_is_good_block(uint8_t* bbt, uint32_t block)
/* Checks if the specified vBlock could be remapped */ /* Checks if the specified vBlock could be remapped */
uint32_t ftl_vfl_is_good_block(uint32_t bank, uint32_t block) static uint32_t ftl_vfl_is_good_block(uint32_t bank, uint32_t block)
{ {
uint8_t bbtentry = ftl_vfl_cxt[bank].bbt[block >> 6]; uint8_t bbtentry = ftl_vfl_cxt[bank].bbt[block >> 6];
if ((bbtentry & (1 << ((7 - (block >> 3)) & 7))) == 0) return 0; if ((bbtentry & (1 << ((7 - (block >> 3)) & 7))) == 0) return 0;
@ -640,7 +640,7 @@ uint32_t ftl_vfl_is_good_block(uint32_t bank, uint32_t block)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Sets or unsets the bad bit of the specified vBlock /* Sets or unsets the bad bit of the specified vBlock
in the specified bank's VFL context */ in the specified bank's VFL context */
void ftl_vfl_set_good_block(uint32_t bank, uint32_t block, uint32_t isgood) static void ftl_vfl_set_good_block(uint32_t bank, uint32_t block, uint32_t isgood)
{ {
uint8_t bit = (1 << ((7 - (block >> 3)) & 7)); uint8_t bit = (1 << ((7 - (block >> 3)) & 7));
if (isgood == 1) ftl_vfl_cxt[bank].bbt[block >> 6] |= bit; if (isgood == 1) ftl_vfl_cxt[bank].bbt[block >> 6] |= bit;
@ -650,9 +650,9 @@ void ftl_vfl_set_good_block(uint32_t bank, uint32_t block, uint32_t isgood)
/* Tries to read a VFL context from the specified bank, pBlock and page */ /* Tries to read a VFL context from the specified bank, pBlock and page */
uint32_t ftl_vfl_read_page(uint32_t bank, uint32_t block, static uint32_t ftl_vfl_read_page(uint32_t bank, uint32_t block,
uint32_t startpage, void* databuffer, uint32_t startpage, void* databuffer,
union ftl_spare_data_type* sparebuffer) union ftl_spare_data_type* sparebuffer)
{ {
uint32_t i; uint32_t i;
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
@ -670,7 +670,7 @@ uint32_t ftl_vfl_read_page(uint32_t bank, uint32_t block,
/* Translates a bank and vBlock to a pBlock, following remaps */ /* Translates a bank and vBlock to a pBlock, following remaps */
uint32_t ftl_vfl_get_physical_block(uint32_t bank, uint32_t block) static uint32_t ftl_vfl_get_physical_block(uint32_t bank, uint32_t block)
{ {
if (ftl_vfl_is_good_block(bank, block) == 1) return block; if (ftl_vfl_is_good_block(bank, block) == 1) return block;
@ -685,7 +685,7 @@ uint32_t ftl_vfl_get_physical_block(uint32_t bank, uint32_t block)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Checks if remapping is scheduled for the specified bank and vBlock */ /* Checks if remapping is scheduled for the specified bank and vBlock */
uint32_t ftl_vfl_check_remap_scheduled(uint32_t bank, uint32_t block) static uint32_t ftl_vfl_check_remap_scheduled(uint32_t bank, uint32_t block)
{ {
uint32_t i; uint32_t i;
for (i = 0x333; i > 0 && i > ftl_vfl_cxt[bank].scheduledstart; i--) for (i = 0x333; i > 0 && i > ftl_vfl_cxt[bank].scheduledstart; i--)
@ -697,7 +697,7 @@ uint32_t ftl_vfl_check_remap_scheduled(uint32_t bank, uint32_t block)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Schedules remapping for the specified bank and vBlock */ /* Schedules remapping for the specified bank and vBlock */
void ftl_vfl_schedule_block_for_remap(uint32_t bank, uint32_t block) static void ftl_vfl_schedule_block_for_remap(uint32_t bank, uint32_t block)
{ {
if (ftl_vfl_check_remap_scheduled(bank, block) == 1) if (ftl_vfl_check_remap_scheduled(bank, block) == 1)
return; return;
@ -713,7 +713,7 @@ void ftl_vfl_schedule_block_for_remap(uint32_t bank, uint32_t block)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Removes the specified bank and vBlock combination /* Removes the specified bank and vBlock combination
from the remap scheduled list */ from the remap scheduled list */
void ftl_vfl_mark_remap_done(uint32_t bank, uint32_t block) static void ftl_vfl_mark_remap_done(uint32_t bank, uint32_t block)
{ {
uint32_t i; uint32_t i;
uint32_t start = ftl_vfl_cxt[bank].scheduledstart; uint32_t start = ftl_vfl_cxt[bank].scheduledstart;
@ -734,7 +734,7 @@ void ftl_vfl_mark_remap_done(uint32_t bank, uint32_t block)
/* Logs that there is trouble for the specified vBlock on the specified bank. /* Logs that there is trouble for the specified vBlock on the specified bank.
The vBlock will be scheduled for remap The vBlock will be scheduled for remap
if there is too much trouble with it. */ if there is too much trouble with it. */
void ftl_vfl_log_trouble(uint32_t bank, uint32_t vblock) static void ftl_vfl_log_trouble(uint32_t bank, uint32_t vblock)
{ {
uint32_t i; uint32_t i;
for (i = 0; i < 5; i++) for (i = 0; i < 5; i++)
@ -763,7 +763,7 @@ void ftl_vfl_log_trouble(uint32_t bank, uint32_t vblock)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Logs a successful erase for the specified vBlock on the specified bank */ /* Logs a successful erase for the specified vBlock on the specified bank */
void ftl_vfl_log_success(uint32_t bank, uint32_t vblock) static void ftl_vfl_log_success(uint32_t bank, uint32_t vblock)
{ {
uint32_t i; uint32_t i;
for (i = 0; i < 5; i++) for (i = 0; i < 5; i++)
@ -783,7 +783,7 @@ void ftl_vfl_log_success(uint32_t bank, uint32_t vblock)
not caring about data in there. not caring about data in there.
If it worked, it will return the new pBlock number, If it worked, it will return the new pBlock number,
if not (no more spare blocks available), it will return zero. */ if not (no more spare blocks available), it will return zero. */
uint32_t ftl_vfl_remap_block(uint32_t bank, uint32_t block) static uint32_t ftl_vfl_remap_block(uint32_t bank, uint32_t block)
{ {
uint32_t i; uint32_t i;
uint32_t newblock = 0, newidx; uint32_t newblock = 0, newidx;
@ -813,8 +813,8 @@ uint32_t ftl_vfl_remap_block(uint32_t bank, uint32_t block)
/* Reads the specified vPage, dealing with all kinds of trouble */ /* Reads the specified vPage, dealing with all kinds of trouble */
uint32_t ftl_vfl_read(uint32_t vpage, void* buffer, void* sparebuffer, static uint32_t ftl_vfl_read(uint32_t vpage, void* buffer, void* sparebuffer,
uint32_t checkempty, uint32_t remaponfail) uint32_t checkempty, uint32_t remaponfail)
{ {
uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks; uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;
uint32_t syshyperblocks = ftl_nand_type->blocks uint32_t syshyperblocks = ftl_nand_type->blocks
@ -852,8 +852,8 @@ uint32_t ftl_vfl_read(uint32_t vpage, void* buffer, void* sparebuffer,
/* Multi-bank version of ftl_vfl_read, will read ftl_banks pages in parallel */ /* Multi-bank version of ftl_vfl_read, will read ftl_banks pages in parallel */
uint32_t ftl_vfl_read_fast(uint32_t vpage, void* buffer, void* sparebuffer, static uint32_t ftl_vfl_read_fast(uint32_t vpage, void* buffer, void* sparebuffer,
uint32_t checkempty, uint32_t remaponfail) uint32_t checkempty, uint32_t remaponfail)
{ {
uint32_t i, rc = 0; uint32_t i, rc = 0;
uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks; uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;
@ -922,8 +922,8 @@ uint32_t ftl_vfl_read_fast(uint32_t vpage, void* buffer, void* sparebuffer,
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Writes the specified vPage, dealing with all kinds of trouble */ /* Writes the specified vPage, dealing with all kinds of trouble */
uint32_t ftl_vfl_write(uint32_t vpage, uint32_t count, static uint32_t ftl_vfl_write(uint32_t vpage, uint32_t count,
void* buffer, void* sparebuffer) void* buffer, void* sparebuffer)
{ {
uint32_t i, j; uint32_t i, j;
uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks; uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;
@ -993,7 +993,7 @@ uint32_t ftl_vfl_write(uint32_t vpage, uint32_t count,
/* Mounts the VFL on all banks */ /* Mounts the VFL on all banks */
uint32_t ftl_vfl_open(void) static uint32_t ftl_vfl_open(void)
{ {
uint32_t i, j, k; uint32_t i, j, k;
uint32_t minusn, vflcxtidx, last; uint32_t minusn, vflcxtidx, last;
@ -1080,7 +1080,7 @@ uint32_t ftl_vfl_open(void)
/* Mounts the actual FTL */ /* Mounts the actual FTL */
uint32_t ftl_open(void) static uint32_t ftl_open(void)
{ {
uint32_t i; uint32_t i;
uint32_t ret; uint32_t ret;
@ -1182,7 +1182,7 @@ uint32_t ftl_open(void)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Returns a pointer to the ftl_log entry for the specified vBlock, /* Returns a pointer to the ftl_log entry for the specified vBlock,
or null, if there is none */ or null, if there is none */
struct ftl_log_type* ftl_get_log_entry(uint32_t block) static struct ftl_log_type* ftl_get_log_entry(uint32_t block)
{ {
uint32_t i; uint32_t i;
for (i = 0; i < 0x11; i++) for (i = 0; i < 0x11; i++)
@ -1264,7 +1264,7 @@ uint32_t ftl_read(uint32_t sector, uint32_t count, void* buffer)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Performs a vBlock erase, dealing with hardware, /* Performs a vBlock erase, dealing with hardware,
remapping and all kinds of trouble */ remapping and all kinds of trouble */
uint32_t ftl_erase_block_internal(uint32_t block) static uint32_t ftl_erase_block_internal(uint32_t block)
{ {
uint32_t i, j; uint32_t i, j;
block = block + ftl_nand_type->blocks block = block + ftl_nand_type->blocks
@ -1308,7 +1308,7 @@ uint32_t ftl_erase_block_internal(uint32_t block)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Highlevel vBlock erase, that increments the erase counter for the block */ /* Highlevel vBlock erase, that increments the erase counter for the block */
uint32_t ftl_erase_block(uint32_t block) static uint32_t ftl_erase_block(uint32_t block)
{ {
ftl_erasectr[block]++; ftl_erasectr[block]++;
if (ftl_erasectr_dirt[block >> 10] == 100) ftl_cxt.erasedirty = 1; if (ftl_erasectr_dirt[block >> 10] == 100) ftl_cxt.erasedirty = 1;
@ -1321,7 +1321,7 @@ uint32_t ftl_erase_block(uint32_t block)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Allocates a block from the pool, /* Allocates a block from the pool,
returning its vBlock number, or 0xFFFFFFFF on error */ returning its vBlock number, or 0xFFFFFFFF on error */
uint32_t ftl_allocate_pool_block(void) static uint32_t ftl_allocate_pool_block(void)
{ {
uint32_t i; uint32_t i;
uint32_t erasectr = 0xFFFFFFFF, bestidx = 0xFFFFFFFF, block; uint32_t erasectr = 0xFFFFFFFF, bestidx = 0xFFFFFFFF, block;
@ -1355,7 +1355,7 @@ uint32_t ftl_allocate_pool_block(void)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Releases a vBlock back into the pool */ /* Releases a vBlock back into the pool */
void ftl_release_pool_block(uint32_t block) static void ftl_release_pool_block(uint32_t block)
{ {
if (block >= (uint32_t)ftl_nand_type->userblocks + 0x17) if (block >= (uint32_t)ftl_nand_type->userblocks + 0x17)
panicf("FTL: Tried to release block %u", (unsigned)block); panicf("FTL: Tried to release block %u", (unsigned)block);
@ -1369,7 +1369,7 @@ void ftl_release_pool_block(uint32_t block)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Commits the location of the FTL context blocks /* Commits the location of the FTL context blocks
to a semi-randomly chosen VFL context */ to a semi-randomly chosen VFL context */
uint32_t ftl_store_ctrl_block_list(void) static uint32_t ftl_store_ctrl_block_list(void)
{ {
uint32_t i; uint32_t i;
for (i = 0; i < ftl_banks; i++) for (i = 0; i < ftl_banks; i++)
@ -1382,7 +1382,7 @@ uint32_t ftl_store_ctrl_block_list(void)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Saves the n-th erase counter page to the flash, /* Saves the n-th erase counter page to the flash,
because it is too dirty or needs to be moved. */ because it is too dirty or needs to be moved. */
uint32_t ftl_save_erasectr_page(uint32_t index) static uint32_t ftl_save_erasectr_page(uint32_t index)
{ {
memset(&ftl_sparebuffer[0], 0xFF, 0x40); memset(&ftl_sparebuffer[0], 0xFF, 0x40);
ftl_sparebuffer[0].meta.usn = ftl_cxt.usn; ftl_sparebuffer[0].meta.usn = ftl_cxt.usn;
@ -1408,7 +1408,7 @@ uint32_t ftl_save_erasectr_page(uint32_t index)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Increments ftl_cxt.ftlctrlpage to the next available FTL context page, /* Increments ftl_cxt.ftlctrlpage to the next available FTL context page,
allocating a new context block if neccessary. */ allocating a new context block if neccessary. */
uint32_t ftl_next_ctrl_pool_page(void) static uint32_t ftl_next_ctrl_pool_page(void)
{ {
uint32_t i; uint32_t i;
uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks; uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;
@ -1446,8 +1446,8 @@ uint32_t ftl_next_ctrl_pool_page(void)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Copies a vPage from one location to another */ /* Copies a vPage from one location to another */
uint32_t ftl_copy_page(uint32_t source, uint32_t destination, static uint32_t ftl_copy_page(uint32_t source, uint32_t destination,
uint32_t lpn, uint32_t type) uint32_t lpn, uint32_t type)
{ {
uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks; uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;
uint32_t rc = ftl_vfl_read(source, ftl_copybuffer[0], uint32_t rc = ftl_vfl_read(source, ftl_copybuffer[0],
@ -1467,7 +1467,7 @@ uint32_t ftl_copy_page(uint32_t source, uint32_t destination,
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Copies a pBlock to a vBlock */ /* Copies a pBlock to a vBlock */
uint32_t ftl_copy_block(uint32_t source, uint32_t destination) static uint32_t ftl_copy_block(uint32_t source, uint32_t destination)
{ {
uint32_t i, j; uint32_t i, j;
uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks; uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;
@ -1509,7 +1509,7 @@ uint32_t ftl_copy_block(uint32_t source, uint32_t destination)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Clears ftl_log.issequential, if something violating that is written. */ /* Clears ftl_log.issequential, if something violating that is written. */
void ftl_check_still_sequential(struct ftl_log_type* entry, uint32_t page) static void ftl_check_still_sequential(struct ftl_log_type* entry, uint32_t page)
{ {
if (entry->pagesused != entry->pagescurrent if (entry->pagesused != entry->pagescurrent
|| entry->pageoffsets[page] != page) || entry->pageoffsets[page] != page)
@ -1526,7 +1526,7 @@ void ftl_check_still_sequential(struct ftl_log_type* entry, uint32_t page)
space again. This is usually done when a scattered page block is being space again. This is usually done when a scattered page block is being
removed because it is full, but less than half of the pages in there are removed because it is full, but less than half of the pages in there are
still in use and rest is just filled with old crap. */ still in use and rest is just filled with old crap. */
uint32_t ftl_compact_scattered(struct ftl_log_type* entry) static uint32_t ftl_compact_scattered(struct ftl_log_type* entry)
{ {
uint32_t i, j; uint32_t i, j;
uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks; uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;
@ -1582,7 +1582,7 @@ uint32_t ftl_compact_scattered(struct ftl_log_type* entry)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Commits an ftl_log entry to proper blocks, no matter what's in there. */ /* Commits an ftl_log entry to proper blocks, no matter what's in there. */
uint32_t ftl_commit_scattered(struct ftl_log_type* entry) static uint32_t ftl_commit_scattered(struct ftl_log_type* entry)
{ {
uint32_t i; uint32_t i;
uint32_t error; uint32_t error;
@ -1610,7 +1610,7 @@ uint32_t ftl_commit_scattered(struct ftl_log_type* entry)
sequentially until now, in order to be able to save a block erase by sequentially until now, in order to be able to save a block erase by
committing it without needing to copy it again. committing it without needing to copy it again.
If this fails for whichever reason, it will be committed the usual way. */ If this fails for whichever reason, it will be committed the usual way. */
uint32_t ftl_commit_sequential(struct ftl_log_type* entry) static uint32_t ftl_commit_sequential(struct ftl_log_type* entry)
{ {
uint32_t i; uint32_t i;
uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks; uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;
@ -1656,7 +1656,7 @@ uint32_t ftl_commit_sequential(struct ftl_log_type* entry)
/* If a log entry is supplied, its scattered page block will be removed in /* If a log entry is supplied, its scattered page block will be removed in
whatever way seems most appropriate. Else, the oldest scattered page block whatever way seems most appropriate. Else, the oldest scattered page block
will be freed by committing it. */ will be freed by committing it. */
uint32_t ftl_remove_scattered_block(struct ftl_log_type* entry) static uint32_t ftl_remove_scattered_block(struct ftl_log_type* entry)
{ {
uint32_t i; uint32_t i;
uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks; uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;
@ -1692,7 +1692,7 @@ uint32_t ftl_remove_scattered_block(struct ftl_log_type* entry)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Initialize a log entry to the values for an empty scattered page block */ /* Initialize a log entry to the values for an empty scattered page block */
void ftl_init_log_entry(struct ftl_log_type* entry) static void ftl_init_log_entry(struct ftl_log_type* entry)
{ {
entry->issequential = 1; entry->issequential = 1;
entry->pagescurrent = 0; entry->pagescurrent = 0;
@ -1705,7 +1705,7 @@ void ftl_init_log_entry(struct ftl_log_type* entry)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Allocates a log entry for the specified vBlock, /* Allocates a log entry for the specified vBlock,
first making space, if neccessary. */ first making space, if neccessary. */
struct ftl_log_type* ftl_allocate_log_entry(uint32_t block) static struct ftl_log_type* ftl_allocate_log_entry(uint32_t block)
{ {
uint32_t i; uint32_t i;
struct ftl_log_type* entry = ftl_get_log_entry(block); struct ftl_log_type* entry = ftl_get_log_entry(block);
@ -1746,7 +1746,7 @@ struct ftl_log_type* ftl_allocate_log_entry(uint32_t block)
#ifndef FTL_READONLY #ifndef FTL_READONLY
/* Commits the FTL block map, erase counters, and context to flash */ /* Commits the FTL block map, erase counters, and context to flash */
uint32_t ftl_commit_cxt(void) static uint32_t ftl_commit_cxt(void)
{ {
uint32_t i; uint32_t i;
uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks; uint32_t ppb = ftl_nand_type->pagesperblock * ftl_banks;
@ -1788,7 +1788,7 @@ uint32_t ftl_commit_cxt(void)
/* Swaps the most and least worn block on the flash, /* Swaps the most and least worn block on the flash,
to better distribute wear. It will refuse to do anything to better distribute wear. It will refuse to do anything
if the wear spread is lower than 5 erases. */ if the wear spread is lower than 5 erases. */
uint32_t ftl_swap_blocks(void) static uint32_t ftl_swap_blocks(void)
{ {
uint32_t i; uint32_t i;
uint32_t min = 0xFFFFFFFF, max = 0, maxidx = 0x14; uint32_t min = 0xFFFFFFFF, max = 0, maxidx = 0x14;

9
firmware/target/arm/s5l8700/ipodnano2g/lcd-nano2g.c
View file

@ -153,15 +153,6 @@ void lcd_shutdown(void)
} }
} }
void lcd_off(void)
{
}
void lcd_on(void)
{
}
/* LCD init */ /* LCD init */
void lcd_init_device(void) void lcd_init_device(void)
{ {

72
firmware/target/arm/s5l8700/ipodnano2g/nand-nano2g.c
View file

@ -84,15 +84,15 @@ static const struct nand_device_info_type nand_deviceinfotable[] =
{0xA555D520, 8192, 3872, 0x80, 7, 2, 1, 2, 1} {0xA555D520, 8192, 3872, 0x80, 7, 2, 1, 2, 1}
}; };
uint8_t nand_tunk1[4]; static uint8_t nand_tunk1[4];
uint8_t nand_twp[4]; static uint8_t nand_twp[4];
uint8_t nand_tunk2[4]; static uint8_t nand_tunk2[4];
uint8_t nand_tunk3[4]; static uint8_t nand_tunk3[4];
uint32_t nand_type[4]; static uint32_t nand_type[4];
int nand_powered = 0; static int nand_powered = 0;
int nand_interleaved = 0; static int nand_interleaved = 0;
int nand_cached = 0; static int nand_cached = 0;
long nand_last_activity_value = -1; static long nand_last_activity_value = -1;
static long nand_stack[DEFAULT_STACK_SIZE]; static long nand_stack[DEFAULT_STACK_SIZE];
static struct mutex nand_mtx; static struct mutex nand_mtx;
@ -106,7 +106,7 @@ static uint8_t nand_spare[0x40] STORAGE_ALIGN_ATTR;
static uint8_t nand_ecc[0x30] STORAGE_ALIGN_ATTR; static uint8_t nand_ecc[0x30] STORAGE_ALIGN_ATTR;
uint32_t nand_unlock(uint32_t rc) static uint32_t nand_unlock(uint32_t rc)
{ {
led(false); led(false);
nand_last_activity_value = current_tick; nand_last_activity_value = current_tick;
@ -114,13 +114,13 @@ uint32_t nand_unlock(uint32_t rc)
return rc; return rc;
} }
uint32_t ecc_unlock(uint32_t rc) static uint32_t ecc_unlock(uint32_t rc)
{ {
mutex_unlock(&ecc_mtx); mutex_unlock(&ecc_mtx);
return rc; return rc;
} }
uint32_t nand_timeout(long timeout) static uint32_t nand_timeout(long timeout)
{ {
if (TIME_AFTER(current_tick, timeout)) return 1; if (TIME_AFTER(current_tick, timeout)) return 1;
else else
@ -130,7 +130,7 @@ uint32_t nand_timeout(long timeout)
} }
} }
uint32_t nand_wait_rbbdone(void) static uint32_t nand_wait_rbbdone(void)
{ {
long timeout = current_tick + HZ / 50; long timeout = current_tick + HZ / 50;
while (!(FMCSTAT & FMCSTAT_RBBDONE)) while (!(FMCSTAT & FMCSTAT_RBBDONE))
@ -139,7 +139,7 @@ uint32_t nand_wait_rbbdone(void)
return 0; return 0;
} }
uint32_t nand_wait_cmddone(void) static uint32_t nand_wait_cmddone(void)
{ {
long timeout = current_tick + HZ / 50; long timeout = current_tick + HZ / 50;
while (!(FMCSTAT & FMCSTAT_CMDDONE)) while (!(FMCSTAT & FMCSTAT_CMDDONE))
@ -148,7 +148,7 @@ uint32_t nand_wait_cmddone(void)
return 0; return 0;
} }
uint32_t nand_wait_addrdone(void) static uint32_t nand_wait_addrdone(void)
{ {
long timeout = current_tick + HZ / 50; long timeout = current_tick + HZ / 50;
while (!(FMCSTAT & FMCSTAT_ADDRDONE)) while (!(FMCSTAT & FMCSTAT_ADDRDONE))
@ -157,7 +157,7 @@ uint32_t nand_wait_addrdone(void)
return 0; return 0;
} }
uint32_t nand_wait_chip_ready(uint32_t bank) static uint32_t nand_wait_chip_ready(uint32_t bank)
{ {
long timeout = current_tick + HZ / 50; long timeout = current_tick + HZ / 50;
while (!(FMCSTAT & (FMCSTAT_BANK0READY << bank))) while (!(FMCSTAT & (FMCSTAT_BANK0READY << bank)))
@ -166,19 +166,19 @@ uint32_t nand_wait_chip_ready(uint32_t bank)
return 0; return 0;
} }
void nand_set_fmctrl0(uint32_t bank, uint32_t flags) static void nand_set_fmctrl0(uint32_t bank, uint32_t flags)
{ {
FMCTRL0 = (nand_tunk1[bank] << 16) | (nand_twp[bank] << 12) FMCTRL0 = (nand_tunk1[bank] << 16) | (nand_twp[bank] << 12)
| (1 << 11) | 1 | (1 << (bank + 1)) | flags; | (1 << 11) | 1 | (1 << (bank + 1)) | flags;
} }
uint32_t nand_send_cmd(uint32_t cmd) static uint32_t nand_send_cmd(uint32_t cmd)
{ {
FMCMD = cmd; FMCMD = cmd;
return nand_wait_rbbdone(); return nand_wait_rbbdone();
} }
uint32_t nand_send_address(uint32_t page, uint32_t offset) static uint32_t nand_send_address(uint32_t page, uint32_t offset)
{ {
FMANUM = 4; FMANUM = 4;
FMADDR0 = (page << 16) | offset; FMADDR0 = (page << 16) | offset;
@ -197,7 +197,7 @@ uint32_t nand_reset(uint32_t bank)
return 0; return 0;
} }
uint32_t nand_wait_status_ready(uint32_t bank) static uint32_t nand_wait_status_ready(uint32_t bank)
{ {
long timeout = current_tick + HZ / 50; long timeout = current_tick + HZ / 50;
nand_set_fmctrl0(bank, 0); nand_set_fmctrl0(bank, 0);
@ -218,8 +218,8 @@ uint32_t nand_wait_status_ready(uint32_t bank)
return nand_send_cmd(NAND_CMD_READ); return nand_send_cmd(NAND_CMD_READ);
} }
void nand_transfer_data_start(uint32_t bank, uint32_t direction, static void nand_transfer_data_start(uint32_t bank, uint32_t direction,
void* buffer, uint32_t size) void* buffer, uint32_t size)
{ {
nand_set_fmctrl0(bank, FMCTRL0_ENABLEDMA); nand_set_fmctrl0(bank, FMCTRL0_ENABLEDMA);
FMDNUM = size - 1; FMDNUM = size - 1;
@ -236,7 +236,7 @@ void nand_transfer_data_start(uint32_t bank, uint32_t direction,
DMACOM3 = 4; DMACOM3 = 4;
} }
uint32_t nand_transfer_data_collect(uint32_t direction) static uint32_t nand_transfer_data_collect(uint32_t direction)
{ {
long timeout = current_tick + HZ / 50; long timeout = current_tick + HZ / 50;
while ((DMAALLST & DMAALLST_DMABUSY3)) while ((DMAALLST & DMAALLST_DMABUSY3))
@ -248,15 +248,16 @@ uint32_t nand_transfer_data_collect(uint32_t direction)
return 0; return 0;
} }
uint32_t nand_transfer_data(uint32_t bank, uint32_t direction, static uint32_t nand_transfer_data(uint32_t bank, uint32_t direction,
void* buffer, uint32_t size) void* buffer, uint32_t size)
{ {
nand_transfer_data_start(bank, direction, buffer, size); nand_transfer_data_start(bank, direction, buffer, size);
uint32_t rc = nand_transfer_data_collect(direction); uint32_t rc = nand_transfer_data_collect(direction);
return rc; return rc;
} }
void ecc_start(uint32_t size, void* databuffer, void* sparebuffer, uint32_t type) static void ecc_start(uint32_t size, void* databuffer, void* sparebuffer,
uint32_t type)
{ {
mutex_lock(&ecc_mtx); mutex_lock(&ecc_mtx);
ECC_INT_CLR = 1; ECC_INT_CLR = 1;
@ -268,7 +269,7 @@ void ecc_start(uint32_t size, void* databuffer, void* sparebuffer, uint32_t type
ECC_CTRL = type; ECC_CTRL = type;
} }
uint32_t ecc_collect(void) static uint32_t ecc_collect(void)
{ {
long timeout = current_tick + HZ / 50; long timeout = current_tick + HZ / 50;
while (!(SRCPND & INTMSK_ECC)) while (!(SRCPND & INTMSK_ECC))
@ -279,21 +280,21 @@ uint32_t ecc_collect(void)
return ecc_unlock(ECC_RESULT); return ecc_unlock(ECC_RESULT);
} }
uint32_t ecc_decode(uint32_t size, void* databuffer, void* sparebuffer) static uint32_t ecc_decode(uint32_t size, void* databuffer, void* sparebuffer)
{ {
ecc_start(size, databuffer, sparebuffer, ECCCTRL_STARTDECODING); ecc_start(size, databuffer, sparebuffer, ECCCTRL_STARTDECODING);
uint32_t rc = ecc_collect(); uint32_t rc = ecc_collect();
return rc; return rc;
} }
uint32_t ecc_encode(uint32_t size, void* databuffer, void* sparebuffer) static uint32_t ecc_encode(uint32_t size, void* databuffer, void* sparebuffer)
{ {
ecc_start(size, databuffer, sparebuffer, ECCCTRL_STARTENCODING); ecc_start(size, databuffer, sparebuffer, ECCCTRL_STARTENCODING);
ecc_collect(); ecc_collect();
return 0; return 0;
} }
uint32_t nand_check_empty(uint8_t* buffer) static uint32_t nand_check_empty(uint8_t* buffer)
{ {
uint32_t i, count; uint32_t i, count;
count = 0; count = 0;
@ -302,7 +303,7 @@ uint32_t nand_check_empty(uint8_t* buffer)
return 0; return 0;
} }
uint32_t nand_get_chip_type(uint32_t bank) static uint32_t nand_get_chip_type(uint32_t bank)
{ {
mutex_lock(&nand_mtx); mutex_lock(&nand_mtx);
uint32_t result; uint32_t result;
@ -443,8 +444,9 @@ uint32_t nand_read_page(uint32_t bank, uint32_t page, void* databuffer,
return nand_unlock(rc); return nand_unlock(rc);
} }
uint32_t nand_write_page_int(uint32_t bank, uint32_t page, void* databuffer, static uint32_t nand_write_page_int(uint32_t bank, uint32_t page,
void* sparebuffer, uint32_t doecc, uint32_t wait) void* databuffer, void* sparebuffer,
uint32_t doecc, uint32_t wait)
{ {
uint8_t* data = nand_data; uint8_t* data = nand_data;
uint8_t* spare = nand_spare; uint8_t* spare = nand_spare;
@ -674,7 +676,8 @@ uint32_t nand_write_page_collect(uint32_t bank)
return nand_wait_status_ready(bank); return nand_wait_status_ready(bank);
} }
uint32_t nand_block_erase_fast(uint32_t page) #if 0 /* currently unused */
static uint32_t nand_block_erase_fast(uint32_t page)
{ {
uint32_t i, rc = 0; uint32_t i, rc = 0;
mutex_lock(&nand_mtx); mutex_lock(&nand_mtx);
@ -708,6 +711,7 @@ uint32_t nand_block_erase_fast(uint32_t page)
} }
return nand_unlock(rc); return nand_unlock(rc);
} }
#endif
const struct nand_device_info_type* nand_get_device_type(uint32_t bank) const struct nand_device_info_type* nand_get_device_type(uint32_t bank)
{ {

1
firmware/target/arm/s5l8700/ipodnano2g/pmu-nano2g.c
View file

@ -22,6 +22,7 @@
#include "config.h" #include "config.h"
#include "kernel.h" #include "kernel.h"
#include "i2c-s5l8700.h" #include "i2c-s5l8700.h"
#include "pmu-target.h"
static struct mutex pmu_adc_mutex; static struct mutex pmu_adc_mutex;

5
firmware/target/arm/s5l8700/ipodnano2g/power-nano2g.c
View file

@ -23,12 +23,9 @@
#include "inttypes.h" #include "inttypes.h"
#include "s5l8700.h" #include "s5l8700.h"
#include "power.h" #include "power.h"
#include "ftl-target.h"
#include <string.h>
#include "panic.h" #include "panic.h"
#include "pmu-target.h" #include "pmu-target.h"
#include "lcd.h" #include "usb_core.h" /* for usb_charging_maxcurrent_change */
void power_off(void) void power_off(void)
{ {

8
firmware/target/arm/s5l8700/pcm-s5l8700.c
View file

@ -41,10 +41,10 @@
*/ */
static volatile int locked = 0; static volatile int locked = 0;
size_t nextsize; static size_t nextsize;
size_t dblbufsize; static size_t dblbufsize;
int dmamode; static int dmamode;
const unsigned char* dblbuf; static const unsigned char* dblbuf;
/* table of recommended PLL/MCLK dividers for mode 256Fs from the datasheet */ /* table of recommended PLL/MCLK dividers for mode 256Fs from the datasheet */
static const struct div_entry { static const struct div_entry {

8
firmware/target/arm/usb-s3c6400x.c
View file

@ -21,6 +21,8 @@
#include "config.h" #include "config.h"
#include "usb.h" #include "usb.h"
#include "usb-target.h"
#include "usb_drv.h"
#define OTGBASE 0x38800000 #define OTGBASE 0x38800000
#define PHYBASE 0x3C400000 #define PHYBASE 0x3C400000
@ -55,7 +57,7 @@ int usb_drv_port_speed(void)
return (DSTS & 2) == 0 ? 1 : 0; return (DSTS & 2) == 0 ? 1 : 0;
} }
void reset_endpoints(int reinit) static void reset_endpoints(int reinit)
{ {
unsigned int i; unsigned int i;
for (i = 0; i < sizeof(endpoints)/sizeof(struct ep_type); i++) for (i = 0; i < sizeof(endpoints)/sizeof(struct ep_type); i++)
@ -268,7 +270,7 @@ void usb_drv_set_address(int address)
into the USB core, which will then call this dummy function. */ into the USB core, which will then call this dummy function. */
} }
void ep_send(int ep, void *ptr, int length) static void ep_send(int ep, void *ptr, int length)
{ {
endpoints[ep].busy = true; endpoints[ep].busy = true;
endpoints[ep].size = length; endpoints[ep].size = length;
@ -289,7 +291,7 @@ void ep_send(int ep, void *ptr, int length)
DIEPCTL(ep) |= 0x84000000; /* EPx OUT ENABLE CLEARNAK */ DIEPCTL(ep) |= 0x84000000; /* EPx OUT ENABLE CLEARNAK */
} }
void ep_recv(int ep, void *ptr, int length) static void ep_recv(int ep, void *ptr, int length)
{ {
endpoints[ep].busy = true; endpoints[ep].busy = true;
endpoints[ep].size = length; endpoints[ep].size = length;