From owner-svn-src-projects@FreeBSD.ORG Sat Apr 7 05:04:15 2012 Return-Path: Delivered-To: svn-src-projects@freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [69.147.83.52]) by hub.freebsd.org (Postfix) with ESMTP id 8F44D106564A; Sat, 7 Apr 2012 05:04:15 +0000 (UTC) (envelope-from gber@FreeBSD.org) Received: from svn.freebsd.org (svn.freebsd.org [IPv6:2001:4f8:fff6::2c]) by mx1.freebsd.org (Postfix) with ESMTP id 78F728FC19; Sat, 7 Apr 2012 05:04:15 +0000 (UTC) Received: from svn.freebsd.org (localhost [127.0.0.1]) by svn.freebsd.org (8.14.4/8.14.4) with ESMTP id q3754F15043600; Sat, 7 Apr 2012 05:04:15 GMT (envelope-from gber@svn.freebsd.org) Received: (from gber@localhost) by svn.freebsd.org (8.14.4/8.14.4/Submit) id q3754Fpl043592; Sat, 7 Apr 2012 05:04:15 GMT (envelope-from gber@svn.freebsd.org) Message-Id: <201204070504.q3754Fpl043592@svn.freebsd.org> From: Grzegorz Bernacki Date: Sat, 7 Apr 2012 05:04:15 +0000 (UTC) To: src-committers@freebsd.org, svn-src-projects@freebsd.org X-SVN-Group: projects MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Cc: Subject: svn commit: r233979 - projects/nand/sys/dev/nand X-BeenThere: svn-src-projects@freebsd.org X-Mailman-Version: 2.1.5 Precedence: list List-Id: "SVN commit messages for the src " projects" tree" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 07 Apr 2012 05:04:15 -0000 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;