svn commit: r233979 - projects/nand/sys/dev/nand
Grzegorz Bernacki
gber at FreeBSD.org
Sat Apr 7 05:04:15 UTC 2012
Author: gber
Date: Sat Apr 7 05:04:14 2012
New Revision: 233979
URL: http://svn.freebsd.org/changeset/base/233979
Log:
nand: Various fixes
Obtained from: Semihalf
Supported by: FreeBSD Foundation, Juniper Networks
Modified:
projects/nand/sys/dev/nand/nand_bbt.c
projects/nand/sys/dev/nand/nandsim.c
projects/nand/sys/dev/nand/nandsim.h
projects/nand/sys/dev/nand/nandsim_chip.c
projects/nand/sys/dev/nand/nandsim_chip.h
projects/nand/sys/dev/nand/nandsim_swap.c
projects/nand/sys/dev/nand/nandsim_swap.h
Modified: projects/nand/sys/dev/nand/nand_bbt.c
==============================================================================
--- projects/nand/sys/dev/nand/nand_bbt.c Sat Apr 7 04:55:36 2012 (r233978)
+++ projects/nand/sys/dev/nand/nand_bbt.c Sat Apr 7 05:04:14 2012 (r233979)
@@ -182,8 +182,8 @@ nand_bbt_load_hdr(struct nand_bbt *bbt,
if (primary)
addr = bbt->primary_map;
-
- addr = bbt->secondary_map;
+ else
+ addr = bbt->secondary_map;
return (nand_read_pages_raw(bbt->chip, addr, hdr,
sizeof(struct bbt_header)));
@@ -227,6 +227,7 @@ nand_bbt_prescan(struct nand_bbt *bbt)
{
int32_t i;
uint8_t bad;
+ bool printed_hash = 0;
device_printf(bbt->chip->dev, "No BBT found. Prescan chip...\n");
for (i = 0; i < bbt->chip->chip_geom.blks_per_chip; i++) {
@@ -237,9 +238,15 @@ nand_bbt_prescan(struct nand_bbt *bbt)
device_printf(bbt->chip->dev, "Bad block(%d)\n", i);
bbt->table[i] = 0x0FFFFFFF;
}
- if (!(i%100)) printf("#");
+ if (!(i % 100)) {
+ printf("#");
+ printed_hash = 1;
+ }
}
+ if (printed_hash)
+ printf("\n");
+
return (0);
}
Modified: projects/nand/sys/dev/nand/nandsim.c
==============================================================================
--- projects/nand/sys/dev/nand/nandsim.c Sat Apr 7 04:55:36 2012 (r233978)
+++ projects/nand/sys/dev/nand/nandsim.c Sat Apr 7 05:04:14 2012 (r233979)
@@ -453,7 +453,7 @@ nandsim_inject_error(struct sim_error *e
return (EINVAL);
offset = (page * page_size) + error->column;
- memset(&bs->block_ptr[offset], error->pattern, error->len);
+ memset(&bs->blk_ptr[offset], error->pattern, error->len);
return (0);
}
@@ -479,10 +479,10 @@ nandsim_set_block_state(struct sim_block
if (bs->block_num > blocks)
return (EINVAL);
- chip->blk_wearout[bs->block_num].is_bad = bs->state;
+ chip->blk_state[bs->block_num].is_bad = bs->state;
if (bs->wearout >= 0)
- chip->blk_wearout[bs->block_num].wear_lev = bs->wearout;
+ chip->blk_state[bs->block_num].wear_lev = bs->wearout;
return (0);
}
@@ -508,8 +508,8 @@ nandsim_get_block_state(struct sim_block
if (bs->block_num > blocks)
return (EINVAL);
- bs->state = chip->blk_wearout[bs->block_num].is_bad;
- bs->wearout = chip->blk_wearout[bs->block_num].wear_lev;
+ bs->state = chip->blk_state[bs->block_num].is_bad;
+ bs->wearout = chip->blk_state[bs->block_num].wear_lev;
return (0);
}
@@ -538,7 +538,7 @@ nandsim_dump(struct sim_dump *dump)
if (dump->len > blk_size)
dump->len = blk_size;
- copyout(bs->block_ptr, dump->data, dump->len);
+ copyout(bs->blk_ptr, dump->data, dump->len);
return (0);
}
@@ -569,7 +569,7 @@ nandsim_restore(struct sim_dump *dump)
dump->len = blk_size;
- copyin(dump->data, bs->block_ptr, dump->len);
+ copyin(dump->data, bs->blk_ptr, dump->len);
return (0);
}
Modified: projects/nand/sys/dev/nand/nandsim.h
==============================================================================
--- projects/nand/sys/dev/nand/nandsim.h Sat Apr 7 04:55:36 2012 (r233978)
+++ projects/nand/sys/dev/nand/nandsim.h Sat Apr 7 05:04:14 2012 (r233979)
@@ -35,6 +35,7 @@
#define MAX_SIM_DEV 4
#define MAX_CTRL_CS 4
#define MAX_ECC_BYTES 512
+#define MAX_BAD_BLOCKS 512
#define DEV_MODEL_STR_SIZE 21
#define MAN_STR_SIZE 13
#define FILENAME_SIZE 20
@@ -71,6 +72,7 @@ struct sim_ctrl {
};
#define NANDSIM_CREATE_CTRL _IOW(NANDSIM_BASE, 2, struct sim_ctrl)
#define NANDSIM_DESTROY_CTRL _IOW(NANDSIM_BASE, 3, int)
+
struct sim_chip {
uint8_t num;
uint8_t ctrl_num;
@@ -96,6 +98,7 @@ struct sim_chip {
uint32_t error_ratio;
uint32_t wear_level;
+ uint32_t bad_block_map[MAX_BAD_BLOCKS];
uint8_t is_wp;
};
Modified: projects/nand/sys/dev/nand/nandsim_chip.c
==============================================================================
--- projects/nand/sys/dev/nand/nandsim_chip.c Sat Apr 7 04:55:36 2012 (r233978)
+++ projects/nand/sys/dev/nand/nandsim_chip.c Sat Apr 7 05:04:14 2012 (r233979)
@@ -69,8 +69,9 @@ static void nandsim_start_handler(struct
static void nandsim_callout_eh(void *);
static int nandsim_delay(struct nandsim_chip *, int);
-static int nandsim_blk_wearout_init(struct nandsim_chip *, uint32_t, uint32_t);
-static void nandsim_blk_wearout_destroy(struct nandsim_chip *);
+static int nandsim_bbm_init(struct nandsim_chip *, uint32_t, uint32_t *);
+static int nandsim_blk_state_init(struct nandsim_chip *, uint32_t, uint32_t);
+static void nandsim_blk_state_destroy(struct nandsim_chip *);
static int nandchip_is_block_valid(struct nandsim_chip *, int);
static void nandchip_set_status(struct nandsim_chip *, uint8_t);
@@ -114,6 +115,9 @@ nandsim_chip_init(struct nandsim_softc*
chip->erase_delay = sim_chip->erase_time;
chip->read_delay = sim_chip->read_time;
+ chip_param->t_prog = sim_chip->prog_time;
+ chip_param->t_bers = sim_chip->erase_time;
+ chip_param->t_r = sim_chip->read_time;
bcopy("onfi", &chip_param->signature, 4);
chip_param->manufacturer_id = sim_chip->manufact_id;
@@ -140,44 +144,41 @@ nandsim_chip_init(struct nandsim_softc*
size = chip_param->blocks_per_lun * chip_param->luns;
- error = nandsim_blk_wearout_init(chip, size, sim_chip->wear_level);
+ error = nandsim_blk_state_init(chip, size, sim_chip->wear_level);
if (error) {
mtx_destroy(&chip->ns_lock);
free(chip, M_NANDSIM);
return (NULL);
}
+ error = nandsim_bbm_init(chip, size, sim_chip->bad_block_map);
+ if (error) {
+ mtx_destroy(&chip->ns_lock);
+ nandsim_blk_state_destroy(chip);
+ free(chip, M_NANDSIM);
+ return (NULL);
+ }
+
nandsim_start_handler(chip, poweron_evh);
nand_debug(NDBG_SIM,"Create thread for chip%d [%8p]", chip->chip_num,
chip);
/* Create chip thread */
-#if __FreeBSD_version > 800001
error = kproc_kthread_add(nandsim_loop, chip, &nandsim_proc,
&chip->nandsim_td, RFSTOPPED | RFHIGHPID,
0, "nandsim", "chip");
-#else
- error = kthread_create(nandsim_loop, chip, &chip->nandsim_proc,
- RFSTOPPED | RFHIGHPID, 0, "nandsim");
- chip->nandsim_td = FIRST_THREAD_IN_PROC(chip->nandsim_proc);
-#endif
if (error) {
mtx_destroy(&chip->ns_lock);
- nandsim_blk_wearout_destroy(chip);
+ nandsim_blk_state_destroy(chip);
free(chip, M_NANDSIM);
return (NULL);
}
-#if __FreeBSD_version > 700001
+
thread_lock(chip->nandsim_td);
sched_class(chip->nandsim_td, PRI_REALTIME);
sched_add(chip->nandsim_td, SRQ_BORING);
thread_unlock(chip->nandsim_td);
-#else
- mtx_lock_spin(&sched_lock);
- sched_class(chip->nandsim_td->td_ksegrp, PRI_REALTIME);
- sched_add(chip->nandsim_td, SRQ_BORING);
- mtx_unlock_spin(&sched_lock);
-#endif
+
size = (chip_param->bytes_per_page +
chip_param->spare_bytes_per_page) *
chip_param->pages_per_block;
@@ -195,7 +196,7 @@ nandsim_chip_init(struct nandsim_softc*
}
static int
-nandsim_blk_wearout_init(struct nandsim_chip *chip, uint32_t size,
+nandsim_blk_state_init(struct nandsim_chip *chip, uint32_t size,
uint32_t wear_lev)
{
int i;
@@ -203,28 +204,58 @@ nandsim_blk_wearout_init(struct nandsim_
if (!chip || size == 0)
return (-1);
- chip->blk_wearout = malloc(size * sizeof(struct block_wearout),
+ chip->blk_state = malloc(size * sizeof(struct nandsim_block_state),
M_NANDSIM, M_WAITOK | M_ZERO);
- if (!chip->blk_wearout) {
+ if (!chip->blk_state) {
return (-1);
}
for (i = 0; i < size; i++) {
if (wear_lev)
- chip->blk_wearout[i].wear_lev = wear_lev;
+ chip->blk_state[i].wear_lev = wear_lev;
else
- chip->blk_wearout[i].wear_lev = -1;
+ chip->blk_state[i].wear_lev = -1;
}
return (0);
}
static void
-nandsim_blk_wearout_destroy(struct nandsim_chip *chip)
+nandsim_blk_state_destroy(struct nandsim_chip *chip)
{
- if (chip && chip->blk_wearout)
- free(chip->blk_wearout, M_NANDSIM);
+ if (chip && chip->blk_state)
+ free(chip->blk_state, M_NANDSIM);
+}
+
+static int
+nandsim_bbm_init(struct nandsim_chip *chip, uint32_t size,
+ uint32_t *sim_bbm)
+{
+ uint32_t index;
+ int i;
+
+ if ((chip == NULL) || (size == 0))
+ return (-1);
+
+ if (chip->blk_state == NULL)
+ return (-1);
+
+ if (sim_bbm == NULL)
+ return (0);
+
+ for (i = 0; i < MAX_BAD_BLOCKS; i++) {
+ index = sim_bbm[i];
+
+ if (index == 0xffffffff)
+ break;
+ else if (index > size)
+ return (-1);
+ else
+ chip->blk_state[index].is_bad = 1;
+ }
+
+ return (0);
}
void
@@ -282,15 +313,12 @@ nandsim_loop(void *arg)
NANDSIM_CHIP_UNLOCK(chip);
nandsim_log(chip, NANDSIM_LOG_SM, "destroyed\n");
mtx_destroy(&chip->ns_lock);
- nandsim_blk_wearout_destroy(chip);
+ nandsim_blk_state_destroy(chip);
nandsim_swap_destroy(chip->swap);
free(chip, M_NANDSIM);
nandsim_proc = NULL;
-#if __FreeBSD_version > 800001
+
kthread_exit();
-#else
- kthread_exit(0);
-#endif
}
if (!(chip->flags & NANDSIM_CHIP_FROZEN)) {
@@ -381,10 +409,8 @@ nandsim_delay(struct nandsim_chip *chip,
if (callout_reset(&chip->ns_callout, tm, nandsim_callout_eh, ev))
return (-1);
- chip->read_delay -= MIN(chip->read_delay, 100);
delay.tv_sec = chip->read_delay / 1000000;
delay.tv_usec = chip->read_delay % 1000000;
- delay.tv_usec = chip->read_delay % 1000000;
timevaladd(&chip->delay_tv, &delay);
return (0);
@@ -455,7 +481,7 @@ nandchip_chip_space(struct nandsim_chip
} else
offset = page * (chip->cg.page_size + chip->cg.oob_size);
- nandchip_set_data(chip, &blk_space->block_ptr[offset], size, column);
+ nandchip_set_data(chip, &blk_space->blk_ptr[offset], size, column);
return (0);
}
@@ -497,11 +523,11 @@ static int
nandchip_is_block_valid(struct nandsim_chip *chip, int block_num)
{
- if (!chip || !chip->blk_wearout)
+ if (!chip || !chip->blk_state)
return (0);
- if (chip->blk_wearout[block_num].wear_lev == 0 ||
- chip->blk_wearout[block_num].is_bad)
+ if (chip->blk_state[block_num].wear_lev == 0 ||
+ chip->blk_state[block_num].is_bad)
return (0);
return (1);
@@ -789,8 +815,8 @@ erase_evh(struct nandsim_chip *chip, uin
err = nand_row_to_blkpg(&chip->cg, row, &lun,
&block, &page);
if (!err) {
- if (chip->blk_wearout[block].wear_lev > 0)
- chip->blk_wearout[block].wear_lev--;
+ if (chip->blk_state[block].wear_lev > 0)
+ chip->blk_state[block].wear_lev--;
}
if (chip->erase_delay != 0 &&
Modified: projects/nand/sys/dev/nand/nandsim_chip.h
==============================================================================
--- projects/nand/sys/dev/nand/nandsim_chip.h Sat Apr 7 04:55:36 2012 (r233978)
+++ projects/nand/sys/dev/nand/nandsim_chip.h Sat Apr 7 05:04:14 2012 (r233979)
@@ -76,7 +76,7 @@ struct nandsim_data {
uint32_t size;
};
-struct block_wearout {
+struct nandsim_block_state {
int32_t wear_lev;
uint8_t is_bad;
};
@@ -88,9 +88,7 @@ struct block_wearout {
struct nandsim_chip {
struct nandsim_softc *sc;
struct thread *nandsim_td;
-#if __FreeBSD_version < 800001
- struct proc *nandsim_proc;
-#endif
+
STAILQ_HEAD(, nandsim_ev) nandsim_events;
nandsim_evh_t *ev_handler;
struct mtx ns_lock;
@@ -100,7 +98,7 @@ struct nandsim_chip {
struct nand_id id;
struct onfi_params params;
struct nandsim_data data;
- struct block_wearout *blk_wearout;
+ struct nandsim_block_state *blk_state;
struct chip_swap *swap;
Modified: projects/nand/sys/dev/nand/nandsim_swap.c
==============================================================================
--- projects/nand/sys/dev/nand/nandsim_swap.c Sat Apr 7 04:55:36 2012 (r233978)
+++ projects/nand/sys/dev/nand/nandsim_swap.c Sat Apr 7 05:04:14 2012 (r233979)
@@ -53,8 +53,8 @@ static void swap_file_close(struct chip_
static int swap_file_write(struct chip_swap *, struct block_state *);
static int swap_file_read(struct chip_swap *, struct block_state *);
-#define CHIP_SWAP_CMODE 0600
-#define CHIP_SWAP_BLOCKSPACES 2
+#define CHIP_SWAP_CMODE 0600
+#define CHIP_SWAP_BLOCKSPACES 2
static int
init_block_state(struct chip_swap *swap)
@@ -62,16 +62,11 @@ init_block_state(struct chip_swap *swap)
struct block_state *blk_state;
int i;
- if (!swap)
+ if (swap == NULL)
return (-1);
blk_state = malloc(swap->nof_blks * sizeof(struct block_state),
M_NANDSIM, M_WAITOK | M_ZERO);
- if (!blk_state) {
- nand_debug(NDBG_SIM,"Cannot allocate blk_state structure blks "
- "%d", swap->nof_blks);
- return (-1);
- }
for (i = 0; i < swap->nof_blks; i++)
blk_state[i].offset = 0xffffffff;
@@ -85,7 +80,10 @@ static void
destroy_block_state(struct chip_swap *swap)
{
- if (swap && (swap->blk_state))
+ if (swap == NULL)
+ return;
+
+ if (swap->blk_state != NULL)
free(swap->blk_state, M_NANDSIM);
}
@@ -98,14 +96,8 @@ create_buffers(struct chip_swap *swap)
for (i = 0; i < CHIP_SWAP_BLOCKSPACES; i++) {
block_space = malloc(sizeof(*block_space), M_NANDSIM, M_WAITOK);
- if (!block_space)
- break;
block = malloc(swap->blk_size, M_NANDSIM, M_WAITOK);
- if (!block) {
- free(block_space, M_NANDSIM);
- break;
- }
- block_space->block_ptr = block;
+ block_space->blk_ptr = block;
SLIST_INSERT_HEAD(&swap->free_bs, block_space, free_link);
nand_debug(NDBG_SIM,"created blk_space %p[%p]\n", block_space,
block);
@@ -122,15 +114,15 @@ destroy_buffers(struct chip_swap *swap)
{
struct block_space *blk_space;
- if (!swap)
+ if (swap == NULL)
return;
blk_space = SLIST_FIRST(&swap->free_bs);
while (blk_space) {
SLIST_REMOVE_HEAD(&swap->free_bs, free_link);
nand_debug(NDBG_SIM,"destroyed blk_space %p[%p]\n",
- blk_space, blk_space->block_ptr);
- free(blk_space->block_ptr, M_NANDSIM);
+ blk_space, blk_space->blk_ptr);
+ free(blk_space->blk_ptr, M_NANDSIM);
free(blk_space, M_NANDSIM);
blk_space = SLIST_FIRST(&swap->free_bs);
}
@@ -139,8 +131,8 @@ destroy_buffers(struct chip_swap *swap)
while (blk_space) {
STAILQ_REMOVE_HEAD(&swap->used_bs, used_link);
nand_debug(NDBG_SIM,"destroyed blk_space %p[%p]\n",
- blk_space, blk_space->block_ptr);
- free(blk_space->block_ptr, M_NANDSIM);
+ blk_space, blk_space->blk_ptr);
+ free(blk_space->blk_ptr, M_NANDSIM);
free(blk_space, M_NANDSIM);
blk_space = STAILQ_FIRST(&swap->used_bs);
}
@@ -157,11 +149,7 @@ swap_file_open(struct chip_swap *swap, c
flags = FWRITE | FREAD | O_NOFOLLOW | O_CREAT | O_TRUNC;
-#if __FreeBSD_version > 700001
error = vn_open(&nd, &flags, CHIP_SWAP_CMODE, NULL);
-#else
- error = vn_open(&nd, &flags, CHIP_SWAP_CMODE, -1);
-#endif
if (error) {
nand_debug(NDBG_SIM,"Cannot create swap file %s", swap_file);
NDFREE(&nd, NDF_ONLY_PNBUF);
@@ -173,11 +161,7 @@ swap_file_open(struct chip_swap *swap, c
NDFREE(&nd, NDF_ONLY_PNBUF);
/* We just unlock so we hold a reference */
-#if __FreeBSD_version > 800001
VOP_UNLOCK(nd.ni_vp, 0);
-#else
- VOP_UNLOCK(nd.ni_vp, 0, curthread);
-#endif
VFS_UNLOCK_GIANT(vfslocked);
swap->swap_vp = nd.ni_vp;
@@ -189,11 +173,14 @@ static void
swap_file_close(struct chip_swap *swap)
{
- if (swap && swap->swap_vp) {
- vn_close(swap->swap_vp, FWRITE, swap->swap_cred,
- curthread);
- crfree(swap->swap_cred);
- }
+ if (swap == NULL)
+ return;
+
+ if (swap->swap_vp == NULL)
+ return;
+
+ vn_close(swap->swap_vp, FWRITE, swap->swap_cred, curthread);
+ crfree(swap->swap_cred);
}
static int
@@ -207,7 +194,7 @@ swap_file_write(struct chip_swap *swap,
struct iovec aiov;
int vfslocked;
- if (!swap || !blk_state)
+ if (swap == NULL || blk_state == NULL)
return (-1);
blk_space = blk_state->blk_sp;
@@ -217,12 +204,12 @@ swap_file_write(struct chip_swap *swap,
}
nand_debug(NDBG_SIM,"saving %p[%p] at %x\n",
- blk_space, blk_space->block_ptr, blk_state->offset);
+ blk_space, blk_space->blk_ptr, blk_state->offset);
bzero(&aiov, sizeof(aiov));
bzero(&auio, sizeof(auio));
- aiov.iov_base = blk_space->block_ptr;
+ aiov.iov_base = blk_space->blk_ptr;
aiov.iov_len = swap->blk_size;
td = curthread;
vp = swap->swap_vp;
@@ -237,15 +224,9 @@ swap_file_write(struct chip_swap *swap,
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
vn_start_write(vp, &mp, V_WAIT);
-#if __FreeBSD_version > 800001
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
VOP_WRITE(vp, &auio, IO_UNIT, swap->swap_cred);
VOP_UNLOCK(vp, 0);
-#else
- vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
- VOP_WRITE(vp, &auio, IO_UNIT, swap->swap_cred);
- VOP_UNLOCK(vp, 0, td);
-#endif
vn_finished_write(mp);
VFS_UNLOCK_GIANT(vfslocked);
@@ -262,18 +243,18 @@ swap_file_read(struct chip_swap *swap, s
struct iovec aiov;
int vfslocked;
- if (!swap || !blk_state)
+ if (swap == NULL || blk_state == NULL)
return (-1);
blk_space = blk_state->blk_sp;
nand_debug(NDBG_SIM,"restore %p[%p] at %x\n",
- blk_space, blk_space->block_ptr, blk_state->offset);
+ blk_space, blk_space->blk_ptr, blk_state->offset);
bzero(&aiov, sizeof(aiov));
bzero(&auio, sizeof(auio));
- aiov.iov_base = blk_space->block_ptr;
+ aiov.iov_base = blk_space->blk_ptr;
aiov.iov_len = swap->blk_size;
td = curthread;
vp = swap->swap_vp;
@@ -287,15 +268,9 @@ swap_file_read(struct chip_swap *swap, s
auio.uio_td = td;
vfslocked = VFS_LOCK_GIANT(vp->v_mount);
-#if __FreeBSD_version > 800001
vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
VOP_READ(vp, &auio, 0, swap->swap_cred);
VOP_UNLOCK(vp, 0);
-#else
- vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td);
- VOP_READ(vp, &auio, 0, swap->swap_cred);
- VOP_UNLOCK(vp, 0, td);
-#endif
VFS_UNLOCK_GIANT(vfslocked);
return (0);
@@ -307,14 +282,10 @@ nandsim_swap_init(const char *swap_file,
struct chip_swap *swap;
int err = 0;
- if ((!swap_file) || (nof_blks == 0) || (blk_size == 0))
+ if ((swap_file == NULL) || (nof_blks == 0) || (blk_size == 0))
return (NULL);
swap = malloc(sizeof(*swap), M_NANDSIM, M_WAITOK | M_ZERO);
- if (!swap) {
- nand_debug(NDBG_SIM,"Cannot allocate swap structure");
- return (NULL);
- }
SLIST_INIT(&swap->free_bs);
STAILQ_INIT(&swap->used_bs);
@@ -346,12 +317,13 @@ void
nandsim_swap_destroy(struct chip_swap *swap)
{
- if (swap) {
- destroy_block_state(swap);
- destroy_buffers(swap);
- swap_file_close(swap);
- free(swap, M_NANDSIM);
- }
+ if (swap == NULL)
+ return;
+
+ destroy_block_state(swap);
+ destroy_buffers(swap);
+ swap_file_close(swap);
+ free(swap, M_NANDSIM);
}
struct block_space *
@@ -360,7 +332,7 @@ get_bs(struct chip_swap *swap, uint32_t
struct block_state *blk_state, *old_blk_state = NULL;
struct block_space *blk_space;
- if (!swap || (block >= swap->nof_blks))
+ if (swap == NULL || (block >= swap->nof_blks))
return (NULL);
blk_state = &swap->blk_state[block];
@@ -372,12 +344,14 @@ get_bs(struct chip_swap *swap, uint32_t
blk_space = SLIST_FIRST(&swap->free_bs);
if (blk_space) {
SLIST_REMOVE_HEAD(&swap->free_bs, free_link);
- STAILQ_INSERT_TAIL(&swap->used_bs, blk_space, used_link);
+ STAILQ_INSERT_TAIL(&swap->used_bs, blk_space,
+ used_link);
} else {
blk_space = STAILQ_FIRST(&swap->used_bs);
old_blk_state = blk_space->blk_state;
STAILQ_REMOVE_HEAD(&swap->used_bs, used_link);
- STAILQ_INSERT_TAIL(&swap->used_bs, blk_space, used_link);
+ STAILQ_INSERT_TAIL(&swap->used_bs, blk_space,
+ used_link);
if (old_blk_state->status & BLOCK_DIRTY) {
swap_file_write(swap, old_blk_state);
old_blk_state->status &= ~BLOCK_DIRTY;
@@ -386,10 +360,10 @@ get_bs(struct chip_swap *swap, uint32_t
}
}
- if (!blk_space)
+ if (blk_space == NULL)
return (NULL);
- if (old_blk_state) {
+ if (old_blk_state != NULL) {
old_blk_state->status &= ~BLOCK_ALLOCATED;
old_blk_state->blk_sp = NULL;
}
@@ -401,7 +375,7 @@ get_bs(struct chip_swap *swap, uint32_t
if (blk_state->status & BLOCK_SWAPPED)
swap_file_read(swap, blk_state);
else
- memset(blk_space->block_ptr, 0xff, swap->blk_size);
+ memset(blk_space->blk_ptr, 0xff, swap->blk_size);
blk_state->status |= BLOCK_ALLOCATED;
}
@@ -409,7 +383,7 @@ get_bs(struct chip_swap *swap, uint32_t
blk_state->status |= BLOCK_DIRTY;
nand_debug(NDBG_SIM,"get_bs returned %p[%p] state %x\n", blk_space,
- blk_space->block_ptr, blk_state->status);
+ blk_space->blk_ptr, blk_state->status);
return (blk_space);
}
Modified: projects/nand/sys/dev/nand/nandsim_swap.h
==============================================================================
--- projects/nand/sys/dev/nand/nandsim_swap.h Sat Apr 7 04:55:36 2012 (r233978)
+++ projects/nand/sys/dev/nand/nandsim_swap.h Sat Apr 7 05:04:14 2012 (r233979)
@@ -30,15 +30,15 @@
#define _NANDSIM_SWAP_CHIP_H_
struct block_space {
- SLIST_ENTRY(block_space) free_link;
- STAILQ_ENTRY(block_space) used_link;
- struct block_state *blk_state;
- uint8_t* block_ptr;
+ SLIST_ENTRY(block_space) free_link;
+ STAILQ_ENTRY(block_space) used_link;
+ struct block_state *blk_state;
+ uint8_t *blk_ptr;
};
-#define BLOCK_ALLOCATED 0x1
-#define BLOCK_SWAPPED 0x2
-#define BLOCK_DIRTY 0x4
+#define BLOCK_ALLOCATED 0x1
+#define BLOCK_SWAPPED 0x2
+#define BLOCK_DIRTY 0x4
struct block_state {
struct block_space *blk_sp;
More information about the svn-src-projects
mailing list