HackRF-Treasure-Chest/Software/portapack-mayhem/firmware/common/cpld_max5.hpp

/*
 * Copyright (C) 2014 Jared Boone, ShareBrained Technology, Inc.
 *
 * This file is part of PortaPack.
 *
 * 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, 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; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street,
 * Boston, MA 02110-1301, USA.
 */

#ifndef __CPLD_MAX5_H__
#define __CPLD_MAX5_H__

#include "jtag.hpp"
#include "crc.hpp"

#include <cstdint>
#include <cstddef>
#include <array>
#include <bitset>

namespace cpld {
namespace max5 {

struct Config {
	const std::array<uint16_t, 3328>& block_0;
	const std::array<uint16_t,  512>& block_1;
};

class CPLD {
public:
	constexpr CPLD(
		jtag::JTAG& jtag
	) : jtag(jtag)
	{
	}

	void bypass();
	void sample();
	void sample(std::bitset<240>& value);
	void extest(std::bitset<240>& value);
	void clamp();

	void reset() {
		jtag.reset();
	}

	void run_test_idle() {
		jtag.run_test_idle();
	}

	bool idcode_ok();

	void enable();

	/* Check ID:
	 * The silicon ID is checked before any Program or Verify process. The
	 * time required to read this silicon ID is relatively small compared to
	 * the overall programming time.
	 */
	bool silicon_id_ok();

	uint32_t usercode();

	void disable();

	void bulk_erase();

	bool program(
		const std::array<uint16_t, 3328>& block_0,
		const std::array<uint16_t, 512>& block_1
	);

	bool verify(
		const std::array<uint16_t, 3328>& block_0,
		const std::array<uint16_t, 512>& block_1
	);

	bool is_blank();

	uint32_t crc();

	std::pair<bool, uint8_t> boundary_scan();

private:
	using idcode_t = uint32_t;
	static constexpr size_t idcode_length = 32;
	static constexpr idcode_t idcode      = 0b00000010000010100101000011011101;
	static constexpr idcode_t idcode_mask = 0b11111111111111111111111111111111;
	
	static constexpr size_t ir_length = 10;

	using ir_t = uint16_t;

	enum class instruction_t : ir_t {
		BYPASS            = 0b1111111111, // 0x3ff
		EXTEST            = 0b0000001111, // 0x00f
		SAMPLE            = 0b0000000101, // 0x005
		IDCODE            = 0b0000000110, // 0x006
		USERCODE          = 0b0000000111, // 0x007
		CLAMP             = 0b0000001010, // 0x00a
		HIGHZ             = 0b0000001011, // 0x00b
		ISC_ENABLE        = 0b1011001100, // 0x2cc
		ISC_DISABLE       = 0b1000000001, // 0x201
		ISC_PROGRAM       = 0b1011110100, // 0x2f4
		ISC_ERASE         = 0b1011110010, // 0x2f2
		ISC_ADDRESS_SHIFT = 0b1000000011, // 0x203
		ISC_READ          = 0b1000000101, // 0x205
		ISC_NOOP          = 0b1000010000, // 0x210
 	};

	void shift_ir(const instruction_t instruction) {
		shift_ir(static_cast<ir_t>(instruction));
	}
	
	void shift_ir(const uint32_t value) {
		jtag.shift_ir(ir_length, value);
	}

	void shift_dr(std::bitset<240>& value) {
		for(size_t i=0; i<value.size(); i++) {
			value[i] = shift_dr(1, value[i]);
		}
	}

	uint32_t shift_dr(const size_t count, const uint32_t value) {
		return jtag.shift_dr(count, value);
	}

	jtag::JTAG& jtag;

	std::array<uint16_t, 5> read_silicon_id();

	void sector_select(const uint16_t id);

	void erase_sector(const uint16_t id);

	void program_block(
		const uint16_t id,
		const uint16_t* const data,
		const size_t count
	);

	template<size_t N>
	void program_block(
		const uint16_t id,
		const std::array<uint16_t, N>& data
	) {
		program_block(id, data.data(), data.size());
	}

	bool verify_block(
		const uint16_t id,
		const uint16_t* const data,
		const size_t count
	);

	template<size_t N>
	bool verify_block(
		const uint16_t id,
		const std::array<uint16_t, N>& data
	) {
		return verify_block(id, data.data(), data.size());
	}

	bool is_blank_block(const uint16_t id, const size_t count);

	using crc_t = CRC<32, true, true>;
	void block_crc(const uint16_t id, const size_t count, crc_t& crc);
};
/*
class ModeISP {
public:
	ModeISP(
		CPLD& cpld
	) : cpld(cpld)
	{
		cpld.enter_isp();
	}

	~ModeISP() {
		cpld.exit_isp();
	}

private:
	CPLD& cpld;
};
*/
} /* namespace max5 */
} /* namespace cpld */

#endif/*__CPLD_MAX5_H__*/