You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mynewt.apache.org by ad...@apache.org on 2016/06/17 23:39:25 UTC

[40/63] [abbrv] [partial] incubator-mynewt-site git commit: remove untarred files for openocd

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-site/blob/69f466b5/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/at91sam9.c
----------------------------------------------------------------------
diff --git a/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/at91sam9.c b/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/at91sam9.c
deleted file mode 100755
index 3f4e5e2..0000000
--- a/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/at91sam9.c
+++ /dev/null
@@ -1,724 +0,0 @@
-/*
- * Copyright (C) 2009 by Dean Glazeski
- * dnglaze@gmail.com
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the
- * Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <target/arm.h>
-#include <helper/log.h>
-#include "imp.h"
-#include "arm_io.h"
-
-#define AT91C_PIOx_SODR (0x30)	/**< Offset to PIO SODR. */
-#define AT91C_PIOx_CODR (0x34)	/**< Offset to PIO CODR. */
-#define AT91C_PIOx_PDSR (0x3C)	/**< Offset to PIO PDSR. */
-#define AT91C_ECCx_CR (0x00)	/**< Offset to ECC CR. */
-#define AT91C_ECCx_SR (0x08)	/**< Offset to ECC SR. */
-#define AT91C_ECCx_PR (0x0C)	/**< Offset to ECC PR. */
-#define AT91C_ECCx_NPR (0x10)	/**< Offset to ECC NPR. */
-
-/**
- * Representation of a pin on an AT91SAM9 chip.
- */
-struct at91sam9_pin {
-	/** Address of the PIO controller. */
-	uint32_t pioc;
-
-	/** Pin number. */
-	uint32_t num;
-};
-
-/**
- * Private data for the controller that is stored in the NAND device structure.
- */
-struct at91sam9_nand {
-	/** Address of the ECC controller for NAND. */
-	uint32_t ecc;
-
-	/** Address data is written to. */
-	uint32_t data;
-
-	/** Address commands are written to. */
-	uint32_t cmd;
-
-	/** Address addresses are written to. */
-	uint32_t addr;
-
-	/** I/O structure for hosted reads/writes. */
-	struct arm_nand_data io;
-
-	/** Pin representing the ready/~busy line. */
-	struct at91sam9_pin busy;
-
-	/** Pin representing the chip enable. */
-	struct at91sam9_pin ce;
-};
-
-/**
- * Checks if the target is halted and prints an error message if it isn't.
- *
- * @param target Target to be checked.
- * @param label String label for where function is called from.
- * @return True if the target is halted.
- */
-static int at91sam9_halted(struct target *target, const char *label)
-{
-	if (target->state == TARGET_HALTED)
-		return true;
-
-	LOG_ERROR("Target must be halted to use NAND controller (%s)", label);
-	return false;
-}
-
-/**
- * Initialize the AT91SAM9 NAND controller.
- *
- * @param nand NAND device the controller is attached to.
- * @return Success or failure of initialization.
- */
-static int at91sam9_init(struct nand_device *nand)
-{
-	struct target *target = nand->target;
-
-	if (!at91sam9_halted(target, "init"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	return ERROR_OK;
-}
-
-/**
- * Enable NAND device attached to a controller.
- *
- * @param info NAND controller information for controlling NAND device.
- * @return Success or failure of the enabling.
- */
-static int at91sam9_enable(struct nand_device *nand)
-{
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	return target_write_u32(target, info->ce.pioc + AT91C_PIOx_CODR, 1 << info->ce.num);
-}
-
-/**
- * Disable NAND device attached to a controller.
- *
- * @param info NAND controller information for controlling NAND device.
- * @return Success or failure of the disabling.
- */
-static int at91sam9_disable(struct nand_device *nand)
-{
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	return target_write_u32(target, info->ce.pioc + AT91C_PIOx_SODR, 1 << info->ce.num);
-}
-
-/**
- * Send a command to the NAND device.
- *
- * @param nand NAND device to write the command to.
- * @param command Command to be written.
- * @return Success or failure of writing the command.
- */
-static int at91sam9_command(struct nand_device *nand, uint8_t command)
-{
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	if (!at91sam9_halted(target, "command"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	at91sam9_enable(nand);
-
-	return target_write_u8(target, info->cmd, command);
-}
-
-/**
- * Reset the AT91SAM9 NAND controller.
- *
- * @param nand NAND device to be reset.
- * @return Success or failure of reset.
- */
-static int at91sam9_reset(struct nand_device *nand)
-{
-	if (!at91sam9_halted(nand->target, "reset"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	return at91sam9_disable(nand);
-}
-
-/**
- * Send an address to the NAND device attached to an AT91SAM9 NAND controller.
- *
- * @param nand NAND device to send the address to.
- * @param address Address to be sent.
- * @return Success or failure of sending the address.
- */
-static int at91sam9_address(struct nand_device *nand, uint8_t address)
-{
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	if (!at91sam9_halted(nand->target, "address"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	return target_write_u8(target, info->addr, address);
-}
-
-/**
- * Read data directly from the NAND device attached to an AT91SAM9 NAND
- * controller.
- *
- * @param nand NAND device to read from.
- * @param data Pointer to where the data should be put.
- * @return Success or failure of reading the data.
- */
-static int at91sam9_read_data(struct nand_device *nand, void *data)
-{
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	if (!at91sam9_halted(nand->target, "read data"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	return target_read_u8(target, info->data, data);
-}
-
-/**
- * Write data directly to the NAND device attached to an AT91SAM9 NAND
- * controller.
- *
- * @param nand NAND device to be written to.
- * @param data Data to be written.
- * @return Success or failure of the data write.
- */
-static int at91sam9_write_data(struct nand_device *nand, uint16_t data)
-{
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	if (!at91sam9_halted(target, "write data"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	return target_write_u8(target, info->data, data);
-}
-
-/**
- * Determine if the NAND device is ready by looking at the ready/~busy pin.
- *
- * @param nand NAND device to check.
- * @param timeout Time in milliseconds to wait for NAND to be ready.
- * @return True if the NAND is ready in the timeout period.
- */
-static int at91sam9_nand_ready(struct nand_device *nand, int timeout)
-{
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	uint32_t status;
-
-	if (!at91sam9_halted(target, "nand ready"))
-		return 0;
-
-	do {
-		target_read_u32(target, info->busy.pioc + AT91C_PIOx_PDSR, &status);
-
-		if (status & (1 << info->busy.num))
-			return 1;
-
-		alive_sleep(1);
-	} while (timeout-- > 0);
-
-	return 0;
-}
-
-/**
- * Read a block of data from the NAND device attached to an AT91SAM9.  This
- * utilizes the ARM hosted NAND read function.
- *
- * @param nand NAND device to read from.
- * @param data Pointer to where the read data should be placed.
- * @param size Size of the data being read.
- * @return Success or failure of the hosted read.
- */
-static int at91sam9_read_block_data(struct nand_device *nand, uint8_t *data, int size)
-{
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct arm_nand_data *io = &info->io;
-	int status;
-
-	if (!at91sam9_halted(nand->target, "read block"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	io->chunk_size = nand->page_size;
-	status = arm_nandread(io, data, size);
-
-	return status;
-}
-
-/**
- * Write a block of data to a NAND device attached to an AT91SAM9.  This uses
- * the ARM hosted write function to write the data.
- *
- * @param nand NAND device to write to.
- * @param data Data to be written to device.
- * @param size Size of the data being written.
- * @return Success or failure of the hosted write.
- */
-static int at91sam9_write_block_data(struct nand_device *nand, uint8_t *data, int size)
-{
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct arm_nand_data *io = &info->io;
-	int status;
-
-	if (!at91sam9_halted(nand->target, "write block"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	io->chunk_size = nand->page_size;
-	status = arm_nandwrite(io, data, size);
-
-	return status;
-}
-
-/**
- * Initialize the ECC controller on the AT91SAM9.
- *
- * @param target Target to configure ECC on.
- * @param info NAND controller information for where the ECC is.
- * @return Success or failure of initialization.
- */
-static int at91sam9_ecc_init(struct target *target, struct at91sam9_nand *info)
-{
-	if (!info->ecc) {
-		LOG_ERROR("ECC controller address must be set when not reading raw NAND data");
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	/* reset ECC parity registers */
-	return target_write_u32(target, info->ecc + AT91C_ECCx_CR, 1);
-}
-
-/**
- * Initialize an area for the OOB based on whether a user is requesting the OOB
- * data.  This determines the size of the OOB and allocates the space in case
- * the user has not requested the OOB data.
- *
- * @param nand NAND device we are creating an OOB for.
- * @param oob Pointer to the user supplied OOB area.
- * @param size Size of the OOB.
- * @return Pointer to an area to store OOB data.
- */
-static uint8_t *at91sam9_oob_init(struct nand_device *nand, uint8_t *oob, uint32_t *size)
-{
-	if (!oob) {
-		/* user doesn't want OOB, allocate it */
-		if (nand->page_size == 512)
-			*size = 16;
-		else if (nand->page_size == 2048)
-			*size = 64;
-
-		oob = malloc(*size);
-		if (!oob) {
-			LOG_ERROR("Unable to allocate space for OOB");
-			return NULL;
-		}
-
-		memset(oob, 0xFF, *size);
-	}
-
-	return oob;
-}
-
-/**
- * Reads a page from an AT91SAM9 NAND controller and verifies using 1-bit ECC
- * controller on chip.  This makes an attempt to correct any errors that are
- * encountered while reading the page of data.
- *
- * @param nand NAND device to read from
- * @param page Page to be read.
- * @param data Pointer to where data should be read to.
- * @param data_size Size of the data to be read.
- * @param oob Pointer to where OOB data should be read to.
- * @param oob_size Size of the OOB data to be read.
- * @return Success or failure of reading the NAND page.
- */
-static int at91sam9_read_page(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
-{
-	int retval;
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	uint8_t *oob_data;
-	uint32_t status;
-
-	retval = at91sam9_ecc_init(target, info);
-	if (ERROR_OK != retval)
-		return retval;
-
-	retval = nand_page_command(nand, page, NAND_CMD_READ0, !data);
-	if (ERROR_OK != retval)
-		return retval;
-
-	if (data) {
-		retval = nand_read_data_page(nand, data, data_size);
-		if (ERROR_OK != retval)
-			return retval;
-	}
-
-	oob_data = at91sam9_oob_init(nand, oob, &oob_size);
-	retval = nand_read_data_page(nand, oob_data, oob_size);
-	if (ERROR_OK == retval && data) {
-		target_read_u32(target, info->ecc + AT91C_ECCx_SR, &status);
-		if (status & 1) {
-			LOG_ERROR("Error detected!");
-			if (status & 4)
-				LOG_ERROR("Multiple errors encountered; unrecoverable!");
-			else {
-				/* attempt recovery */
-				uint32_t parity;
-
-				target_read_u32(target,
-					info->ecc + AT91C_ECCx_PR,
-					&parity);
-				uint32_t word = (parity & 0x0000FFF0) >> 4;
-				uint32_t bit = parity & 0x0F;
-
-				data[word] ^= (0x1) << bit;
-				LOG_INFO("Data word %d, bit %d corrected.",
-					(unsigned) word,
-					(unsigned) bit);
-			}
-		}
-
-		if (status & 2) {
-			/* we could write back correct ECC data */
-			LOG_ERROR("Error in ECC bytes detected");
-		}
-	}
-
-	if (!oob) {
-		/* if it wasn't asked for, free it */
-		free(oob_data);
-	}
-
-	return retval;
-}
-
-/**
- * Write a page of data including 1-bit ECC information to a NAND device
- * attached to an AT91SAM9 controller.  If there is OOB data to be written,
- * this will ignore the computed ECC from the ECC controller.
- *
- * @param nand NAND device to write to.
- * @param page Page to write.
- * @param data Pointer to data being written.
- * @param data_size Size of the data being written.
- * @param oob Pointer to OOB data being written.
- * @param oob_size Size of the OOB data.
- * @return Success or failure of the page write.
- */
-static int at91sam9_write_page(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
-{
-	struct at91sam9_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	int retval;
-	uint8_t *oob_data = oob;
-	uint32_t parity, nparity;
-
-	retval = at91sam9_ecc_init(target, info);
-	if (ERROR_OK != retval)
-		return retval;
-
-	retval = nand_page_command(nand, page, NAND_CMD_SEQIN, !data);
-	if (ERROR_OK != retval)
-		return retval;
-
-	if (data) {
-		retval = nand_write_data_page(nand, data, data_size);
-		if (ERROR_OK != retval) {
-			LOG_ERROR("Unable to write data to NAND device");
-			return retval;
-		}
-	}
-
-	oob_data = at91sam9_oob_init(nand, oob, &oob_size);
-
-	if (!oob) {
-		/* no OOB given, so read in the ECC parity from the ECC controller */
-		target_read_u32(target, info->ecc + AT91C_ECCx_PR, &parity);
-		target_read_u32(target, info->ecc + AT91C_ECCx_NPR, &nparity);
-
-		oob_data[0] = (uint8_t) parity;
-		oob_data[1] = (uint8_t) (parity >> 8);
-		oob_data[2] = (uint8_t) nparity;
-		oob_data[3] = (uint8_t) (nparity >> 8);
-	}
-
-	retval = nand_write_data_page(nand, oob_data, oob_size);
-
-	if (!oob)
-		free(oob_data);
-
-	if (ERROR_OK != retval) {
-		LOG_ERROR("Unable to write OOB data to NAND");
-		return retval;
-	}
-
-	retval = nand_write_finish(nand);
-
-	return retval;
-}
-
-/**
- * Handle the initial NAND device command for AT91SAM9 controllers.  This
- * initializes much of the controller information struct to be ready for future
- * reads and writes.
- */
-NAND_DEVICE_COMMAND_HANDLER(at91sam9_nand_device_command)
-{
-	unsigned long chip = 0, ecc = 0;
-	struct at91sam9_nand *info = NULL;
-
-	LOG_DEBUG("AT91SAM9 NAND Device Command");
-
-	if (CMD_ARGC < 3 || CMD_ARGC > 4) {
-		LOG_ERROR("parameters: %s target chip_addr", CMD_ARGV[0]);
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	COMMAND_PARSE_NUMBER(ulong, CMD_ARGV[2], chip);
-	if (chip == 0) {
-		LOG_ERROR("invalid NAND chip address: %s", CMD_ARGV[2]);
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	if (CMD_ARGC == 4) {
-		COMMAND_PARSE_NUMBER(ulong, CMD_ARGV[3], ecc);
-		if (ecc == 0) {
-			LOG_ERROR("invalid ECC controller address: %s", CMD_ARGV[3]);
-			return ERROR_NAND_OPERATION_FAILED;
-		}
-	}
-
-	info = calloc(1, sizeof(*info));
-	if (!info) {
-		LOG_ERROR("unable to allocate space for controller private data");
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	info->data = chip;
-	info->cmd = chip | (1 << 22);
-	info->addr = chip | (1 << 21);
-	info->ecc = ecc;
-
-	nand->controller_priv = info;
-	info->io.target = nand->target;
-	info->io.data = info->data;
-	info->io.op = ARM_NAND_NONE;
-
-	return ERROR_OK;
-}
-
-/**
- * Handle the AT91SAM9 CLE command for specifying the address line to use for
- * writing commands to a NAND device.
- */
-COMMAND_HANDLER(handle_at91sam9_cle_command)
-{
-	struct nand_device *nand = NULL;
-	struct at91sam9_nand *info = NULL;
-	unsigned num, address_line;
-
-	if (CMD_ARGC != 2) {
-		command_print(CMD_CTX, "incorrect number of arguments for 'at91sam9 cle' command");
-		return ERROR_OK;
-	}
-
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
-	nand = get_nand_device_by_num(num);
-	if (!nand) {
-		command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
-		return ERROR_OK;
-	}
-
-	info = nand->controller_priv;
-
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], address_line);
-	info->cmd = info->data | (1 << address_line);
-
-	return ERROR_OK;
-}
-
-/**
- * Handle the AT91SAM9 ALE command for specifying the address line to use for
- * writing addresses to the NAND device.
- */
-COMMAND_HANDLER(handle_at91sam9_ale_command)
-{
-	struct nand_device *nand = NULL;
-	struct at91sam9_nand *info = NULL;
-	unsigned num, address_line;
-
-	if (CMD_ARGC != 2)
-		return ERROR_COMMAND_SYNTAX_ERROR;
-
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
-	nand = get_nand_device_by_num(num);
-	if (!nand) {
-		command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
-		return ERROR_COMMAND_ARGUMENT_INVALID;
-	}
-
-	info = nand->controller_priv;
-
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], address_line);
-	info->addr = info->data | (1 << address_line);
-
-	return ERROR_OK;
-}
-
-/**
- * Handle the AT91SAM9 RDY/~BUSY command for specifying the pin that watches the
- * RDY/~BUSY line from the NAND device.
- */
-COMMAND_HANDLER(handle_at91sam9_rdy_busy_command)
-{
-	struct nand_device *nand = NULL;
-	struct at91sam9_nand *info = NULL;
-	unsigned num, base_pioc, pin_num;
-
-	if (CMD_ARGC != 3)
-		return ERROR_COMMAND_SYNTAX_ERROR;
-
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
-	nand = get_nand_device_by_num(num);
-	if (!nand) {
-		command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
-		return ERROR_COMMAND_ARGUMENT_INVALID;
-	}
-
-	info = nand->controller_priv;
-
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], base_pioc);
-	info->busy.pioc = base_pioc;
-
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[2], pin_num);
-	info->busy.num = pin_num;
-
-	return ERROR_OK;
-}
-
-/**
- * Handle the AT91SAM9 CE command for specifying the pin that is used to enable
- * or disable the NAND device.
- */
-COMMAND_HANDLER(handle_at91sam9_ce_command)
-{
-	struct nand_device *nand = NULL;
-	struct at91sam9_nand *info = NULL;
-	unsigned num, base_pioc, pin_num;
-
-	if (CMD_ARGC != 3)
-		return ERROR_COMMAND_SYNTAX_ERROR;
-
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num);
-	nand = get_nand_device_by_num(num);
-	if (!nand) {
-		command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]);
-		return ERROR_COMMAND_ARGUMENT_INVALID;
-	}
-
-	info = nand->controller_priv;
-
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], base_pioc);
-	info->ce.pioc = base_pioc;
-
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[2], pin_num);
-	info->ce.num = pin_num;
-
-	return ERROR_OK;
-}
-
-static const struct command_registration at91sam9_sub_command_handlers[] = {
-	{
-		.name = "cle",
-		.handler = handle_at91sam9_cle_command,
-		.mode = COMMAND_CONFIG,
-		.help = "set command latch enable address line (default is 22)",
-		.usage = "bank_id address_line",
-	},
-	{
-		.name = "ale",
-		.handler = handle_at91sam9_ale_command,
-		.mode = COMMAND_CONFIG,
-		.help = "set address latch enable address line (default is 21)",
-		.usage = "bank_id address_line",
-	},
-	{
-		.name = "rdy_busy",
-		.handler = handle_at91sam9_rdy_busy_command,
-		.mode = COMMAND_CONFIG,
-		.help = "set the GPIO input pin connected to "
-			"the RDY/~BUSY signal (no default)",
-		.usage = "bank_id pio_base_addr pin_num",
-	},
-	{
-		.name = "ce",
-		.handler = handle_at91sam9_ce_command,
-		.mode = COMMAND_CONFIG,
-		.help = "set the GPIO output pin connected to "
-			"the chip enable signal (no default)",
-		.usage = "bank_id pio_base_addr pin_num",
-	},
-	COMMAND_REGISTRATION_DONE
-};
-
-static const struct command_registration at91sam9_command_handler[] = {
-	{
-		.name = "at91sam9",
-		.mode = COMMAND_ANY,
-		.help = "AT91SAM9 NAND flash controller commands",
-		.usage = "",
-		.chain = at91sam9_sub_command_handlers,
-	},
-	COMMAND_REGISTRATION_DONE
-};
-
-/**
- * Structure representing the AT91SAM9 NAND controller.
- */
-struct nand_flash_controller at91sam9_nand_controller = {
-	.name = "at91sam9",
-	.nand_device_command = at91sam9_nand_device_command,
-	.commands = at91sam9_command_handler,
-	.init = at91sam9_init,
-	.command = at91sam9_command,
-	.reset = at91sam9_reset,
-	.address = at91sam9_address,
-	.read_data = at91sam9_read_data,
-	.write_data = at91sam9_write_data,
-	.nand_ready = at91sam9_nand_ready,
-	.read_block_data = at91sam9_read_block_data,
-	.write_block_data = at91sam9_write_block_data,
-	.read_page = at91sam9_read_page,
-	.write_page = at91sam9_write_page,
-};

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-site/blob/69f466b5/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/core.c
----------------------------------------------------------------------
diff --git a/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/core.c b/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/core.c
deleted file mode 100755
index 815c766..0000000
--- a/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/core.c
+++ /dev/null
@@ -1,878 +0,0 @@
-/***************************************************************************
- *   Copyright (C) 2007 by Dominic Rath <Do...@gmx.de>              *
- *   Copyright (C) 2002 Thomas Gleixner <tg...@linutronix.de>               *
- *   Copyright (C) 2009 Zachary T Welch <zw...@superlucidity.net>             *
- *                                                                         *
- *   Partially based on drivers/mtd/nand_ids.c from Linux.                 *
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- *   This program is distributed in the hope that it will be useful,       *
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
- *   GNU General Public License for more details.                          *
- *                                                                         *
- *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
- ***************************************************************************/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "imp.h"
-
-/* configured NAND devices and NAND Flash command handler */
-struct nand_device *nand_devices;
-
-void nand_device_add(struct nand_device *c)
-{
-	if (nand_devices) {
-		struct nand_device *p = nand_devices;
-		while (p && p->next)
-			p = p->next;
-		p->next = c;
-	} else
-		nand_devices = c;
-}
-
-
-/*	Chip ID list
- *
- *	Manufacturer, ID code, pagesize, chipsize in MegaByte, eraseblock size,
- *	options, name
- *
- *	Pagesize; 0, 256, 512
- *	0	get this information from the extended chip ID
- *	256	256 Byte page size
- *	512	512 Byte page size
- */
-static struct nand_info nand_flash_ids[] = {
-	/* Vendor Specific Entries */
-	{ NAND_MFR_SAMSUNG,     0xD5, 8192, 2048, 0x100000, LP_OPTIONS,
-	  "K9GAG08 2GB NAND 3.3V x8 MLC 2b/cell"},
-	{ NAND_MFR_SAMSUNG,     0xD7, 8192, 4096, 0x100000, LP_OPTIONS,
-	  "K9LBG08 4GB NAND 3.3V x8 MLC 2b/cell"},
-
-	/* start "museum" IDs */
-	{ 0x0,                  0x6e, 256, 1, 0x1000, 0,                "NAND 1MiB 5V 8-bit"},
-	{ 0x0,                  0x64, 256, 2, 0x1000, 0,                "NAND 2MiB 5V 8-bit"},
-	{ 0x0,                  0x6b, 512, 4, 0x2000, 0,                "NAND 4MiB 5V 8-bit"},
-	{ 0x0,                  0xe8, 256, 1, 0x1000, 0,                "NAND 1MiB 3.3V 8-bit"},
-	{ 0x0,                  0xec, 256, 1, 0x1000, 0,                "NAND 1MiB 3.3V 8-bit"},
-	{ 0x0,                  0xea, 256, 2, 0x1000, 0,                "NAND 2MiB 3.3V 8-bit"},
-	{ 0x0,                  0xd5, 512, 4, 0x2000, 0,                "NAND 4MiB 3.3V 8-bit"},
-	{ 0x0,                  0xe3, 512, 4, 0x2000, 0,                "NAND 4MiB 3.3V 8-bit"},
-	{ 0x0,                  0xe5, 512, 4, 0x2000, 0,                "NAND 4MiB 3.3V 8-bit"},
-	{ 0x0,                  0xd6, 512, 8, 0x2000, 0,                "NAND 8MiB 3.3V 8-bit"},
-
-	{ 0x0,                  0x39, 512, 8, 0x2000, 0,                "NAND 8MiB 1.8V 8-bit"},
-	{ 0x0,                  0xe6, 512, 8, 0x2000, 0,                "NAND 8MiB 3.3V 8-bit"},
-	{ 0x0,                  0x49, 512, 8, 0x2000, NAND_BUSWIDTH_16, "NAND 8MiB 1.8V 16-bit"},
-	{ 0x0,                  0x59, 512, 8, 0x2000, NAND_BUSWIDTH_16, "NAND 8MiB 3.3V 16-bit"},
-	/* end "museum" IDs */
-
-	{ 0x0,                  0x33, 512, 16, 0x4000, 0,               "NAND 16MiB 1.8V 8-bit"},
-	{ 0x0,                  0x73, 512, 16, 0x4000, 0,               "NAND 16MiB 3.3V 8-bit"},
-	{ 0x0,                  0x43, 512, 16, 0x4000, NAND_BUSWIDTH_16, "NAND 16MiB 1.8V 16-bit"},
-	{ 0x0,                  0x53, 512, 16, 0x4000, NAND_BUSWIDTH_16, "NAND 16MiB 3.3V 16-bit"},
-
-	{ 0x0,                  0x35, 512, 32, 0x4000, 0,               "NAND 32MiB 1.8V 8-bit"},
-	{ 0x0,                  0x75, 512, 32, 0x4000, 0,               "NAND 32MiB 3.3V 8-bit"},
-	{ 0x0,                  0x45, 512, 32, 0x4000, NAND_BUSWIDTH_16, "NAND 32MiB 1.8V 16-bit"},
-	{ 0x0,                  0x55, 512, 32, 0x4000, NAND_BUSWIDTH_16, "NAND 32MiB 3.3V 16-bit"},
-
-	{ 0x0,                  0x36, 512, 64, 0x4000, 0,               "NAND 64MiB 1.8V 8-bit"},
-	{ 0x0,                  0x76, 512, 64, 0x4000, 0,               "NAND 64MiB 3.3V 8-bit"},
-	{ 0x0,                  0x46, 512, 64, 0x4000, NAND_BUSWIDTH_16, "NAND 64MiB 1.8V 16-bit"},
-	{ 0x0,                  0x56, 512, 64, 0x4000, NAND_BUSWIDTH_16, "NAND 64MiB 3.3V 16-bit"},
-
-	{ 0x0,                  0x78, 512, 128, 0x4000, 0,              "NAND 128MiB 1.8V 8-bit"},
-	{ 0x0,                  0x39, 512, 128, 0x4000, 0,              "NAND 128MiB 1.8V 8-bit"},
-	{ 0x0,                  0x79, 512, 128, 0x4000, 0,              "NAND 128MiB 3.3V 8-bit"},
-	{ 0x0,                  0x72, 512, 128, 0x4000, NAND_BUSWIDTH_16, "NAND 128MiB 1.8V 16-bit"},
-	{ 0x0,                  0x49, 512, 128, 0x4000, NAND_BUSWIDTH_16, "NAND 128MiB 1.8V 16-bit"},
-	{ 0x0,                  0x74, 512, 128, 0x4000, NAND_BUSWIDTH_16, "NAND 128MiB 3.3V 16-bit"},
-	{ 0x0,                  0x59, 512, 128, 0x4000, NAND_BUSWIDTH_16, "NAND 128MiB 3.3V 16-bit"},
-
-	{ 0x0,                  0x71, 512, 256, 0x4000, 0,              "NAND 256MiB 3.3V 8-bit"},
-
-	{ 0x0,                  0xA2, 0,  64, 0, LP_OPTIONS,            "NAND 64MiB 1.8V 8-bit"},
-	{ 0x0,                  0xF2, 0,  64, 0, LP_OPTIONS,            "NAND 64MiB 3.3V 8-bit"},
-	{ 0x0,                  0xB2, 0,  64, 0, LP_OPTIONS16,          "NAND 64MiB 1.8V 16-bit"},
-	{ 0x0,                  0xC2, 0,  64, 0, LP_OPTIONS16,          "NAND 64MiB 3.3V 16-bit"},
-
-	{ 0x0,                  0xA1, 0, 128, 0, LP_OPTIONS,            "NAND 128MiB 1.8V 8-bit"},
-	{ 0x0,                  0xF1, 0, 128, 0, LP_OPTIONS,            "NAND 128MiB 3.3V 8-bit"},
-	{ 0x0,                  0xB1, 0, 128, 0, LP_OPTIONS16,          "NAND 128MiB 1.8V 16-bit"},
-	{ 0x0,                  0xC1, 0, 128, 0, LP_OPTIONS16,          "NAND 128MiB 3.3V 16-bit"},
-
-	{ 0x0,                  0xAA, 0, 256, 0, LP_OPTIONS,            "NAND 256MiB 1.8V 8-bit"},
-	{ 0x0,                  0xDA, 0, 256, 0, LP_OPTIONS,            "NAND 256MiB 3.3V 8-bit"},
-	{ 0x0,                  0xBA, 0, 256, 0, LP_OPTIONS16,          "NAND 256MiB 1.8V 16-bit"},
-	{ 0x0,                  0xCA, 0, 256, 0, LP_OPTIONS16,          "NAND 256MiB 3.3V 16-bit"},
-
-	{ 0x0,                  0xAC, 0, 512, 0, LP_OPTIONS,            "NAND 512MiB 1.8V 8-bit"},
-	{ 0x0,                  0xDC, 0, 512, 0, LP_OPTIONS,            "NAND 512MiB 3.3V 8-bit"},
-	{ 0x0,                  0xBC, 0, 512, 0, LP_OPTIONS16,          "NAND 512MiB 1.8V 16-bit"},
-	{ 0x0,                  0xCC, 0, 512, 0, LP_OPTIONS16,          "NAND 512MiB 3.3V 16-bit"},
-
-	{ 0x0,                  0xA3, 0, 1024, 0, LP_OPTIONS,           "NAND 1GiB 1.8V 8-bit"},
-	{ 0x0,                  0xD3, 0, 1024, 0, LP_OPTIONS,           "NAND 1GiB 3.3V 8-bit"},
-	{ 0x0,                  0xB3, 0, 1024, 0, LP_OPTIONS16,         "NAND 1GiB 1.8V 16-bit"},
-	{ 0x0,                  0xC3, 0, 1024, 0, LP_OPTIONS16,         "NAND 1GiB 3.3V 16-bit"},
-
-	{ 0x0,                  0xA5, 0, 2048, 0, LP_OPTIONS,           "NAND 2GiB 1.8V 8-bit"},
-	{ 0x0,                  0xD5, 0, 8192, 0, LP_OPTIONS,           "NAND 2GiB 3.3V 8-bit"},
-	{ 0x0,                  0xB5, 0, 2048, 0, LP_OPTIONS16,         "NAND 2GiB 1.8V 16-bit"},
-	{ 0x0,                  0xC5, 0, 2048, 0, LP_OPTIONS16,         "NAND 2GiB 3.3V 16-bit"},
-
-	{ 0x0,                  0x48, 0, 2048, 0, LP_OPTIONS,           "NAND 2GiB 3.3V 8-bit"},
-
-	{0, 0, 0, 0, 0, 0, NULL}
-};
-
-/* Manufacturer ID list
- */
-static struct nand_manufacturer nand_manuf_ids[] = {
-	{0x0, "unknown"},
-	{NAND_MFR_TOSHIBA, "Toshiba"},
-	{NAND_MFR_SAMSUNG, "Samsung"},
-	{NAND_MFR_FUJITSU, "Fujitsu"},
-	{NAND_MFR_NATIONAL, "National"},
-	{NAND_MFR_RENESAS, "Renesas"},
-	{NAND_MFR_STMICRO, "ST Micro"},
-	{NAND_MFR_HYNIX, "Hynix"},
-	{NAND_MFR_MICRON, "Micron"},
-	{0x0, NULL},
-};
-
-/*
- * Define default oob placement schemes for large and small page devices
- */
-
-#if 0
-static struct nand_ecclayout nand_oob_8 = {
-	.eccbytes = 3,
-	.eccpos = {0, 1, 2},
-	.oobfree = {
-		{.offset = 3,
-		 .length = 2},
-		{.offset = 6,
-		 .length = 2}
-	}
-};
-#endif
-
-/**
- * Returns the flash bank specified by @a name, which matches the
- * driver name and a suffix (option) specify the driver-specific
- * bank number. The suffix consists of the '.' and the driver-specific
- * bank number: when two davinci banks are defined, then 'davinci.1' refers
- * to the second (e.g. DM355EVM).
- */
-static struct nand_device *get_nand_device_by_name(const char *name)
-{
-	unsigned requested = get_flash_name_index(name);
-	unsigned found = 0;
-
-	struct nand_device *nand;
-	for (nand = nand_devices; NULL != nand; nand = nand->next) {
-		if (strcmp(nand->name, name) == 0)
-			return nand;
-		if (!flash_driver_name_matches(nand->controller->name, name))
-			continue;
-		if (++found < requested)
-			continue;
-		return nand;
-	}
-	return NULL;
-}
-
-struct nand_device *get_nand_device_by_num(int num)
-{
-	struct nand_device *p;
-	int i = 0;
-
-	for (p = nand_devices; p; p = p->next) {
-		if (i++ == num)
-			return p;
-	}
-
-	return NULL;
-}
-
-COMMAND_HELPER(nand_command_get_device, unsigned name_index,
-	struct nand_device **nand)
-{
-	const char *str = CMD_ARGV[name_index];
-	*nand = get_nand_device_by_name(str);
-	if (*nand)
-		return ERROR_OK;
-
-	unsigned num;
-	COMMAND_PARSE_NUMBER(uint, str, num);
-	*nand = get_nand_device_by_num(num);
-	if (!*nand) {
-		command_print(CMD_CTX, "NAND flash device '%s' not found", str);
-		return ERROR_COMMAND_SYNTAX_ERROR;
-	}
-	return ERROR_OK;
-}
-
-int nand_build_bbt(struct nand_device *nand, int first, int last)
-{
-	uint32_t page;
-	int i;
-	int pages_per_block = (nand->erase_size / nand->page_size);
-	uint8_t oob[6];
-	int ret;
-
-	if ((first < 0) || (first >= nand->num_blocks))
-		first = 0;
-
-	if ((last >= nand->num_blocks) || (last == -1))
-		last = nand->num_blocks - 1;
-
-	page = first * pages_per_block;
-	for (i = first; i <= last; i++) {
-		ret = nand_read_page(nand, page, NULL, 0, oob, 6);
-		if (ret != ERROR_OK)
-			return ret;
-
-		if (((nand->device->options & NAND_BUSWIDTH_16) && ((oob[0] & oob[1]) != 0xff))
-				|| (((nand->page_size == 512) && (oob[5] != 0xff)) ||
-				((nand->page_size == 2048) && (oob[0] != 0xff)))) {
-			LOG_WARNING("bad block: %i", i);
-			nand->blocks[i].is_bad = 1;
-		} else
-			nand->blocks[i].is_bad = 0;
-
-		page += pages_per_block;
-	}
-
-	return ERROR_OK;
-}
-
-int nand_read_status(struct nand_device *nand, uint8_t *status)
-{
-	if (!nand->device)
-		return ERROR_NAND_DEVICE_NOT_PROBED;
-
-	/* Send read status command */
-	nand->controller->command(nand, NAND_CMD_STATUS);
-
-	alive_sleep(1);
-
-	/* read status */
-	if (nand->device->options & NAND_BUSWIDTH_16) {
-		uint16_t data;
-		nand->controller->read_data(nand, &data);
-		*status = data & 0xff;
-	} else
-		nand->controller->read_data(nand, status);
-
-	return ERROR_OK;
-}
-
-static int nand_poll_ready(struct nand_device *nand, int timeout)
-{
-	uint8_t status;
-
-	nand->controller->command(nand, NAND_CMD_STATUS);
-	do {
-		if (nand->device->options & NAND_BUSWIDTH_16) {
-			uint16_t data;
-			nand->controller->read_data(nand, &data);
-			status = data & 0xff;
-		} else
-			nand->controller->read_data(nand, &status);
-		if (status & NAND_STATUS_READY)
-			break;
-		alive_sleep(1);
-	} while (timeout--);
-
-	return (status & NAND_STATUS_READY) != 0;
-}
-
-int nand_probe(struct nand_device *nand)
-{
-	uint8_t manufacturer_id, device_id;
-	uint8_t id_buff[6];
-	int retval;
-	int i;
-
-	/* clear device data */
-	nand->device = NULL;
-	nand->manufacturer = NULL;
-
-	/* clear device parameters */
-	nand->bus_width = 0;
-	nand->address_cycles = 0;
-	nand->page_size = 0;
-	nand->erase_size = 0;
-
-	/* initialize controller (device parameters are zero, use controller default) */
-	retval = nand->controller->init(nand);
-	if (retval != ERROR_OK) {
-		switch (retval) {
-			case ERROR_NAND_OPERATION_FAILED:
-				LOG_DEBUG("controller initialization failed");
-				return ERROR_NAND_OPERATION_FAILED;
-			case ERROR_NAND_OPERATION_NOT_SUPPORTED:
-				LOG_ERROR(
-				"BUG: controller reported that it doesn't support default parameters");
-				return ERROR_NAND_OPERATION_FAILED;
-			default:
-				LOG_ERROR("BUG: unknown controller initialization failure");
-				return ERROR_NAND_OPERATION_FAILED;
-		}
-	}
-
-	nand->controller->command(nand, NAND_CMD_RESET);
-	nand->controller->reset(nand);
-
-	nand->controller->command(nand, NAND_CMD_READID);
-	nand->controller->address(nand, 0x0);
-
-	if (nand->bus_width == 8) {
-		nand->controller->read_data(nand, &manufacturer_id);
-		nand->controller->read_data(nand, &device_id);
-	} else {
-		uint16_t data_buf;
-		nand->controller->read_data(nand, &data_buf);
-		manufacturer_id = data_buf & 0xff;
-		nand->controller->read_data(nand, &data_buf);
-		device_id = data_buf & 0xff;
-	}
-
-	for (i = 0; nand_flash_ids[i].name; i++) {
-		if (nand_flash_ids[i].id == device_id &&
-				(nand_flash_ids[i].mfr_id == manufacturer_id ||
-				nand_flash_ids[i].mfr_id == 0)) {
-			nand->device = &nand_flash_ids[i];
-			break;
-		}
-	}
-
-	for (i = 0; nand_manuf_ids[i].name; i++) {
-		if (nand_manuf_ids[i].id == manufacturer_id) {
-			nand->manufacturer = &nand_manuf_ids[i];
-			break;
-		}
-	}
-
-	if (!nand->manufacturer) {
-		nand->manufacturer = &nand_manuf_ids[0];
-		nand->manufacturer->id = manufacturer_id;
-	}
-
-	if (!nand->device) {
-		LOG_ERROR(
-			"unknown NAND flash device found, manufacturer id: 0x%2.2x device id: 0x%2.2x",
-			manufacturer_id,
-			device_id);
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	LOG_DEBUG("found %s (%s)", nand->device->name, nand->manufacturer->name);
-
-	/* initialize device parameters */
-
-	/* bus width */
-	if (nand->device->options & NAND_BUSWIDTH_16)
-		nand->bus_width = 16;
-	else
-		nand->bus_width = 8;
-
-	/* Do we need extended device probe information? */
-	if (nand->device->page_size == 0 ||
-			nand->device->erase_size == 0) {
-		if (nand->bus_width == 8) {
-			nand->controller->read_data(nand, id_buff + 3);
-			nand->controller->read_data(nand, id_buff + 4);
-			nand->controller->read_data(nand, id_buff + 5);
-		} else {
-			uint16_t data_buf;
-
-			nand->controller->read_data(nand, &data_buf);
-			id_buff[3] = data_buf;
-
-			nand->controller->read_data(nand, &data_buf);
-			id_buff[4] = data_buf;
-
-			nand->controller->read_data(nand, &data_buf);
-			id_buff[5] = data_buf >> 8;
-		}
-	}
-
-	/* page size */
-	if (nand->device->page_size == 0)
-		nand->page_size = 1 << (10 + (id_buff[4] & 3));
-	else if (nand->device->page_size == 256) {
-		LOG_ERROR("NAND flashes with 256 byte pagesize are not supported");
-		return ERROR_NAND_OPERATION_FAILED;
-	} else
-		nand->page_size = nand->device->page_size;
-
-	/* number of address cycles */
-	if (nand->page_size <= 512) {
-		/* small page devices */
-		if (nand->device->chip_size <= 32)
-			nand->address_cycles = 3;
-		else if (nand->device->chip_size <= 8*1024)
-			nand->address_cycles = 4;
-		else {
-			LOG_ERROR("BUG: small page NAND device with more than 8 GiB encountered");
-			nand->address_cycles = 5;
-		}
-	} else {
-		/* large page devices */
-		if (nand->device->chip_size <= 128)
-			nand->address_cycles = 4;
-		else if (nand->device->chip_size <= 32*1024)
-			nand->address_cycles = 5;
-		else {
-			LOG_ERROR("BUG: large page NAND device with more than 32 GiB encountered");
-			nand->address_cycles = 6;
-		}
-	}
-
-	/* erase size */
-	if (nand->device->erase_size == 0) {
-		switch ((id_buff[4] >> 4) & 3) {
-			case 0:
-				nand->erase_size = 64 << 10;
-				break;
-			case 1:
-				nand->erase_size = 128 << 10;
-				break;
-			case 2:
-				nand->erase_size = 256 << 10;
-				break;
-			case 3:
-				nand->erase_size = 512 << 10;
-				break;
-		}
-	} else
-		nand->erase_size = nand->device->erase_size;
-
-	/* initialize controller, but leave parameters at the controllers default */
-	retval = nand->controller->init(nand);
-	if (retval != ERROR_OK) {
-		switch (retval) {
-			case ERROR_NAND_OPERATION_FAILED:
-				LOG_DEBUG("controller initialization failed");
-				return ERROR_NAND_OPERATION_FAILED;
-			case ERROR_NAND_OPERATION_NOT_SUPPORTED:
-				LOG_ERROR(
-				"controller doesn't support requested parameters (buswidth: %i, address cycles: %i, page size: %i)",
-				nand->bus_width,
-				nand->address_cycles,
-				nand->page_size);
-				return ERROR_NAND_OPERATION_FAILED;
-			default:
-				LOG_ERROR("BUG: unknown controller initialization failure");
-				return ERROR_NAND_OPERATION_FAILED;
-		}
-	}
-
-	nand->num_blocks = (nand->device->chip_size * 1024) / (nand->erase_size / 1024);
-	nand->blocks = malloc(sizeof(struct nand_block) * nand->num_blocks);
-
-	for (i = 0; i < nand->num_blocks; i++) {
-		nand->blocks[i].size = nand->erase_size;
-		nand->blocks[i].offset = i * nand->erase_size;
-		nand->blocks[i].is_erased = -1;
-		nand->blocks[i].is_bad = -1;
-	}
-
-	return ERROR_OK;
-}
-
-int nand_erase(struct nand_device *nand, int first_block, int last_block)
-{
-	int i;
-	uint32_t page;
-	uint8_t status;
-	int retval;
-
-	if (!nand->device)
-		return ERROR_NAND_DEVICE_NOT_PROBED;
-
-	if ((first_block < 0) || (last_block >= nand->num_blocks))
-		return ERROR_COMMAND_SYNTAX_ERROR;
-
-	/* make sure we know if a block is bad before erasing it */
-	for (i = first_block; i <= last_block; i++) {
-		if (nand->blocks[i].is_bad == -1) {
-			nand_build_bbt(nand, i, last_block);
-			break;
-		}
-	}
-
-	for (i = first_block; i <= last_block; i++) {
-		/* Send erase setup command */
-		nand->controller->command(nand, NAND_CMD_ERASE1);
-
-		page = i * (nand->erase_size / nand->page_size);
-
-		/* Send page address */
-		if (nand->page_size <= 512) {
-			/* row */
-			nand->controller->address(nand, page & 0xff);
-			nand->controller->address(nand, (page >> 8) & 0xff);
-
-			/* 3rd cycle only on devices with more than 32 MiB */
-			if (nand->address_cycles >= 4)
-				nand->controller->address(nand, (page >> 16) & 0xff);
-
-			/* 4th cycle only on devices with more than 8 GiB */
-			if (nand->address_cycles >= 5)
-				nand->controller->address(nand, (page >> 24) & 0xff);
-		} else {
-			/* row */
-			nand->controller->address(nand, page & 0xff);
-			nand->controller->address(nand, (page >> 8) & 0xff);
-
-			/* 3rd cycle only on devices with more than 128 MiB */
-			if (nand->address_cycles >= 5)
-				nand->controller->address(nand, (page >> 16) & 0xff);
-		}
-
-		/* Send erase confirm command */
-		nand->controller->command(nand, NAND_CMD_ERASE2);
-
-		retval = nand->controller->nand_ready ?
-			nand->controller->nand_ready(nand, 1000) :
-			nand_poll_ready(nand, 1000);
-		if (!retval) {
-			LOG_ERROR("timeout waiting for NAND flash block erase to complete");
-			return ERROR_NAND_OPERATION_TIMEOUT;
-		}
-
-		retval = nand_read_status(nand, &status);
-		if (retval != ERROR_OK) {
-			LOG_ERROR("couldn't read status");
-			return ERROR_NAND_OPERATION_FAILED;
-		}
-
-		if (status & 0x1) {
-			LOG_ERROR("didn't erase %sblock %d; status: 0x%2.2x",
-				(nand->blocks[i].is_bad == 1)
-				? "bad " : "",
-				i, status);
-			/* continue; other blocks might still be erasable */
-		}
-
-		nand->blocks[i].is_erased = 1;
-	}
-
-	return ERROR_OK;
-}
-
-#if 0
-static int nand_read_plain(struct nand_device *nand,
-	uint32_t address,
-	uint8_t *data,
-	uint32_t data_size)
-{
-	uint8_t *page;
-
-	if (!nand->device)
-		return ERROR_NAND_DEVICE_NOT_PROBED;
-
-	if (address % nand->page_size) {
-		LOG_ERROR("reads need to be page aligned");
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	page = malloc(nand->page_size);
-
-	while (data_size > 0) {
-		uint32_t thisrun_size = (data_size > nand->page_size) ? nand->page_size : data_size;
-		uint32_t page_address;
-
-
-		page_address = address / nand->page_size;
-
-		nand_read_page(nand, page_address, page, nand->page_size, NULL, 0);
-
-		memcpy(data, page, thisrun_size);
-
-		address += thisrun_size;
-		data += thisrun_size;
-		data_size -= thisrun_size;
-	}
-
-	free(page);
-
-	return ERROR_OK;
-}
-
-static int nand_write_plain(struct nand_device *nand,
-	uint32_t address,
-	uint8_t *data,
-	uint32_t data_size)
-{
-	uint8_t *page;
-
-	if (!nand->device)
-		return ERROR_NAND_DEVICE_NOT_PROBED;
-
-	if (address % nand->page_size) {
-		LOG_ERROR("writes need to be page aligned");
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	page = malloc(nand->page_size);
-
-	while (data_size > 0) {
-		uint32_t thisrun_size = (data_size > nand->page_size) ? nand->page_size : data_size;
-		uint32_t page_address;
-
-		memset(page, 0xff, nand->page_size);
-		memcpy(page, data, thisrun_size);
-
-		page_address = address / nand->page_size;
-
-		nand_write_page(nand, page_address, page, nand->page_size, NULL, 0);
-
-		address += thisrun_size;
-		data += thisrun_size;
-		data_size -= thisrun_size;
-	}
-
-	free(page);
-
-	return ERROR_OK;
-}
-#endif
-
-int nand_write_page(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size,
-	uint8_t *oob, uint32_t oob_size)
-{
-	uint32_t block;
-
-	if (!nand->device)
-		return ERROR_NAND_DEVICE_NOT_PROBED;
-
-	block = page / (nand->erase_size / nand->page_size);
-	if (nand->blocks[block].is_erased == 1)
-		nand->blocks[block].is_erased = 0;
-
-	if (nand->use_raw || nand->controller->write_page == NULL)
-		return nand_write_page_raw(nand, page, data, data_size, oob, oob_size);
-	else
-		return nand->controller->write_page(nand, page, data, data_size, oob, oob_size);
-}
-
-int nand_read_page(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size,
-	uint8_t *oob, uint32_t oob_size)
-{
-	if (!nand->device)
-		return ERROR_NAND_DEVICE_NOT_PROBED;
-
-	if (nand->use_raw || nand->controller->read_page == NULL)
-		return nand_read_page_raw(nand, page, data, data_size, oob, oob_size);
-	else
-		return nand->controller->read_page(nand, page, data, data_size, oob, oob_size);
-}
-
-int nand_page_command(struct nand_device *nand, uint32_t page,
-	uint8_t cmd, bool oob_only)
-{
-	if (!nand->device)
-		return ERROR_NAND_DEVICE_NOT_PROBED;
-
-	if (oob_only && NAND_CMD_READ0 == cmd && nand->page_size <= 512)
-		cmd = NAND_CMD_READOOB;
-
-	nand->controller->command(nand, cmd);
-
-	if (nand->page_size <= 512) {
-		/* small page device */
-
-		/* column (always 0, we start at the beginning of a page/OOB area) */
-		nand->controller->address(nand, 0x0);
-
-		/* row */
-		nand->controller->address(nand, page & 0xff);
-		nand->controller->address(nand, (page >> 8) & 0xff);
-
-		/* 4th cycle only on devices with more than 32 MiB */
-		if (nand->address_cycles >= 4)
-			nand->controller->address(nand, (page >> 16) & 0xff);
-
-		/* 5th cycle only on devices with more than 8 GiB */
-		if (nand->address_cycles >= 5)
-			nand->controller->address(nand, (page >> 24) & 0xff);
-	} else {
-		/* large page device */
-
-		/* column (0 when we start at the beginning of a page,
-		 * or 2048 for the beginning of OOB area)
-		 */
-		nand->controller->address(nand, 0x0);
-		if (oob_only)
-			nand->controller->address(nand, 0x8);
-		else
-			nand->controller->address(nand, 0x0);
-
-		/* row */
-		nand->controller->address(nand, page & 0xff);
-		nand->controller->address(nand, (page >> 8) & 0xff);
-
-		/* 5th cycle only on devices with more than 128 MiB */
-		if (nand->address_cycles >= 5)
-			nand->controller->address(nand, (page >> 16) & 0xff);
-
-		/* large page devices need a start command if reading */
-		if (NAND_CMD_READ0 == cmd)
-			nand->controller->command(nand, NAND_CMD_READSTART);
-	}
-
-	if (nand->controller->nand_ready) {
-		if (!nand->controller->nand_ready(nand, 100))
-			return ERROR_NAND_OPERATION_TIMEOUT;
-	} else {
-		/* nand_poll_read() cannot be used during nand read */
-		alive_sleep(1);
-	}
-
-	return ERROR_OK;
-}
-
-int nand_read_data_page(struct nand_device *nand, uint8_t *data, uint32_t size)
-{
-	int retval = ERROR_NAND_NO_BUFFER;
-
-	if (nand->controller->read_block_data != NULL)
-		retval = (nand->controller->read_block_data)(nand, data, size);
-
-	if (ERROR_NAND_NO_BUFFER == retval) {
-		uint32_t i;
-		int incr = (nand->device->options & NAND_BUSWIDTH_16) ? 2 : 1;
-
-		retval = ERROR_OK;
-		for (i = 0; retval == ERROR_OK && i < size; i += incr) {
-			retval = nand->controller->read_data(nand, data);
-			data += incr;
-		}
-	}
-
-	return retval;
-}
-
-int nand_read_page_raw(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size,
-	uint8_t *oob, uint32_t oob_size)
-{
-	int retval;
-
-	retval = nand_page_command(nand, page, NAND_CMD_READ0, !data);
-	if (ERROR_OK != retval)
-		return retval;
-
-	if (data)
-		nand_read_data_page(nand, data, data_size);
-
-	if (oob)
-		nand_read_data_page(nand, oob, oob_size);
-
-	return ERROR_OK;
-}
-
-int nand_write_data_page(struct nand_device *nand, uint8_t *data, uint32_t size)
-{
-	int retval = ERROR_NAND_NO_BUFFER;
-
-	if (nand->controller->write_block_data != NULL)
-		retval = (nand->controller->write_block_data)(nand, data, size);
-
-	if (ERROR_NAND_NO_BUFFER == retval) {
-		bool is16bit = nand->device->options & NAND_BUSWIDTH_16;
-		uint32_t incr = is16bit ? 2 : 1;
-		uint16_t write_data;
-		uint32_t i;
-
-		for (i = 0; i < size; i += incr) {
-			if (is16bit)
-				write_data = le_to_h_u16(data);
-			else
-				write_data = *data;
-
-			retval = nand->controller->write_data(nand, write_data);
-			if (ERROR_OK != retval)
-				break;
-
-			data += incr;
-		}
-	}
-
-	return retval;
-}
-
-int nand_write_finish(struct nand_device *nand)
-{
-	int retval;
-	uint8_t status;
-
-	nand->controller->command(nand, NAND_CMD_PAGEPROG);
-
-	retval = nand->controller->nand_ready ?
-		nand->controller->nand_ready(nand, 100) :
-		nand_poll_ready(nand, 100);
-	if (!retval)
-		return ERROR_NAND_OPERATION_TIMEOUT;
-
-	retval = nand_read_status(nand, &status);
-	if (ERROR_OK != retval) {
-		LOG_ERROR("couldn't read status");
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	if (status & NAND_STATUS_FAIL) {
-		LOG_ERROR("write operation didn't pass, status: 0x%2.2x",
-			status);
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	return ERROR_OK;
-}
-
-int nand_write_page_raw(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size,
-	uint8_t *oob, uint32_t oob_size)
-{
-	int retval;
-
-	retval = nand_page_command(nand, page, NAND_CMD_SEQIN, !data);
-	if (ERROR_OK != retval)
-		return retval;
-
-	if (data) {
-		retval = nand_write_data_page(nand, data, data_size);
-		if (ERROR_OK != retval) {
-			LOG_ERROR("Unable to write data to NAND device");
-			return retval;
-		}
-	}
-
-	if (oob) {
-		retval = nand_write_data_page(nand, oob, oob_size);
-		if (ERROR_OK != retval) {
-			LOG_ERROR("Unable to write OOB data to NAND device");
-			return retval;
-		}
-	}
-
-	return nand_write_finish(nand);
-}

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-site/blob/69f466b5/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/core.h
----------------------------------------------------------------------
diff --git a/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/core.h b/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/core.h
deleted file mode 100755
index 308859b..0000000
--- a/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/core.h
+++ /dev/null
@@ -1,234 +0,0 @@
-/***************************************************************************
- *   Copyright (C) 2007 by Dominic Rath <Do...@gmx.de>              *
- *   Copyright (C) 2009 Zachary T Welch <zw...@superlucidity.net>             *
- *                                                                         *
- *   Partially based on linux/include/linux/mtd/nand.h                     *
- *   Copyright (C) 2000 David Woodhouse <dw...@mvhi.com>                   *
- *   Copyright (C) 2000 Steven J. Hill <sj...@realitydiluted.com>         *
- *   Copyright (C) 2000 Thomas Gleixner <tg...@linutronix.de>               *
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- *   This program is distributed in the hope that it will be useful,       *
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
- *   GNU General Public License for more details.                          *
- *                                                                         *
- *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
- ***************************************************************************/
-
-#ifndef FLASH_NAND_CORE_H
-#define FLASH_NAND_CORE_H
-
-#include <flash/common.h>
-
-/**
- * Representation of a single NAND block in a NAND device.
- */
-struct nand_block {
-	/** Offset to the block. */
-	uint32_t offset;
-
-	/** Size of the block. */
-	uint32_t size;
-
-	/** True if the block has been erased. */
-	int is_erased;
-
-	/** True if the block is bad. */
-	int is_bad;
-};
-
-struct nand_oobfree {
-	int offset;
-	int length;
-};
-
-struct nand_ecclayout {
-	int eccbytes;
-	int eccpos[64];
-	int oobavail;
-	struct nand_oobfree oobfree[2];
-};
-
-struct nand_device {
-	const char *name;
-	struct target *target;
-	struct nand_flash_controller *controller;
-	void *controller_priv;
-	struct nand_manufacturer *manufacturer;
-	struct nand_info *device;
-	int bus_width;
-	int address_cycles;
-	int page_size;
-	int erase_size;
-	int use_raw;
-	int num_blocks;
-	struct nand_block *blocks;
-	struct nand_device *next;
-};
-
-/* NAND Flash Manufacturer ID Codes
- */
-enum {
-	NAND_MFR_TOSHIBA = 0x98,
-	NAND_MFR_SAMSUNG = 0xec,
-	NAND_MFR_FUJITSU = 0x04,
-	NAND_MFR_NATIONAL = 0x8f,
-	NAND_MFR_RENESAS = 0x07,
-	NAND_MFR_STMICRO = 0x20,
-	NAND_MFR_HYNIX = 0xad,
-	NAND_MFR_MICRON = 0x2c,
-};
-
-struct nand_manufacturer {
-	int id;
-	const char *name;
-};
-
-struct nand_info {
-	int mfr_id;
-	int id;
-	int page_size;
-	int chip_size;
-	int erase_size;
-	int options;
-	const char *name;
-};
-
-/* Option constants for bizarre disfunctionality and real features
- */
-enum {
-	/* Chip can not auto increment pages */
-	NAND_NO_AUTOINCR = 0x00000001,
-
-	/* Buswitdh is 16 bit */
-	NAND_BUSWIDTH_16 = 0x00000002,
-
-	/* Device supports partial programming without padding */
-	NAND_NO_PADDING = 0x00000004,
-
-	/* Chip has cache program function */
-	NAND_CACHEPRG = 0x00000008,
-
-	/* Chip has copy back function */
-	NAND_COPYBACK = 0x00000010,
-
-	/* AND Chip which has 4 banks and a confusing page / block
-	 * assignment. See Renesas datasheet for further information */
-	NAND_IS_AND = 0x00000020,
-
-	/* Chip has a array of 4 pages which can be read without
-	 * additional ready /busy waits */
-	NAND_4PAGE_ARRAY = 0x00000040,
-
-	/* Chip requires that BBT is periodically rewritten to prevent
-	 * bits from adjacent blocks from 'leaking' in altering data.
-	 * This happens with the Renesas AG-AND chips, possibly others.  */
-	BBT_AUTO_REFRESH = 0x00000080,
-
-	/* Chip does not require ready check on read. True
-	 * for all large page devices, as they do not support
-	 * autoincrement.*/
-	NAND_NO_READRDY = 0x00000100,
-
-	/* Options valid for Samsung large page devices */
-	NAND_SAMSUNG_LP_OPTIONS = (NAND_NO_PADDING | NAND_CACHEPRG | NAND_COPYBACK),
-
-	/* Options for new chips with large page size. The pagesize and the
-	 * erasesize is determined from the extended id bytes
-	 */
-	LP_OPTIONS = (NAND_SAMSUNG_LP_OPTIONS | NAND_NO_READRDY | NAND_NO_AUTOINCR),
-	LP_OPTIONS16 = (LP_OPTIONS | NAND_BUSWIDTH_16),
-};
-
-enum {
-	/* Standard NAND flash commands */
-	NAND_CMD_READ0 = 0x0,
-	NAND_CMD_READ1 = 0x1,
-	NAND_CMD_RNDOUT = 0x5,
-	NAND_CMD_PAGEPROG = 0x10,
-	NAND_CMD_READOOB = 0x50,
-	NAND_CMD_ERASE1 = 0x60,
-	NAND_CMD_STATUS = 0x70,
-	NAND_CMD_STATUS_MULTI = 0x71,
-	NAND_CMD_SEQIN = 0x80,
-	NAND_CMD_RNDIN = 0x85,
-	NAND_CMD_READID = 0x90,
-	NAND_CMD_ERASE2 = 0xd0,
-	NAND_CMD_RESET = 0xff,
-
-	/* Extended commands for large page devices */
-	NAND_CMD_READSTART = 0x30,
-	NAND_CMD_RNDOUTSTART = 0xE0,
-	NAND_CMD_CACHEDPROG = 0x15,
-};
-
-/* Status bits */
-enum {
-	NAND_STATUS_FAIL = 0x01,
-	NAND_STATUS_FAIL_N1 = 0x02,
-	NAND_STATUS_TRUE_READY = 0x20,
-	NAND_STATUS_READY = 0x40,
-	NAND_STATUS_WP = 0x80,
-};
-
-/* OOB (spare) data formats */
-enum oob_formats {
-	NAND_OOB_NONE = 0x0,	/* no OOB data at all */
-	NAND_OOB_RAW = 0x1,		/* raw OOB data (16 bytes for 512b page sizes, 64 bytes for
-					 *2048b page sizes) */
-	NAND_OOB_ONLY = 0x2,	/* only OOB data */
-	NAND_OOB_SW_ECC = 0x10,	/* when writing, use SW ECC (as opposed to no ECC) */
-	NAND_OOB_HW_ECC = 0x20,	/* when writing, use HW ECC (as opposed to no ECC) */
-	NAND_OOB_SW_ECC_KW = 0x40,	/* when writing, use Marvell's Kirkwood bootrom format */
-	NAND_OOB_JFFS2 = 0x100,	/* when writing, use JFFS2 OOB layout */
-	NAND_OOB_YAFFS2 = 0x100,/* when writing, use YAFFS2 OOB layout */
-};
-
-
-struct nand_device *get_nand_device_by_num(int num);
-
-int nand_page_command(struct nand_device *nand, uint32_t page,
-		      uint8_t cmd, bool oob_only);
-
-int nand_read_data_page(struct nand_device *nand, uint8_t *data, uint32_t size);
-int nand_write_data_page(struct nand_device *nand,
-			 uint8_t *data, uint32_t size);
-
-int nand_write_finish(struct nand_device *nand);
-
-int nand_read_page_raw(struct nand_device *nand, uint32_t page,
-		       uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size);
-int nand_write_page_raw(struct nand_device *nand, uint32_t page,
-			uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size);
-
-int nand_read_status(struct nand_device *nand, uint8_t *status);
-
-int nand_calculate_ecc(struct nand_device *nand,
-		       const uint8_t *dat, uint8_t *ecc_code);
-int nand_calculate_ecc_kw(struct nand_device *nand,
-			  const uint8_t *dat, uint8_t *ecc_code);
-
-int nand_register_commands(struct command_context *cmd_ctx);
-
-/** helper for parsing a nand device command argument string */
-COMMAND_HELPER(nand_command_get_device, unsigned name_index,
-	struct nand_device **nand);
-
-
-#define         ERROR_NAND_DEVICE_INVALID               (-1100)
-#define         ERROR_NAND_OPERATION_FAILED             (-1101)
-#define         ERROR_NAND_OPERATION_TIMEOUT    (-1102)
-#define         ERROR_NAND_OPERATION_NOT_SUPPORTED      (-1103)
-#define         ERROR_NAND_DEVICE_NOT_PROBED    (-1104)
-#define         ERROR_NAND_ERROR_CORRECTION_FAILED      (-1105)
-#define         ERROR_NAND_NO_BUFFER                    (-1106)
-
-#endif	/* FLASH_NAND_CORE_H */

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-site/blob/69f466b5/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/davinci.c
----------------------------------------------------------------------
diff --git a/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/davinci.c b/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/davinci.c
deleted file mode 100755
index c88046d..0000000
--- a/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/davinci.c
+++ /dev/null
@@ -1,795 +0,0 @@
-/***************************************************************************
- *   Copyright (C) 2009 by David Brownell                                  *
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- *   This program is distributed in the hope that it will be useful,       *
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
- *   GNU General Public License for more details.                          *
- *                                                                         *
- *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
- ***************************************************************************/
-
-/*
- * DaVinci family NAND controller support for OpenOCD.
- *
- * This driver uses hardware ECC (1-bit or 4-bit) unless
- * the chip is accessed in "raw" mode.
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "imp.h"
-#include "arm_io.h"
-#include <target/target.h>
-
-enum ecc {
-	HWECC1,		/* all controllers support 1-bit ECC */
-	HWECC4,		/* newer chips also have 4-bit ECC hardware */
-	HWECC4_INFIX,	/* avoid this layout, except maybe for boot code */
-};
-
-struct davinci_nand {
-	uint8_t chipsel;		/* chipselect 0..3 == CS2..CS5 */
-	uint8_t eccmode;
-
-	/* Async EMIF controller base */
-	uint32_t aemif;
-
-	/* NAND chip addresses */
-	uint32_t data;				/* without CLE or ALE */
-	uint32_t cmd;				/* with CLE */
-	uint32_t addr;				/* with ALE */
-
-	/* write acceleration */
-	struct arm_nand_data io;
-
-	/* page i/o for the relevant flavor of hardware ECC */
-	int (*read_page)(struct nand_device *nand, uint32_t page,
-			 uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size);
-	int (*write_page)(struct nand_device *nand, uint32_t page,
-			  uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size);
-};
-
-#define NANDFCR         0x60		/* flash control register */
-#define NANDFSR         0x64		/* flash status register */
-#define NANDFECC        0x70		/* 1-bit ECC data, CS0, 1st of 4 */
-#define NAND4BITECCLOAD 0xbc		/* 4-bit ECC, load saved values */
-#define NAND4BITECC     0xc0		/* 4-bit ECC data, 1st of 4 */
-#define NANDERRADDR     0xd0		/* 4-bit ECC err addr, 1st of 2 */
-#define NANDERRVAL      0xd8		/* 4-bit ECC err value, 1st of 2 */
-
-static int halted(struct target *target, const char *label)
-{
-	if (target->state == TARGET_HALTED)
-		return true;
-
-	LOG_ERROR("Target must be halted to use NAND controller (%s)", label);
-	return false;
-}
-
-static int davinci_init(struct nand_device *nand)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	uint32_t nandfcr;
-
-	if (!halted(target, "init"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	/* We require something else to have configured AEMIF to talk
-	 * to NAND chip in this range (including timings and width).
-	 */
-	target_read_u32(target, info->aemif + NANDFCR, &nandfcr);
-	if (!(nandfcr & (1 << info->chipsel))) {
-		LOG_ERROR("chip address %08" PRIx32 " not NAND-enabled?", info->data);
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	/* REVISIT verify:  AxCR must be in 8-bit mode, since that's all we
-	 * tested.  16 bit support should work too; but not with 4-bit ECC.
-	 */
-
-	return ERROR_OK;
-}
-
-static int davinci_reset(struct nand_device *nand)
-{
-	return ERROR_OK;
-}
-
-static int davinci_nand_ready(struct nand_device *nand, int timeout)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	uint32_t nandfsr;
-
-	/* NOTE: return code is zero/error, else success; not ERROR_* */
-
-	if (!halted(target, "ready"))
-		return 0;
-
-	do {
-		target_read_u32(target, info->aemif + NANDFSR, &nandfsr);
-
-		if (nandfsr & 0x01)
-			return 1;
-
-		alive_sleep(1);
-	} while (timeout-- > 0);
-
-	return 0;
-}
-
-static int davinci_command(struct nand_device *nand, uint8_t command)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	if (!halted(target, "command"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	target_write_u8(target, info->cmd, command);
-	return ERROR_OK;
-}
-
-static int davinci_address(struct nand_device *nand, uint8_t address)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	if (!halted(target, "address"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	target_write_u8(target, info->addr, address);
-	return ERROR_OK;
-}
-
-static int davinci_write_data(struct nand_device *nand, uint16_t data)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	if (!halted(target, "write_data"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	target_write_u8(target, info->data, data);
-	return ERROR_OK;
-}
-
-static int davinci_read_data(struct nand_device *nand, void *data)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	if (!halted(target, "read_data"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	target_read_u8(target, info->data, data);
-	return ERROR_OK;
-}
-
-/* REVISIT a bit of native code should let block reads be MUCH faster */
-
-static int davinci_read_block_data(struct nand_device *nand,
-	uint8_t *data, int data_size)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	uint32_t nfdata = info->data;
-	uint32_t tmp;
-
-	if (!halted(target, "read_block"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	while (data_size >= 4) {
-		target_read_u32(target, nfdata, &tmp);
-
-		data[0] = tmp;
-		data[1] = tmp >> 8;
-		data[2] = tmp >> 16;
-		data[3] = tmp >> 24;
-
-		data_size -= 4;
-		data += 4;
-	}
-
-	while (data_size > 0) {
-		target_read_u8(target, nfdata, data);
-
-		data_size -= 1;
-		data += 1;
-	}
-
-	return ERROR_OK;
-}
-
-static int davinci_write_block_data(struct nand_device *nand,
-	uint8_t *data, int data_size)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	uint32_t nfdata = info->data;
-	uint32_t tmp;
-	int status;
-
-	if (!halted(target, "write_block"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	/* try the fast way first */
-	status = arm_nandwrite(&info->io, data, data_size);
-	if (status != ERROR_NAND_NO_BUFFER)
-		return status;
-
-	/* else do it slowly */
-	while (data_size >= 4) {
-		tmp = le_to_h_u32(data);
-		target_write_u32(target, nfdata, tmp);
-
-		data_size -= 4;
-		data += 4;
-	}
-
-	while (data_size > 0) {
-		target_write_u8(target, nfdata, *data);
-
-		data_size -= 1;
-		data += 1;
-	}
-
-	return ERROR_OK;
-}
-
-static int davinci_write_page(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	uint8_t *ooballoc = NULL;
-	int status;
-
-	if (!nand->device)
-		return ERROR_NAND_DEVICE_NOT_PROBED;
-	if (!halted(nand->target, "write_page"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	/* Always write both data and OOB ... we are not "raw" I/O! */
-	if (!data) {
-		LOG_ERROR("Missing NAND data; try 'nand raw_access enable'");
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	/* If we're not given OOB, write 0xff where we don't write ECC codes. */
-	switch (nand->page_size) {
-		case 512:
-			oob_size = 16;
-			break;
-		case 2048:
-			oob_size = 64;
-			break;
-		case 4096:
-			oob_size = 128;
-			break;
-		default:
-			return ERROR_NAND_OPERATION_FAILED;
-	}
-	if (!oob) {
-		ooballoc = malloc(oob_size);
-		if (!ooballoc)
-			return ERROR_NAND_OPERATION_FAILED;
-		oob = ooballoc;
-		memset(oob, 0x0ff, oob_size);
-	}
-
-	/* REVISIT avoid wasting SRAM:  unless nand->use_raw is set,
-	 * use 512 byte chunks.  Read side support will often want
-	 * to include oob_size ...
-	 */
-	info->io.chunk_size = nand->page_size;
-
-	status = info->write_page(nand, page, data, data_size, oob, oob_size);
-	free(ooballoc);
-	return status;
-}
-
-static int davinci_read_page(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
-{
-	struct davinci_nand *info = nand->controller_priv;
-
-	if (!nand->device)
-		return ERROR_NAND_DEVICE_NOT_PROBED;
-	if (!halted(nand->target, "read_page"))
-		return ERROR_NAND_OPERATION_FAILED;
-
-	return info->read_page(nand, page, data, data_size, oob, oob_size);
-}
-
-static void davinci_write_pagecmd(struct nand_device *nand, uint8_t cmd, uint32_t page)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	int page3 = nand->address_cycles - (nand->page_size == 512);
-
-	/* write command ({page,otp}x{read,program} */
-	target_write_u8(target, info->cmd, cmd);
-
-	/* column address (beginning-of-page) */
-	target_write_u8(target, info->addr, 0);
-	if (nand->page_size > 512)
-		target_write_u8(target, info->addr, 0);
-
-	/* page address */
-	target_write_u8(target, info->addr, page);
-	target_write_u8(target, info->addr, page >> 8);
-	if (page3)
-		target_write_u8(target, info->addr, page >> 16);
-	if (page3 == 2)
-		target_write_u8(target, info->addr, page >> 24);
-}
-
-static int davinci_seek_column(struct nand_device *nand, uint16_t column)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-
-	/* Random read, we must have issued a page read already */
-	target_write_u8(target, info->cmd, NAND_CMD_RNDOUT);
-
-	target_write_u8(target, info->addr, column);
-
-	if (nand->page_size > 512) {
-		target_write_u8(target, info->addr, column >> 8);
-		target_write_u8(target, info->cmd, NAND_CMD_RNDOUTSTART);
-	}
-
-	if (!davinci_nand_ready(nand, 100))
-		return ERROR_NAND_OPERATION_TIMEOUT;
-
-	return ERROR_OK;
-}
-
-static int davinci_writepage_tail(struct nand_device *nand,
-	uint8_t *oob, uint32_t oob_size)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	uint8_t status;
-
-	if (oob_size)
-		davinci_write_block_data(nand, oob, oob_size);
-
-	/* non-cachemode page program */
-	target_write_u8(target, info->cmd, NAND_CMD_PAGEPROG);
-
-	if (!davinci_nand_ready(nand, 100))
-		return ERROR_NAND_OPERATION_TIMEOUT;
-
-	if (nand_read_status(nand, &status) != ERROR_OK) {
-		LOG_ERROR("couldn't read status");
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	if (status & NAND_STATUS_FAIL) {
-		LOG_ERROR("write operation failed, status: 0x%02x", status);
-		return ERROR_NAND_OPERATION_FAILED;
-	}
-
-	return ERROR_OK;
-}
-
-/*
- * All DaVinci family chips support 1-bit ECC on a per-chipselect basis.
- */
-static int davinci_write_page_ecc1(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
-{
-	unsigned oob_offset;
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	const uint32_t fcr_addr = info->aemif + NANDFCR;
-	const uint32_t ecc1_addr = info->aemif + NANDFECC + (4 * info->chipsel);
-	uint32_t fcr, ecc1;
-
-	/* Write contiguous ECC bytes starting at specified offset.
-	 * NOTE: Linux reserves twice as many bytes as we need; and
-	 * for 16-bit OOB, those extra bytes are discontiguous.
-	 */
-	switch (nand->page_size) {
-		case 512:
-			oob_offset = 0;
-			break;
-		case 2048:
-			oob_offset = 40;
-			break;
-		default:
-			oob_offset = 80;
-			break;
-	}
-
-	davinci_write_pagecmd(nand, NAND_CMD_SEQIN, page);
-
-	/* scrub any old ECC state */
-	target_read_u32(target, ecc1_addr, &ecc1);
-
-	target_read_u32(target, fcr_addr, &fcr);
-	fcr |= 1 << (8 + info->chipsel);
-
-	do {
-		/* set "start csX 1bit ecc" bit */
-		target_write_u32(target, fcr_addr, fcr);
-
-		/* write 512 bytes */
-		davinci_write_block_data(nand, data, 512);
-		data += 512;
-		data_size -= 512;
-
-		/* read the ecc, pack to 3 bytes, and invert so the ecc
-		 * in an erased block is correct
-		 */
-		target_read_u32(target, ecc1_addr, &ecc1);
-		ecc1 = (ecc1 & 0x0fff) | ((ecc1 & 0x0fff0000) >> 4);
-		ecc1 = ~ecc1;
-
-		/* save correct ECC code into oob data */
-		oob[oob_offset++] = (uint8_t)(ecc1);
-		oob[oob_offset++] = (uint8_t)(ecc1 >> 8);
-		oob[oob_offset++] = (uint8_t)(ecc1 >> 16);
-
-	} while (data_size);
-
-	/* write OOB into spare area */
-	return davinci_writepage_tail(nand, oob, oob_size);
-}
-
-/*
- * Preferred "new style" ECC layout for use with 4-bit ECC.  This somewhat
- * slows down large page reads done with error correction (since the OOB
- * is read first, so its ECC data can be used incrementally), but the
- * manufacturer bad block markers are safe.  Contrast:  old "infix" style.
- */
-static int davinci_write_page_ecc4(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
-{
-	static const uint8_t ecc512[] = {
-		0, 1, 2, 3, 4,	/* 5== mfr badblock */
-		6, 7, /* 8..12 for BBT or JFFS2 */ 13, 14, 15,
-	};
-	static const uint8_t ecc2048[] = {
-		24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
-		34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
-		44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
-		54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
-	};
-	static const uint8_t ecc4096[] = {
-		48,  49,  50,  51,  52,  53,  54,  55,  56,  57,
-		58,  59,  60,  61,  62,  63,  64,  65,  66,  67,
-		68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
-		78,  79,  80,  81,  82,  83,  84,  85,  86,  87,
-		88,  89,  90,  91,  92,  93,  94,  95,  96,  97,
-		98,  99, 100, 101, 102, 103, 104, 105, 106, 107,
-		108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
-		118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
-	};
-
-	struct davinci_nand *info = nand->controller_priv;
-	const uint8_t *l;
-	struct target *target = nand->target;
-	const uint32_t fcr_addr = info->aemif + NANDFCR;
-	const uint32_t ecc4_addr = info->aemif + NAND4BITECC;
-	uint32_t fcr, ecc4;
-
-	/* Use the same ECC layout Linux uses.  For small page chips
-	 * it's a bit cramped.
-	 *
-	 * NOTE:  at this writing, 4KB pages have issues in Linux
-	 * because they need more than 64 bytes of ECC data, which
-	 * the standard ECC logic can't handle.
-	 */
-	switch (nand->page_size) {
-		case 512:
-			l = ecc512;
-			break;
-		case 2048:
-			l = ecc2048;
-			break;
-		default:
-			l = ecc4096;
-			break;
-	}
-
-	davinci_write_pagecmd(nand, NAND_CMD_SEQIN, page);
-
-	/* scrub any old ECC state */
-	target_read_u32(target, info->aemif + NANDERRVAL, &ecc4);
-
-	target_read_u32(target, fcr_addr, &fcr);
-	fcr &= ~(0x03 << 4);
-	fcr |= (1 << 12) | (info->chipsel << 4);
-
-	do {
-		uint32_t raw_ecc[4], *p;
-		int i;
-
-		/* start 4bit ecc on csX */
-		target_write_u32(target, fcr_addr, fcr);
-
-		/* write 512 bytes */
-		davinci_write_block_data(nand, data, 512);
-		data += 512;
-		data_size -= 512;
-
-		/* read the ecc, then save it into 10 bytes in the oob */
-		for (i = 0; i < 4; i++) {
-			target_read_u32(target, ecc4_addr + 4 * i, &raw_ecc[i]);
-			raw_ecc[i] &= 0x03ff03ff;
-		}
-		for (i = 0, p = raw_ecc; i < 2; i++, p += 2) {
-			oob[*l++] = p[0]        & 0xff;
-			oob[*l++] = ((p[0] >>  8) & 0x03) | ((p[0] >> 14) & 0xfc);
-			oob[*l++] = ((p[0] >> 22) & 0x0f) | ((p[1] <<  4) & 0xf0);
-			oob[*l++] = ((p[1] >>  4) & 0x3f) | ((p[1] >> 10) & 0xc0);
-			oob[*l++] = (p[1] >> 18) & 0xff;
-		}
-
-	} while (data_size);
-
-	/* write OOB into spare area */
-	return davinci_writepage_tail(nand, oob, oob_size);
-}
-
-/*
- * "Infix" OOB ... like Linux ECC_HW_SYNDROME.  Avoided because it trashes
- * manufacturer bad block markers, except on small page chips.  Once you
- * write to a page using this scheme, you need specialized code to update
- * it (code which ignores now-invalid bad block markers).
- *
- * This is needed *only* to support older firmware.  Older ROM Boot Loaders
- * need it to read their second stage loader (UBL) into SRAM, but from then
- * on the whole system can use the cleaner non-infix layouts.  Systems with
- * older second stage loaders (ABL/U-Boot, etc) or other system software
- * (MVL 4.x/5.x kernels, filesystems, etc) may need it more generally.
- */
-static int davinci_write_page_ecc4infix(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
-{
-	struct davinci_nand *info = nand->controller_priv;
-	struct target *target = nand->target;
-	const uint32_t fcr_addr = info->aemif + NANDFCR;
-	const uint32_t ecc4_addr = info->aemif + NAND4BITECC;
-	uint32_t fcr, ecc4;
-
-	davinci_write_pagecmd(nand, NAND_CMD_SEQIN, page);
-
-	/* scrub any old ECC state */
-	target_read_u32(target, info->aemif + NANDERRVAL, &ecc4);
-
-	target_read_u32(target, fcr_addr, &fcr);
-	fcr &= ~(0x03 << 4);
-	fcr |= (1 << 12) | (info->chipsel << 4);
-
-	do {
-		uint32_t raw_ecc[4], *p;
-		uint8_t *l;
-		int i;
-
-		/* start 4bit ecc on csX */
-		target_write_u32(target, fcr_addr, fcr);
-
-		/* write 512 bytes */
-		davinci_write_block_data(nand, data, 512);
-		data += 512;
-		data_size -= 512;
-
-		/* read the ecc */
-		for (i = 0; i < 4; i++) {
-			target_read_u32(target, ecc4_addr + 4 * i, &raw_ecc[i]);
-			raw_ecc[i] &= 0x03ff03ff;
-		}
-
-		/* skip 6 bytes of prepad, then pack 10 packed ecc bytes */
-		for (i = 0, l = oob + 6, p = raw_ecc; i < 2; i++, p += 2) {
-			*l++ = p[0]        & 0xff;
-			*l++ = ((p[0] >>  8) & 0x03) | ((p[0] >> 14) & 0xfc);
-			*l++ = ((p[0] >> 22) & 0x0f) | ((p[1] <<  4) & 0xf0);
-			*l++ = ((p[1] >>  4) & 0x3f) | ((p[1] >> 10) & 0xc0);
-			*l++ = (p[1] >> 18) & 0xff;
-		}
-
-		/* write this "out-of-band" data -- infix */
-		davinci_write_block_data(nand, oob, 16);
-		oob += 16;
-		oob_size -= 16;
-
-	} while (data_size);
-
-	/* the last data and OOB writes included the spare area */
-	return davinci_writepage_tail(nand, NULL, 0);
-}
-
-static int davinci_read_page_ecc4infix(struct nand_device *nand, uint32_t page,
-	uint8_t *data, uint32_t data_size, uint8_t *oob, uint32_t oob_size)
-{
-	int read_size;
-	int want_col, at_col;
-	int ret;
-
-	davinci_write_pagecmd(nand, NAND_CMD_READ0, page);
-
-	/* large page devices need a start command */
-	if (nand->page_size > 512)
-		davinci_command(nand, NAND_CMD_READSTART);
-
-	if (!davinci_nand_ready(nand, 100))
-		return ERROR_NAND_OPERATION_TIMEOUT;
-
-	/* NOTE:  not bothering to compute and use ECC data for now */
-
-	want_col = 0;
-	at_col = 0;
-	while ((data && data_size) || (oob && oob_size)) {
-
-		if (data && data_size) {
-			if (want_col != at_col) {
-				/* Reads are slow, so seek past them when we can */
-				ret  = davinci_seek_column(nand, want_col);
-				if (ret != ERROR_OK)
-					return ret;
-				at_col = want_col;
-			}
-			/* read 512 bytes or data_size, whichever is smaller*/
-			read_size = data_size > 512 ? 512 : data_size;
-			davinci_read_block_data(nand, data, read_size);
-			data += read_size;
-			data_size -= read_size;
-			at_col += read_size;
-		}
-		want_col += 512;
-
-		if (oob && oob_size) {
-			if (want_col != at_col) {
-				ret  = davinci_seek_column(nand, want_col);
-				if (ret != ERROR_OK)
-					return ret;
-				at_col = want_col;
-			}
-			/* read this "out-of-band" data -- infix */
-			read_size = oob_size > 16 ? 16 : oob_size;
-			davinci_read_block_data(nand, oob, read_size);
-			oob += read_size;
-			oob_size -= read_size;
-			at_col += read_size;
-		}
-		want_col += 16;
-	}
-	return ERROR_OK;
-}
-
-NAND_DEVICE_COMMAND_HANDLER(davinci_nand_device_command)
-{
-	struct davinci_nand *info;
-	unsigned long chip, aemif;
-	enum ecc eccmode;
-	int chipsel;
-
-	/* arguments:
-	 *  - "davinci"
-	 *  - target
-	 *  - nand chip address
-	 *  - ecc mode
-	 *  - aemif address
-	 * Plus someday, optionally, ALE and CLE masks.
-	 */
-	if (CMD_ARGC < 5)
-		return ERROR_COMMAND_SYNTAX_ERROR;
-
-	COMMAND_PARSE_NUMBER(ulong, CMD_ARGV[2], chip);
-	if (chip == 0) {
-		LOG_ERROR("Invalid NAND chip address %s", CMD_ARGV[2]);
-		goto fail;
-	}
-
-	if (strcmp(CMD_ARGV[3], "hwecc1") == 0)
-		eccmode = HWECC1;
-	else if (strcmp(CMD_ARGV[3], "hwecc4") == 0)
-		eccmode = HWECC4;
-	else if (strcmp(CMD_ARGV[3], "hwecc4_infix") == 0)
-		eccmode = HWECC4_INFIX;
-	else {
-		LOG_ERROR("Invalid ecc mode %s", CMD_ARGV[3]);
-		goto fail;
-	}
-
-	COMMAND_PARSE_NUMBER(ulong, CMD_ARGV[4], aemif);
-	if (aemif == 0) {
-		LOG_ERROR("Invalid AEMIF controller address %s", CMD_ARGV[4]);
-		goto fail;
-	}
-
-	/* REVISIT what we'd *like* to do is look up valid ranges using
-	 * target-specific declarations, and not even need to pass the
-	 * AEMIF controller address.
-	 */
-	if (aemif == 0x01e00000			/* dm6446, dm357 */
-			|| aemif == 0x01e10000		/* dm335, dm355 */
-			|| aemif == 0x01d10000		/* dm365 */
-		) {
-		if (chip < 0x02000000 || chip >= 0x0a000000) {
-			LOG_ERROR("NAND address %08lx out of range?", chip);
-			goto fail;
-		}
-		chipsel = (chip - 0x02000000) >> 25;
-	} else {
-		LOG_ERROR("unrecognized AEMIF controller address %08lx", aemif);
-		goto fail;
-	}
-
-	info = calloc(1, sizeof *info);
-	if (info == NULL)
-		goto fail;
-
-	info->eccmode = eccmode;
-	info->chipsel = chipsel;
-	info->aemif = aemif;
-	info->data = chip;
-	info->cmd = chip | 0x10;
-	info->addr = chip | 0x08;
-
-	nand->controller_priv = info;
-
-	info->io.target = nand->target;
-	info->io.data = info->data;
-	info->io.op = ARM_NAND_NONE;
-
-	/* NOTE:  for now we don't do any error correction on read.
-	 * Nothing else in OpenOCD currently corrects read errors,
-	 * and in any case it's *writing* that we care most about.
-	 */
-	info->read_page = nand_read_page_raw;
-
-	switch (eccmode) {
-		case HWECC1:
-			/* ECC_HW, 1-bit corrections, 3 bytes ECC per 512 data bytes */
-			info->write_page = davinci_write_page_ecc1;
-			break;
-		case HWECC4:
-			/* ECC_HW, 4-bit corrections, 10 bytes ECC per 512 data bytes */
-			info->write_page = davinci_write_page_ecc4;
-			break;
-		case HWECC4_INFIX:
-			/* Same 4-bit ECC HW, with problematic page/ecc layout */
-			info->read_page = davinci_read_page_ecc4infix;
-			info->write_page = davinci_write_page_ecc4infix;
-			break;
-	}
-
-	return ERROR_OK;
-
-fail:
-	return ERROR_NAND_OPERATION_FAILED;
-}
-
-struct nand_flash_controller davinci_nand_controller = {
-	.name                   = "davinci",
-	.usage                  = "chip_addr hwecc_mode aemif_addr",
-	.nand_device_command    = davinci_nand_device_command,
-	.init                   = davinci_init,
-	.reset                  = davinci_reset,
-	.command                = davinci_command,
-	.address                = davinci_address,
-	.write_data             = davinci_write_data,
-	.read_data              = davinci_read_data,
-	.write_page             = davinci_write_page,
-	.read_page              = davinci_read_page,
-	.write_block_data       = davinci_write_block_data,
-	.read_block_data        = davinci_read_block_data,
-	.nand_ready             = davinci_nand_ready,
-};

http://git-wip-us.apache.org/repos/asf/incubator-mynewt-site/blob/69f466b5/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/driver.c
----------------------------------------------------------------------
diff --git a/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/driver.c b/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/driver.c
deleted file mode 100755
index 49e13c0..0000000
--- a/docs/os/tutorials/downloads/openocd-code-89bf96ffe6ac66c80407af8383b9d5adc0dc35f4/src/flash/nand/driver.c
+++ /dev/null
@@ -1,84 +0,0 @@
-/***************************************************************************
- *   Copyright (C) 2005 by Dominic Rath <Do...@gmx.de>              *
- *   Copyright (C) 2007,2008 �yvind Harboe <oy...@zylin.com>       *
- *   Copyright (C) 2008 by Spencer Oliver <sp...@spen-soft.co.uk>           *
- *   Copyright (C) 2009 Zachary T Welch <zw...@superlucidity.net>             *
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- *   This program is distributed in the hope that it will be useful,       *
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
- *   GNU General Public License for more details.                          *
- *                                                                         *
- *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
- ***************************************************************************/
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include "core.h"
-#include "driver.h"
-
-/* NAND flash controller
- */
-extern struct nand_flash_controller nonce_nand_controller;
-extern struct nand_flash_controller davinci_nand_controller;
-extern struct nand_flash_controller lpc3180_nand_controller;
-extern struct nand_flash_controller lpc32xx_nand_controller;
-extern struct nand_flash_controller orion_nand_controller;
-extern struct nand_flash_controller s3c2410_nand_controller;
-extern struct nand_flash_controller s3c2412_nand_controller;
-extern struct nand_flash_controller s3c2440_nand_controller;
-extern struct nand_flash_controller s3c2443_nand_controller;
-extern struct nand_flash_controller s3c6400_nand_controller;
-extern struct nand_flash_controller mxc_nand_flash_controller;
-extern struct nand_flash_controller imx31_nand_flash_controller;
-extern struct nand_flash_controller at91sam9_nand_controller;
-extern struct nand_flash_controller nuc910_nand_controller;
-
-/* extern struct nand_flash_controller boundary_scan_nand_controller; */
-
-static struct nand_flash_controller *nand_flash_controllers[] = {
-	&nonce_nand_controller,
-	&davinci_nand_controller,
-	&lpc3180_nand_controller,
-	&lpc32xx_nand_controller,
-	&orion_nand_controller,
-	&s3c2410_nand_controller,
-	&s3c2412_nand_controller,
-	&s3c2440_nand_controller,
-	&s3c2443_nand_controller,
-	&s3c6400_nand_controller,
-	&mxc_nand_flash_controller,
-	&imx31_nand_flash_controller,
-	&at91sam9_nand_controller,
-	&nuc910_nand_controller,
-/*	&boundary_scan_nand_controller, */
-	NULL
-};
-
-struct nand_flash_controller *nand_driver_find_by_name(const char *name)
-{
-	for (unsigned i = 0; nand_flash_controllers[i]; i++) {
-		struct nand_flash_controller *controller = nand_flash_controllers[i];
-		if (strcmp(name, controller->name) == 0)
-			return controller;
-	}
-	return NULL;
-}
-int nand_driver_walk(nand_driver_walker_t f, void *x)
-{
-	for (unsigned i = 0; nand_flash_controllers[i]; i++) {
-		int retval = (*f)(nand_flash_controllers[i], x);
-		if (ERROR_OK != retval)
-			return retval;
-	}
-	return ERROR_OK;
-}