/* $NetBSD: nor.c,v 1.7 2021/08/07 16:19:13 thorpej Exp $ */
/*-
* Copyright (c) 2011 Department of Software Engineering,
* University of Szeged, Hungary
* Copyright (c) 2011 Adam Hoka <
[email protected]>
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by the Department of Software Engineering, University of Szeged, Hungary
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/* Common driver for NOR chips implementing the ONFI CFI specification */
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: nor.c,v 1.7 2021/08/07 16:19:13 thorpej Exp $");
#include "locators.h"
#include "opt_nor.h"
#include <sys/param.h>
#include <sys/types.h>
#include <sys/device.h>
#include <sys/kmem.h>
#include <sys/sysctl.h>
#include <sys/atomic.h>
#include <dev/flash/flash.h>
#include <dev/flash/flash_io.h>
#include <dev/nor/nor.h>
static int nor_match(device_t, cfdata_t, void *);
static void nor_attach(device_t, device_t, void *);
static int nor_detach(device_t, int);
static bool nor_shutdown(device_t, int);
static int nor_print(void *, const char *);
static int nor_search(device_t, cfdata_t, const int *, void *);
/* flash interface implementation */
static int nor_flash_isbad(device_t, flash_off_t, bool *);
static int nor_flash_markbad(device_t, flash_off_t);
static int nor_flash_write(device_t, flash_off_t, size_t, size_t *,
const u_char *);
static int nor_flash_read(device_t, flash_off_t, size_t, size_t *, uint8_t *);
static int nor_flash_erase_all(device_t);
static int nor_flash_erase(device_t, struct flash_erase_instruction *);
static int nor_flash_submit(device_t, buf_t *);
/* default functions for driver development */
static void nor_default_select(device_t, bool);
static int nor_default_read_page(device_t, flash_off_t, uint8_t *);
static int nor_default_program_page(device_t, flash_off_t, const uint8_t *);
static int nor_scan_media(device_t, struct nor_chip *);
CFATTACH_DECL_NEW(nor, sizeof(struct nor_softc),
nor_match, nor_attach, nor_detach, NULL);
#ifdef NOR_DEBUG
int nordebug = NOR_DEBUG;
#endif
int nor_cachesync_timeout = 1;
int nor_cachesync_nodenum;
struct flash_interface nor_flash_if = {
.type = FLASH_TYPE_NOR,
.read = nor_flash_read,
.write = nor_flash_write,
.erase = nor_flash_erase,
.block_isbad = nor_flash_isbad,
.block_markbad = nor_flash_markbad,
.submit = nor_flash_submit
};
#ifdef NOR_VERBOSE
const struct nor_manufacturer nor_mfrs[] = {
{ NOR_MFR_AMD, "AMD" },
{ NOR_MFR_FUJITSU, "Fujitsu" },
{ NOR_MFR_RENESAS, "Renesas" },
{ NOR_MFR_STMICRO, "ST Micro" },
{ NOR_MFR_MICRON, "Micron" },
{ NOR_MFR_NATIONAL, "National" },
{ NOR_MFR_TOSHIBA, "Toshiba" },
{ NOR_MFR_HYNIX, "Hynix" },
{ NOR_MFGR_MACRONIX, "Macronix" },
{ NOR_MFR_SAMSUNG, "Samsung" },
{ NOR_MFR_UNKNOWN, "Unknown" }
};
static const char *
nor_midtoname(int id)
{
int i;
for (i = 0; nor_mfrs[i].id != 0; i++) {
if (nor_mfrs[i].id == id)
return nor_mfrs[i].name;
}
KASSERT(nor_mfrs[i].id == 0);
return nor_mfrs[i].name;
}
#endif
/* ARGSUSED */
static int
nor_match(device_t parent, cfdata_t match, void *aux)
{
/* pseudo device, always attaches */
return 1;
}
static void
nor_attach(device_t parent, device_t self, void *aux)
{
struct nor_softc * const sc = device_private(self);
struct nor_attach_args * const naa = aux;
struct nor_chip * const chip = &sc->sc_chip;
sc->sc_dev = self;
sc->sc_controller_dev = parent;
sc->sc_nor_if = naa->naa_nor_if;
aprint_naive("\n");
aprint_normal("\n");
if (nor_scan_media(self, chip))
return;
sc->sc_flash_if = nor_flash_if;
sc->sc_flash_if.erasesize = chip->nc_block_size;
sc->sc_flash_if.page_size = chip->nc_page_size;
sc->sc_flash_if.writesize = chip->nc_page_size;
/* allocate cache */
#ifdef NOTYET
chip->nc_oob_cache = kmem_alloc(chip->nc_spare_size, KM_SLEEP);
#endif
chip->nc_page_cache = kmem_alloc(chip->nc_page_size, KM_SLEEP);
mutex_init(&sc->sc_device_lock, MUTEX_DEFAULT, IPL_NONE);
if (flash_sync_thread_init(&sc->sc_flash_io, self, &sc->sc_flash_if)) {
goto error;
}
if (!pmf_device_register1(sc->sc_dev, NULL, NULL, nor_shutdown))
aprint_error_dev(sc->sc_dev,
"couldn't establish power handler\n");
#ifdef NOR_BBT
nor_bbt_init(self);
nor_bbt_scan(self);
#endif
/*
* Attach all our devices
*/
config_search(self, NULL,
CFARGS(.search = nor_search));
return;
error:
#ifdef NOTET
kmem_free(chip->nc_oob_cache, chip->nc_spare_size);
#endif
kmem_free(chip->nc_page_cache, chip->nc_page_size);
mutex_destroy(&sc->sc_device_lock);
}
static int
nor_search(device_t parent, cfdata_t cf, const int *ldesc, void *aux)
{
struct nor_softc * const sc = device_private(parent);
struct nor_chip * const chip = &sc->sc_chip;
struct flash_attach_args faa;
faa.partinfo.part_offset = cf->cf_loc[FLASHBUSCF_OFFSET];
if (cf->cf_loc[FLASHBUSCF_SIZE] == 0) {
faa.partinfo.part_size =
chip->nc_size - faa.partinfo.part_offset;
} else {
faa.partinfo.part_size = cf->cf_loc[FLASHBUSCF_SIZE];
}
if (cf->cf_loc[FLASHBUSCF_READONLY])
faa.partinfo.part_flags = FLASH_PART_READONLY;
else
faa.partinfo.part_flags = 0;
faa.flash_if = &sc->sc_flash_if;
if (config_probe(parent, cf, &faa)) {
if (config_attach(parent, cf, &faa, nor_print,
CFARGS_NONE) != NULL) {
return 0;
} else {
return 1;
}
}
return 1;
}
static int
nor_detach(device_t self, int flags)
{
struct nor_softc * const sc = device_private(self);
struct nor_chip * const chip = &sc->sc_chip;
int error = 0;
error = config_detach_children(self, flags);
if (error) {
return error;
}
flash_sync_thread_destroy(&sc->sc_flash_io);
#ifdef NOR_BBT
nor_bbt_detach(self);
#endif
#ifdef NOTET
/* free oob cache */
kmem_free(chip->nc_oob_cache, chip->nc_spare_size);
#endif
kmem_free(chip->nc_page_cache, chip->nc_page_size);
mutex_destroy(&sc->sc_device_lock);
pmf_device_deregister(sc->sc_dev);
return error;
}
static int
nor_print(void *aux, const char *pnp)
{
if (pnp != NULL)
aprint_normal("nor at %s\n", pnp);
return UNCONF;
}
/* ask for a nor driver to attach to the controller */
device_t
nor_attach_mi(struct nor_interface * const nor_if, device_t parent)
{
struct nor_attach_args arg;
KASSERT(nor_if != NULL);
if (nor_if->select == NULL)
nor_if->select = &nor_default_select;
if (nor_if->read_page == NULL)
nor_if->read_page = &nor_default_read_page;
if (nor_if->program_page == NULL)
nor_if->program_page = &nor_default_program_page;
arg.naa_nor_if = nor_if;
device_t dev = config_found(parent, &arg, nor_print,
CFARGS(.iattr = "norbus"));
return dev;
}
static void
nor_default_select(device_t self, bool n)
{
/* do nothing */
return;
}
static int
nor_flash_submit(device_t self, buf_t * const bp)
{
struct nor_softc * const sc = device_private(self);
return flash_io_submit(&sc->sc_flash_io, bp);
}
/* default everything to reasonable values, to ease future api changes */
void
nor_init_interface(struct nor_interface * const nor_if)
{
nor_if->select = &nor_default_select;
nor_if->read_1 = NULL;
nor_if->read_2 = NULL;
nor_if->read_4 = NULL;
nor_if->read_buf_1 = NULL;
nor_if->read_buf_2 = NULL;
nor_if->read_buf_4 = NULL;
nor_if->write_1 = NULL;
nor_if->write_2 = NULL;
nor_if->write_4 = NULL;
nor_if->write_buf_1 = NULL;
nor_if->write_buf_2 = NULL;
nor_if->write_buf_4 = NULL;
nor_if->busy = NULL;
}
#ifdef NOTYET
/* handle quirks here */
static void
nor_quirks(device_t self, struct nor_chip * const chip)
{
/* this is an example only! */
switch (chip->nc_manf_id) {
case NOR_MFR_SAMSUNG:
if (chip->nc_dev_id == 0x00) {
/* do something only samsung chips need */
/* or */
/* chip->nc_quirks |= NC_QUIRK_NO_READ_START */
}
}
return;
}
#endif
/**
* scan media to determine the chip's properties
* this function resets the device
*/
static int
nor_scan_media(device_t self, struct nor_chip * const chip)
{
struct nor_softc * const sc = device_private(self);
char pbuf[3][sizeof("XXXX MB")];
KASSERT(sc->sc_nor_if != NULL);
KASSERT(sc->sc_nor_if->scan_media != NULL);
int error = sc->sc_nor_if->scan_media(self, chip);
if (error != 0)
return error;
#ifdef NOR_VERBOSE
aprint_normal_dev(self,
"manufacturer id: 0x%.4x (%s), device id: 0x%.4x\n",
chip->nc_manf_id,
nor_midtoname(chip->nc_manf_id),
chip->nc_dev_id);
#endif
format_bytes(pbuf[0], sizeof(pbuf[0]), chip->nc_page_size);
format_bytes(pbuf[1], sizeof(pbuf[1]), chip->nc_spare_size);
format_bytes(pbuf[2], sizeof(pbuf[2]), chip->nc_block_size);
aprint_normal_dev(self,
"page size: %s, spare size: %s, block size: %s\n",
pbuf[0], pbuf[1], pbuf[2]);
format_bytes(pbuf[0], sizeof(pbuf[0]), chip->nc_size);
aprint_normal_dev(self,
"LUN size: %" PRIu32 " blocks, LUNs: %" PRIu8
", total storage size: %s\n",
chip->nc_lun_blocks, chip->nc_num_luns, pbuf[0]);
#ifdef NOTYET
/* XXX does this apply to nor? */
/*
* calculate badblock marker offset in oob
* we try to be compatible with linux here
*/
if (chip->nc_page_size > 512)
chip->nc_badmarker_offs = 0;
else
chip->nc_badmarker_offs = 5;
#endif
/* Calculate page shift and mask */
chip->nc_page_shift = ffs(chip->nc_page_size) - 1;
chip->nc_page_mask = ~(chip->nc_page_size - 1);
/* same for block */
chip->nc_block_shift = ffs(chip->nc_block_size) - 1;
chip->nc_block_mask = ~(chip->nc_block_size - 1);
#ifdef NOTYET
/* look for quirks here if needed in future */
nor_quirks(self, chip);
#endif
return 0;
}
/* ARGSUSED */
static bool
nor_shutdown(device_t self, int howto)
{
return true;
}
/* implementation of the block device API */
/* read a page, default implementation */
static int
nor_default_read_page(device_t self, flash_off_t offset, uint8_t * const data)
{
struct nor_softc * const sc = device_private(self);
struct nor_chip * const chip = &sc->sc_chip;
/*
* access by specified access_width
* note: #bits == 1 << width
*/
switch(sc->sc_nor_if->access_width) {
case 0:
nor_read_buf_1(self, offset, data, chip->nc_page_size);
break;
case 1:
nor_read_buf_2(self, offset, data, chip->nc_page_size);
break;
case 2:
nor_read_buf_4(self, offset, data, chip->nc_page_size);
break;
#ifdef NOTYET
case 3:
nor_read_buf_8(self, offset, data, chip->nc_page_size);
break;
#endif
default:
panic("%s: bad width %d\n", __func__, sc->sc_nor_if->access_width);
}
#if 0
/* for debugging new drivers */
nor_dump_data("page", data, chip->nc_page_size);
#endif
return 0;
}
/* write a page, default implementation */
static int
nor_default_program_page(device_t self, flash_off_t offset,
const uint8_t * const data)
{
struct nor_softc * const sc = device_private(self);
struct nor_chip * const chip = &sc->sc_chip;
/*
* access by specified width
* #bits == 1 << access_width
*/
switch(sc->sc_nor_if->access_width) {
case 0:
nor_write_buf_1(self, offset, data, chip->nc_page_size);
break;
case 1:
nor_write_buf_2(self, offset, data, chip->nc_page_size);
break;
case 2:
nor_write_buf_4(self, offset, data, chip->nc_page_size);
break;
#ifdef NOTYET
case 3:
nor_write_buf_8(self, offset, data, chip->nc_page_size);
break;
#endif
default:
panic("%s: bad width %d\n", __func__,
sc->sc_nor_if->access_width);
}
#if 0
/* for debugging new drivers */
nor_dump_data("page", data, chip->nc_page_size);
#endif
return 0;
}
/*
* nor_flash_erase_all - erase the entire chip
*
* XXX a good way to brick your system
*/
static int
nor_flash_erase_all(device_t self)
{
struct nor_softc * const sc = device_private(self);
int error;
mutex_enter(&sc->sc_device_lock);
error = nor_erase_all(self);
mutex_exit(&sc->sc_device_lock);
return error;
}
static int
nor_flash_erase(device_t self, struct flash_erase_instruction * const ei)
{
struct nor_softc * const sc = device_private(self);
struct nor_chip * const chip = &sc->sc_chip;
flash_off_t addr;
int error = 0;
if (ei->ei_addr < 0 || ei->ei_len < chip->nc_block_size)
return EINVAL;
if (ei->ei_addr + ei->ei_len > chip->nc_size) {
DPRINTF(("%s: erase address is past the end"
" of the device\n", __func__));
return EINVAL;
}
if ((ei->ei_addr == 0) && (ei->ei_len == chip->nc_size)
&& (sc->sc_nor_if->erase_all != NULL)) {
return nor_flash_erase_all(self);
}
if (ei->ei_addr % chip->nc_block_size != 0) {
aprint_error_dev(self,
"nor_flash_erase: ei_addr (%ju) is not"
" a multiple of block size (%ju)\n",
(uintmax_t)ei->ei_addr,
(uintmax_t)chip->nc_block_size);
return EINVAL;
}
if (ei->ei_len % chip->nc_block_size != 0) {
aprint_error_dev(self,
"nor_flash_erase: ei_len (%ju) is not"
" a multiple of block size (%ju)",
(uintmax_t)ei->ei_len,
(uintmax_t)chip->nc_block_size);
return EINVAL;
}
mutex_enter(&sc->sc_device_lock);
addr = ei->ei_addr;
while (addr < ei->ei_addr + ei->ei_len) {
#ifdef NOTYET
if (nor_isbad(self, addr)) {
aprint_error_dev(self, "bad block encountered\n");
ei->ei_state = FLASH_ERASE_FAILED;
error = EIO;
goto out;
}
#endif
error = nor_erase_block(self, addr);
if (error) {
ei->ei_state = FLASH_ERASE_FAILED;
goto out;
}
addr += chip->nc_block_size;
}
mutex_exit(&sc->sc_device_lock);
ei->ei_state = FLASH_ERASE_DONE;
if (ei->ei_callback != NULL) {
ei->ei_callback(ei);
}
return 0;
out:
mutex_exit(&sc->sc_device_lock);
return error;
}
/*
* handle (page) unaligned write to nor
*/
static int
nor_flash_write_unaligned(device_t self, flash_off_t offset, size_t len,
size_t * const retlen, const uint8_t * const buf)
{
struct nor_softc * const sc = device_private(self);
struct nor_chip * const chip = &sc->sc_chip;
flash_off_t first, last, firstoff;
const uint8_t *bufp;
flash_off_t addr;
size_t left, count;
int error = 0, i;
first = offset & chip->nc_page_mask;
firstoff = offset & ~chip->nc_page_mask;
/* XXX check if this should be len - 1 */
last = (offset + len) & chip->nc_page_mask;
count = last - first + 1;
addr = first;
*retlen = 0;
mutex_enter(&sc->sc_device_lock);
if (count == 1) {
#ifdef NOTYET
if (nor_isbad(self, addr)) {
aprint_error_dev(self,
"nor_flash_write_unaligned: "
"bad block encountered\n");
error = EIO;
goto out;
}
#endif
error = nor_read_page(self, addr, chip->nc_page_cache);
if (error) {
goto out;
}
memcpy(chip->nc_page_cache + firstoff, buf, len);
error = nor_program_page(self, addr, chip->nc_page_cache);
if (error) {
goto out;
}
*retlen = len;
goto out;
}
bufp = buf;
left = len;
for (i = 0; i < count && left != 0; i++) {
#ifdef NOTYET
if (nor_isbad(self, addr)) {
aprint_error_dev(self,
"nor_flash_write_unaligned: "
"bad block encountered\n");
error = EIO;
goto out;
}
#endif
if (i == 0) {
error = nor_read_page(self, addr, chip->nc_page_cache);
if (error) {
goto out;
}
memcpy(chip->nc_page_cache + firstoff,
bufp, chip->nc_page_size - firstoff);
printf("write page: %s: %d\n", __FILE__, __LINE__);
error = nor_program_page(self, addr,
chip->nc_page_cache);
if (error) {
goto out;
}
bufp += chip->nc_page_size - firstoff;
left -= chip->nc_page_size - firstoff;
*retlen += chip->nc_page_size - firstoff;
} else if (i == count - 1) {
error = nor_read_page(self, addr, chip->nc_page_cache);
if (error) {
goto out;
}
memcpy(chip->nc_page_cache, bufp, left);
error = nor_program_page(self, addr,
chip->nc_page_cache);
if (error) {
goto out;
}
*retlen += left;
KASSERT(left < chip->nc_page_size);
} else {
/* XXX debug */
if (left > chip->nc_page_size) {
printf("left: %zu, i: %d, count: %zu\n",
(size_t )left, i, count);
}
KASSERT(left > chip->nc_page_size);
error = nor_program_page(self, addr, bufp);
if (error) {
goto out;
}
bufp += chip->nc_page_size;
left -= chip->nc_page_size;
*retlen += chip->nc_page_size;
}
addr += chip->nc_page_size;
}
KASSERT(*retlen == len);
out:
mutex_exit(&sc->sc_device_lock);
return error;
}
static int
nor_flash_write(device_t self, flash_off_t offset, size_t len,
size_t * const retlen, const uint8_t * const buf)
{
struct nor_softc * const sc = device_private(self);
struct nor_chip * const chip = &sc->sc_chip;
const uint8_t *bufp;
size_t pages, page;
daddr_t addr;
int error = 0;
if ((offset + len) > chip->nc_size) {
DPRINTF(("%s: write (off: 0x%jx, len: %ju),"
" exceeds device size (0x%jx)\n", __func__,
(uintmax_t)offset, (uintmax_t)len,
(uintmax_t)chip->nc_size));
return EINVAL;
}
if (len % chip->nc_page_size != 0 ||
offset % chip->nc_page_size != 0) {
return nor_flash_write_unaligned(self,
offset, len, retlen, buf);
}
pages = len / chip->nc_page_size;
KASSERT(pages != 0);
*retlen = 0;
addr = offset;
bufp = buf;
mutex_enter(&sc->sc_device_lock);
for (page = 0; page < pages; page++) {
#ifdef NOTYET
/* do we need this check here? */
if (nor_isbad(self, addr)) {
aprint_error_dev(self,
"nor_flash_write: bad block encountered\n");
error = EIO;
goto out;
}
#endif
error = nor_program_page(self, addr, bufp);
if (error) {
goto out;
}
addr += chip->nc_page_size;
bufp += chip->nc_page_size;
*retlen += chip->nc_page_size;
}
out:
mutex_exit(&sc->sc_device_lock);
DPRINTF(("%s: retlen: %zu, len: %zu\n", __func__, *retlen, len));
return error;
}
/*
* handle (page) unaligned read from nor
*/
static int
nor_flash_read_unaligned(device_t self, flash_off_t offset, size_t len,
size_t * const retlen, uint8_t * const buf)
{
struct nor_softc * const sc = device_private(self);
struct nor_chip * const chip = &sc->sc_chip;
daddr_t first, last, count, firstoff;
uint8_t *bufp;
daddr_t addr;
size_t left;
int error = 0, i;
first = offset & chip->nc_page_mask;
firstoff = offset & ~chip->nc_page_mask;
last = (offset + len) & chip->nc_page_mask;
count = (last - first) / chip->nc_page_size + 1;
addr = first;
bufp = buf;
left = len;
*retlen = 0;
mutex_enter(&sc->sc_device_lock);
if (count == 1) {
error = nor_read_page(self, addr, chip->nc_page_cache);
if (error) {
goto out;
}
memcpy(bufp, chip->nc_page_cache + firstoff, len);
*retlen = len;
goto out;
}
for (i = 0; i < count && left != 0; i++) {
/* XXX Why use the page cache here ? */
error = nor_read_page(self, addr, chip->nc_page_cache);
if (error) {
goto out;
}
if (i == 0) {
memcpy(bufp, chip->nc_page_cache + firstoff,
chip->nc_page_size - firstoff);
bufp += chip->nc_page_size - firstoff;
left -= chip->nc_page_size - firstoff;
*retlen += chip->nc_page_size - firstoff;
} else if (i == count - 1) {
memcpy(bufp, chip->nc_page_cache, left);
*retlen += left;
KASSERT(left < chip->nc_page_size);
} else {
memcpy(bufp, chip->nc_page_cache, chip->nc_page_size);
bufp += chip->nc_page_size;
left -= chip->nc_page_size;
*retlen += chip->nc_page_size;
}
addr += chip->nc_page_size;
}
KASSERT(*retlen == len);
out:
mutex_exit(&sc->sc_device_lock);
return error;
}
static int
nor_flash_read(device_t self, flash_off_t offset, size_t len,
size_t * const retlen, uint8_t * const buf)
{
struct nor_softc * const sc = device_private(self);
struct nor_chip * const chip = &sc->sc_chip;
uint8_t *bufp;
size_t addr;
size_t i, pages;
int error = 0;
*retlen = 0;
DPRINTF(("%s: off: 0x%jx, len: %zu\n",
__func__, (uintmax_t)offset, len));
if (__predict_false((offset + len) > chip->nc_size)) {
DPRINTF(("%s: read (off: 0x%jx, len: %zu),"
" exceeds device size (%ju)\n", __func__,
(uintmax_t)offset, len, (uintmax_t)chip->nc_size));
return EINVAL;
}
/* Handle unaligned access, shouldnt be needed when using the
* block device, as strategy handles it, so only low level
* accesses will use this path
*/
/* XXX^2 */
#if 0
if (len < chip->nc_page_size)
panic("TODO page size is larger than read size");
#endif
if (len % chip->nc_page_size != 0 ||
offset % chip->nc_page_size != 0) {
return nor_flash_read_unaligned(self,
offset, len, retlen, buf);
}
bufp = buf;
addr = offset;
pages = len / chip->nc_page_size;
mutex_enter(&sc->sc_device_lock);
for (i = 0; i < pages; i++) {
#ifdef NOTYET
/* XXX do we need this check here? */
if (nor_isbad(self, addr)) {
aprint_error_dev(self, "bad block encountered\n");
error = EIO;
goto out;
}
#endif
error = nor_read_page(self, addr, bufp);
if (error)
goto out;
bufp += chip->nc_page_size;
addr += chip->nc_page_size;
*retlen += chip->nc_page_size;
}
out:
mutex_exit(&sc->sc_device_lock);
return error;
}
static int
nor_flash_isbad(device_t self, flash_off_t ofs, bool * const isbad)
{
struct nor_softc * const sc = device_private(self);
struct nor_chip * const chip = &sc->sc_chip;
#ifdef NOTYET
bool result;
#endif
if (ofs > chip->nc_size) {
DPRINTF(("%s: offset 0x%jx is larger than"
" device size (0x%jx)\n", __func__,
(uintmax_t)ofs, (uintmax_t)chip->nc_size));
return EINVAL;
}
if (ofs % chip->nc_block_size != 0) {
DPRINTF(("offset (0x%jx) is not the multiple of block size "
"(%ju)",
(uintmax_t)ofs, (uintmax_t)chip->nc_block_size));
return EINVAL;
}
#ifdef NOTYET
mutex_enter(&sc->sc_device_lock);
result = nor_isbad(self, ofs);
mutex_exit(&sc->sc_device_lock);
*isbad = result;
#else
*isbad = false;
#endif
return 0;
}
static int
nor_flash_markbad(device_t self, flash_off_t ofs)
{
struct nor_softc * const sc = device_private(self);
struct nor_chip * const chip = &sc->sc_chip;
if (ofs > chip->nc_size) {
DPRINTF(("%s: offset 0x%jx is larger than"
" device size (0x%jx)\n", __func__,
ofs, (uintmax_t)chip->nc_size));
return EINVAL;
}
if (ofs % chip->nc_block_size != 0) {
panic("offset (%ju) is not the multiple of block size (%ju)",
(uintmax_t)ofs, (uintmax_t)chip->nc_block_size);
}
/* TODO: implement this */
return 0;
}
static int
sysctl_nor_verify(SYSCTLFN_ARGS)
{
int error, t;
struct sysctlnode node;
node = *rnode;
t = *(int *)rnode->sysctl_data;
node.sysctl_data = &t;
error = sysctl_lookup(SYSCTLFN_CALL(&node));
if (error || newp == NULL)
return error;
if (node.sysctl_num == nor_cachesync_nodenum) {
if (t <= 0 || t > 60)
return EINVAL;
} else {
return EINVAL;
}
*(int *)rnode->sysctl_data = t;
return 0;
}
SYSCTL_SETUP(sysctl_nor, "sysctl nor subtree setup")
{
int rc, nor_root_num;
const struct sysctlnode *node;
if ((rc = sysctl_createv(clog, 0, NULL, &node,
CTLFLAG_PERMANENT, CTLTYPE_NODE, "nor",
SYSCTL_DESCR("NOR driver controls"),
NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) {
goto error;
}
nor_root_num = node->sysctl_num;
if ((rc = sysctl_createv(clog, 0, NULL, &node,
CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
CTLTYPE_INT, "cache_sync_timeout",
SYSCTL_DESCR("NOR write cache sync timeout in seconds"),
sysctl_nor_verify, 0, &nor_cachesync_timeout,
0, CTL_HW, nor_root_num, CTL_CREATE,
CTL_EOL)) != 0) {
goto error;
}
nor_cachesync_nodenum = node->sysctl_num;
return;
error:
aprint_error("%s: sysctl_createv failed (rc = %d)\n", __func__, rc);
}
MODULE(MODULE_CLASS_DRIVER, nor, "flash");
#ifdef _MODULE
#include "ioconf.c"
#endif
static int
nor_modcmd(modcmd_t cmd, void *opaque)
{
switch (cmd) {
case MODULE_CMD_INIT:
#ifdef _MODULE
return config_init_component(cfdriver_ioconf_nor,
cfattach_ioconf_nor, cfdata_ioconf_nor);
#else
return 0;
#endif
case MODULE_CMD_FINI:
#ifdef _MODULE
return config_fini_component(cfdriver_ioconf_nor,
cfattach_ioconf_nor, cfdata_ioconf_nor);
#else
return 0;
#endif
default:
return ENOTTY;
}
}
