int map_gpio() {
int ret = 0;
int fd;
fd = open("/dev/mem", O_RDWR);
if (fd == -1) { perror("open()"); return ret; }
if (!enable_gpio_clocks(fd)) goto exit;
gpio_0 = map_port(fd, GPIO_MMAP_SIZE, GPIO_0_BASE);
if (gpio_0 == MAP_FAILED) { perror("mmap() GPIO-0"); goto exit; }
gpio_1 = map_port(fd, GPIO_MMAP_SIZE, GPIO_1_BASE);
if (gpio_1 == MAP_FAILED) { perror("mmap() GPIO-1"); goto exit; }
gpio_2 = map_port(fd, GPIO_MMAP_SIZE, GPIO_2_BASE);
if (gpio_2 == MAP_FAILED) { perror("mmap() GPIO-2"); goto exit; }
gpio_3 = map_port(fd, GPIO_MMAP_SIZE, GPIO_3_BASE);
if (gpio_3 == MAP_FAILED) { perror("mmap() GPIO-3"); goto exit; }
// Prepare all the pins we need for output.
cfg_gpio_outputs();
ret = 1;
exit:
close(fd);
if (!ret)
unmap_gpio();
return ret;
}
static int enable_gpio_clocks(int fd) {
volatile uint32_t *cm;
cm = map_port(fd, CM_SIZE, CM_BASE);
if (cm == MAP_FAILED) { perror("mmap() CM"); return 0; }
ena_gpio_clk(cm, CM_WKUP_GPIO0_CLKCTRL, 0);
ena_gpio_clk(cm, CM_PER_GPIO1_CLKCTRL, 1);
ena_gpio_clk(cm, CM_PER_GPIO2_CLKCTRL, 2);
ena_gpio_clk(cm, CM_PER_GPIO3_CLKCTRL, 3);
munmap((void*)cm, CM_SIZE);
return 1;
}
// create the mapping table
static void create_mappings(void)
{
free_mappings();
for ( int i=0; i < numports; i++ )
{
const char *name = ports[i].name;
ea_t nameea = get_name_ea(BADADDR, name);
if ( nameea != BADADDR )
{
ea_t ea = map_port(ports[i].address);
if ( nameea != ea )
add_mapping(ea, nameea-dataseg);
}
}
}
int main( int argc, char** argv )
{
// parse command-line options
boost::program_options::options_description option_config("Allowed options");
option_config.add_options()("data-dir", boost::program_options::value<std::string>(), "configuration data directory")
("help", "display this help message")
("p2p-port", boost::program_options::value<uint16_t>()->default_value(5678), "set port to listen on")
("maximum-number-of-connections", boost::program_options::value<uint16_t>(), "set the maximum number of peers this node will accept at any one time")
("upnp", boost::program_options::value<bool>()->default_value(true), "Enable UPNP")
("connect-to", boost::program_options::value<std::vector<std::string> >(), "set remote host to connect to")
("server", "enable JSON-RPC server")
("daemon", "run in daemon mode with no CLI console")
("rpcuser", boost::program_options::value<std::string>(), "username for JSON-RPC")
("rpcpassword", boost::program_options::value<std::string>(), "password for JSON-RPC")
("rpcport", boost::program_options::value<uint16_t>()->default_value(5679), "port to listen for JSON-RPC connections")
("httpport", boost::program_options::value<uint16_t>()->default_value(5680), "port to listen for HTTP JSON-RPC connections")
("genesis-config", boost::program_options::value<std::string>()->default_value("genesis.dat"),
"generate a genesis state with the given json file (only accepted when the blockchain is empty)")
("clear-peer-database", "erase all information in the peer database")
("resync-blockchain", "delete our copy of the blockchain at startup, and download a fresh copy of the entire blockchain from the network")
("version", "print the version information for bts_xt_client");
boost::program_options::positional_options_description positional_config;
positional_config.add("data-dir", 1);
boost::program_options::variables_map option_variables;
try
{
boost::program_options::store(boost::program_options::command_line_parser(argc, argv).
options(option_config).positional(positional_config).run(), option_variables);
boost::program_options::notify(option_variables);
}
catch (boost::program_options::error&)
{
std::cerr << "Error parsing command-line options\n\n";
std::cerr << option_config << "\n";
return 1;
}
if (option_variables.count("help"))
{
std::cout << option_config << "\n";
return 0;
}
if (option_variables.count("version"))
{
std::cout << "bts_xt_client built on " << __DATE__ << " at " << __TIME__ << "\n";
std::cout << " bitshares_toolkit revision: " << bts::utilities::git_revision_sha << "\n";
std::cout << " committed " << fc::get_approximate_relative_time_string(fc::time_point_sec(bts::utilities::git_revision_unix_timestamp)) << "\n";
std::cout << " fc revision: " << fc::git_revision_sha << "\n";
std::cout << " committed " << fc::get_approximate_relative_time_string(fc::time_point_sec(bts::utilities::git_revision_unix_timestamp)) << "\n";
return 0;
}
try {
print_banner();
fc::path datadir = get_data_dir(option_variables);
::configure_logging(datadir);
auto cfg = load_config(datadir);
auto chain = load_and_configure_chain_database(datadir, option_variables);
auto wall = std::make_shared<bts::wallet::wallet>(chain);
wall->set_data_directory( datadir );
bts::client::client_ptr client = std::make_shared<bts::client::client>( chain );
_global_client = client.get();
client->set_wallet( wall );
client->run_delegate();
bts::rpc::rpc_server_ptr rpc_server = std::make_shared<bts::rpc::rpc_server>();
rpc_server->set_client(client);
if( option_variables.count("server") )
{
// the user wants us to launch the RPC server.
// First, override any config parameters they
bts::rpc::rpc_server::config rpc_config(cfg.rpc);
if (option_variables.count("rpcuser"))
rpc_config.rpc_user = option_variables["rpcuser"].as<std::string>();
if (option_variables.count("rpcpassword"))
rpc_config.rpc_password = option_variables["rpcpassword"].as<std::string>();
// for now, force binding to localhost only
if (option_variables.count("rpcport"))
rpc_config.rpc_endpoint = fc::ip::endpoint(fc::ip::address("127.0.0.1"), option_variables["rpcport"].as<uint16_t>());
else
rpc_config.rpc_endpoint = fc::ip::endpoint(fc::ip::address("127.0.0.1"), uint16_t(9988));
if (option_variables.count("httpport"))
rpc_config.httpd_endpoint = fc::ip::endpoint(fc::ip::address("127.0.0.1"), option_variables["httpport"].as<uint16_t>());
std::cout<<"Starting json rpc server on "<< std::string( rpc_config.rpc_endpoint ) <<"\n";
std::cout<<"Starting http json rpc server on "<< std::string( rpc_config.httpd_endpoint ) <<"\n";
bool rpc_success = rpc_server->configure(rpc_config);
if (!rpc_success)
{
std::cerr << "Error starting rpc server\n\n";
}
}
else
{
std::cout << "Not starting rpc server, use --server to enable the rpc interface\n";
}
client->configure( datadir );
if (option_variables.count("maximum-number-of-connections"))
{
fc::mutable_variant_object params;
params["maximum_number_of_connections"] = option_variables["maximum-number-of-connections"].as<uint16_t>();
client->network_set_advanced_node_parameters(params);
}
if (option_variables.count("p2p-port"))
{
auto p2pport = option_variables["p2p-port"].as<uint16_t>();
std::cout << "Listening to P2P connections on port "<<p2pport<<"\n";
client->listen_on_port(p2pport);
if( option_variables["upnp"].as<bool>() )
{
std::cout << "Attempting to map UPNP port...\n";
auto upnp_service = new bts::net::upnp_service();
upnp_service->map_port( p2pport );
fc::usleep( fc::seconds(3) );
}
}
if (option_variables.count("clear-peer-database"))
{
std::cout << "Erasing old peer database\n";
client->get_node()->clear_peer_database();
}
client->connect_to_p2p_network();
if (option_variables.count("connect-to"))
{
std::vector<std::string> hosts = option_variables["connect-to"].as<std::vector<std::string>>();
for( auto peer : hosts )
{
client->connect_to_peer( peer );
}
}
else
{
client->connect_to_peer( "107.170.30.182:5678" );
}
if( !option_variables.count("daemon") )
{
auto cli = std::make_shared<bts::cli::cli>( client, rpc_server );
cli->wait();
}
else if( option_variables.count( "server" ) ) // daemon & server
{
rpc_server->wait_on_quit();
}
else // daemon !server
{
std::cerr << "You must start the rpc server in daemon mode\n";
}
}
catch ( const fc::exception& e )
{
std::cerr << "------------ error --------------\n"
<< e.to_detail_string() << "\n";
wlog( "${e}", ("e", e.to_detail_string() ) );
}
return 0;
}
const char *find_bit(ea_t address, int bit)
{
address = map_port(address);
const ioport_bit_t *b = find_ioport_bit(ports, numports, address, bit);
return b ? b->name : NULL;
}
