src/devices/block/bin/sdio/sdio.cc - fuchsia - Git at Google

 // Copyright 2020 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "sdio.h"

 #include <lib/zx/clock.h>

 namespace sdio {

 using SdioClient = fidl::WireSyncClient<fuchsia_hardware_sdio::Device>;
 using namespace fuchsia_hardware_sdio;
 using namespace fuchsia_hardware_sdio::wire;

 constexpr char kUsageMessage[] = R"""(Usage: sdio <device> <command> [options]

     --help - Show this message
     --version - Show the version of this tool
     info - Display information about the host controller and the card
     read-byte <address> - Read one byte from the SDIO function
     write-byte <address> <byte> - Write one byte to the SDIO function
     read-stress <address> <size> <loops> [--fifo] - Read a number of blocks from the SDIO
                                                     function and measure the throughput

     Example:
     sdio /dev/class/sdio/001 read-stress 0x01234 256 100
 )""";

 constexpr char kVersion[] = "1";

 void PrintUsage() { printf("%s", kUsageMessage); }

 void PrintVersion() { printf("%s\n", kVersion); }

 template <typename T>
 bool ParseNumericalArg(const char* const arg, T* const out) {
   char* endptr;
   unsigned long value = strtoul(arg, &endptr, 0);
   if (*endptr != '\0') {
     fprintf(stderr, "Failed to parse value: %s\n", arg);
     return false;
   }

   if constexpr (sizeof(T) < sizeof(value)) {
     if (value > ((1ul << (sizeof(T) * 8)) - 1)) {
       fprintf(stderr, "Value out of range: %s\n", arg);
       return false;
     }
   }

   *out = static_cast<T>(value);
   return true;
 }

 std::string GetTxnStats(const zx::duration duration, const uint64_t bytes) {
   constexpr size_t kMaxStringSize = 32;

   constexpr double kKilobyte = 1000.0;
   constexpr double kMegabyte = kKilobyte * 1000.0;
   constexpr double kGigabyte = kMegabyte * 1000.0;

   char duration_str[kMaxStringSize];
   const double duration_nsec = static_cast<double>(duration.to_nsecs());
   if (duration >= zx::sec(1)) {
     snprintf(duration_str, kMaxStringSize, "%.3f s", duration_nsec / zx::sec(1).to_nsecs());
   } else if (duration >= zx::msec(1)) {
     snprintf(duration_str, kMaxStringSize, "%.3f ms", duration_nsec / zx::msec(1).to_nsecs());
   } else if (duration >= zx::usec(1)) {
     snprintf(duration_str, kMaxStringSize, "%.3f us", duration_nsec / zx::usec(1).to_nsecs());
   } else {
     snprintf(duration_str, kMaxStringSize, "%ld ns", duration.to_nsecs());
   }

   if (duration.to_nsecs() == 0) {
     return std::string(duration_str);
   }

   char bytes_second_str[kMaxStringSize];
   const double bytes_second = static_cast<double>(bytes) / (duration_nsec / zx::sec(1).to_nsecs());
   if (bytes_second >= kGigabyte) {
     snprintf(bytes_second_str, kMaxStringSize, " (%.3f GB/s)", bytes_second / kGigabyte);
   } else if (bytes_second >= kMegabyte) {
     snprintf(bytes_second_str, kMaxStringSize, " (%.3f MB/s)", bytes_second / kMegabyte);
   } else if (bytes_second >= kKilobyte) {
     snprintf(bytes_second_str, kMaxStringSize, " (%.3f kB/s)", bytes_second / kKilobyte);
   } else {
     snprintf(bytes_second_str, kMaxStringSize, " (%.3f B/s)", bytes_second);
   }

   return std::string(duration_str) + std::string(bytes_second_str);
 }

 int Info(SdioClient client) {
   struct {
     SdioDeviceCapabilities capability;
     const char* string;
   } constexpr kCapabilityStrings[] = {
       {SdioDeviceCapabilities::kMultiBlock, "MULTI_BLOCK"},
       {SdioDeviceCapabilities::kSrw, "SRW"},
       {SdioDeviceCapabilities::kDirectCommand, "DIRECT_COMMAND"},
       {SdioDeviceCapabilities::kSuspendResume, "SUSPEND_RESUME"},
       {SdioDeviceCapabilities::kLowSpeed, "LOW_SPEED"},
       {SdioDeviceCapabilities::kHighSpeed, "HIGH_SPEED"},
       {SdioDeviceCapabilities::kHighPower, "HIGH_POWER"},
       {SdioDeviceCapabilities::kFourBitBus, "FOUR_BIT_BUS"},
       {SdioDeviceCapabilities::kHsSdr12, "HS_SDR12"},
       {SdioDeviceCapabilities::kHsSdr25, "HS_SDR25"},
       {SdioDeviceCapabilities::kUhsSdr50, "UHS_SDR50"},
       {SdioDeviceCapabilities::kUhsSdr104, "UHS_SDR104"},
       {SdioDeviceCapabilities::kUhsDdr50, "UHS_DDR50"},
       {SdioDeviceCapabilities::kTypeA, "TYPE_A"},
       {SdioDeviceCapabilities::kTypeB, "TYPE_B"},
       {SdioDeviceCapabilities::kTypeC, "TYPE_C"},
       {SdioDeviceCapabilities::kTypeD, "TYPE_D"},
   };

   auto result = client->GetDevHwInfo();
   if (!result.ok()) {
     fprintf(stderr, "FIDL call GetDevHwInfo failed: %s\n", zx_status_get_string(result.status()));
     return 1;
   }
   if (result->is_error()) {
     fprintf(stderr, "Failed to get Dev HW info err: %s",
             zx_status_get_string(result->error_value()));
     return result->error_value();
   }

   const SdioHwInfo& info = result.value()->hw_info;
   const SdioDeviceHwInfo& dev_info = info.dev_hw_info;
   const uint32_t caps(dev_info.caps);
   printf("Host:\n    Max transfer size: %u\n\n", info.host_max_transfer_size);
   printf("Card:\n");
   printf(
       "    SDIO version: %u\n"
       "    CCCR version: %u\n"
       "    Functions:    %u\n"
       "    Capabilities: 0x%08x\n"
       "    Max transfer speed: ",
       dev_info.sdio_vsn, dev_info.cccr_vsn, dev_info.num_funcs, caps);
   if (dev_info.max_tran_speed > 1000) {
     printf("%.1f Mb/s\n", static_cast<double>(dev_info.max_tran_speed) / 1000.0);
   } else {
     printf("%u kb/s\n", dev_info.max_tran_speed);
   }

   for (size_t i = 0; i < std::size(kCapabilityStrings); i++) {
     if (dev_info.caps & kCapabilityStrings[i].capability) {
       printf("        %s\n", kCapabilityStrings[i].string);
     }
   }

   printf("\n    Function:\n");
   const SdioFuncHwInfo& func_info = info.func_hw_info;
   printf(
       "        Manufacturer ID:    0x%04x\n"
       "        Product ID:         0x%04x\n"
       "        Max block size:     %u\n"
       "        Interface code:     0x%02x\n",
       func_info.manufacturer_id, func_info.product_id, func_info.max_blk_size,
       func_info.fn_intf_code);

   return 0;
 }

 int ReadByte(SdioClient client, uint32_t address, int argc, const char** argv) {
   auto result = client->DoRwByte(false, address, 0);
   if (!result.ok()) {
     fprintf(stderr, "FIDL call DoRwByte failed: %d\n", result.status());
     return 1;
   }
   if (result->is_error()) {
     fprintf(stderr, "Failed to read byte: %s", zx_status_get_string(result->error_value()));
     return 1;
   }

   printf("0x%02x\n", result.value()->read_byte);
   return 0;
 }

 int WriteByte(SdioClient client, uint32_t address, int argc, const char** argv) {
   if (argc < 1) {
     fprintf(stderr, "Expected <byte> argument\n");
     PrintUsage();
     return 1;
   }

   uint8_t write_value = 0;
   if (!ParseNumericalArg(argv[0], &write_value)) {
     return 1;
   }

   auto result = client->DoRwByte(true, address, write_value);
   if (!result.ok()) {
     fprintf(stderr, "FIDL call DoRwByte failed: %d\n", result.status());
     return 1;
   }
   if (result->is_error()) {
     fprintf(stderr, "Failed to write byte: %s", zx_status_get_string(result->error_value()));
     return 1;
   }

   return 0;
 }

 int ReadStress(SdioClient client, uint32_t address, int argc, const char** argv) {
   if (argc < 2) {
     fprintf(stderr, "Expected <size> and <loops> arguments\n");
     PrintUsage();
     return 1;
   }

   uint32_t size = 0;
   if (!ParseNumericalArg(argv[0], &size)) {
     return 1;
   }

   unsigned long loops = 0;
   if (!ParseNumericalArg(argv[1], &loops)) {
     return 1;
   }

   bool incr = true;

   for (int i = 2; i < argc; i++) {
     if (strcmp(argv[i], "--fifo") == 0) {
       incr = false;
     } else {
       fprintf(stderr, "Unexpected option: %s\n", argv[i]);
       PrintUsage();
       return 1;
     }
   }

   zx::vmo dma_vmo;
   zx_status_t status = zx::vmo::create(size, 0, &dma_vmo);
   if (status != ZX_OK) {
     fprintf(stderr, "Failed to create VMO: %s\n", zx_status_get_string(status));
     return 1;
   }

   const zx::time start = zx::clock::get_monotonic();

   for (unsigned long i = 0; i < loops; i++) {
     zx::vmo dup_dma_vmo;
     zx_status_t status = dma_vmo.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup_dma_vmo);
     if (status != ZX_OK) {
       fprintf(stderr, "Failed to duplicate VMO handle for SDIO test: %s\n",
               zx_status_get_string(status));
       return 1;
     }
     fuchsia_hardware_sdmmc::wire::SdmmcBufferRegion buffers[1];
     buffers[0] = fuchsia_hardware_sdmmc::wire::SdmmcBufferRegion{
         .buffer = fuchsia_hardware_sdmmc::wire::SdmmcBuffer::WithVmo(std::move(dup_dma_vmo)),
         .offset = 0,
         .size = size,
     };
     SdioRwTxn txn{
         .addr = address,
         .incr = incr,
         .write = false,
         .buffers = fidl::VectorView<fuchsia_hardware_sdmmc::wire::SdmmcBufferRegion>::FromExternal(
             buffers, 1),
     };

     auto result = client->DoRwTxn(std::move(txn));
     if (!result.ok()) {
       fprintf(stderr, "FIDL call DoRwTxn failed on iteration %lu status: %s\n", i,
               zx_status_get_string(result.status()));
       return 1;
     }
     if (result->is_error()) {
       fprintf(stderr, "DoRwTxn failed on iteration %lu status: %s", i,
               zx_status_get_string(result->error_value()));
       return 1;
     }
   }

   const zx::duration elapsed = zx::clock::get_monotonic() - start;
   const std::string txn_stats = GetTxnStats(elapsed, size * loops);
   printf("Read %lu chunks of %u bytes in %s\n", loops, size, txn_stats.c_str());
   return 0;
 }

 int RunSdioTool(SdioClient client, int argc, const char** argv) {
   if (argc < 1) {
     fprintf(stderr, "Expected <command> argument\n");
     PrintUsage();
     return 1;
   }

   const char* const command = argv[0];
   if (strcmp(command, "info") == 0) {
     return Info(std::move(client));
   }

   if (argc < 2) {
     fprintf(stderr, "Expected <address> argument\n");
     PrintUsage();
     return 1;
   }

   const char* const address_str = argv[1];

   argc -= 2;
   argv += 2;

   uint32_t address = 0;
   if (!ParseNumericalArg(address_str, &address)) {
     return 1;
   }

   constexpr uint32_t kMaxSdioAddress = (1 << 17) - 1;

   if (address > kMaxSdioAddress) {
     fprintf(stderr, "Address must be less than 0x%x: %s\n", kMaxSdioAddress, address_str);
     return 1;
   }

   if (strcmp(command, "read-byte") == 0) {
     return ReadByte(std::move(client), address, argc, argv);
   } else if (strcmp(command, "write-byte") == 0) {
     return WriteByte(std::move(client), address, argc, argv);
   } else if (strcmp(command, "read-stress") == 0) {
     return ReadStress(std::move(client), address, argc, argv);
   } else {
     fprintf(stderr, "Unexpected command: %s\n", command);
     PrintUsage();
     return 1;
   }
 }

 }  // namespace sdio
	// Copyright 2020 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "sdio.h"

	#include <lib/zx/clock.h>

	namespace sdio {

	using SdioClient = fidl::WireSyncClient<fuchsia_hardware_sdio::Device>;
	using namespace fuchsia_hardware_sdio;
	using namespace fuchsia_hardware_sdio::wire;

	constexpr char kUsageMessage[] = R"""(Usage: sdio <device> <command> [options]

	--help - Show this message
	--version - Show the version of this tool
	info - Display information about the host controller and the card
	read-byte <address> - Read one byte from the SDIO function
	write-byte <address> <byte> - Write one byte to the SDIO function
	read-stress <address> <size> <loops> [--fifo] - Read a number of blocks from the SDIO
	function and measure the throughput

	Example:
	sdio /dev/class/sdio/001 read-stress 0x01234 256 100
	)""";

	constexpr char kVersion[] = "1";

	void PrintUsage() { printf("%s", kUsageMessage); }

	void PrintVersion() { printf("%s\n", kVersion); }

	template <typename T>
	bool ParseNumericalArg(const char* const arg, T* const out) {
	char* endptr;
	unsigned long value = strtoul(arg, &endptr, 0);
	if (*endptr != '\0') {
	fprintf(stderr, "Failed to parse value: %s\n", arg);
	return false;
	}

	if constexpr (sizeof(T) < sizeof(value)) {
	if (value > ((1ul << (sizeof(T) * 8)) - 1)) {
	fprintf(stderr, "Value out of range: %s\n", arg);
	return false;
	}
	}

	*out = static_cast<T>(value);
	return true;
	}

	std::string GetTxnStats(const zx::duration duration, const uint64_t bytes) {
	constexpr size_t kMaxStringSize = 32;

	constexpr double kKilobyte = 1000.0;
	constexpr double kMegabyte = kKilobyte * 1000.0;
	constexpr double kGigabyte = kMegabyte * 1000.0;

	char duration_str[kMaxStringSize];
	const double duration_nsec = static_cast<double>(duration.to_nsecs());
	if (duration >= zx::sec(1)) {
	snprintf(duration_str, kMaxStringSize, "%.3f s", duration_nsec / zx::sec(1).to_nsecs());
	} else if (duration >= zx::msec(1)) {
	snprintf(duration_str, kMaxStringSize, "%.3f ms", duration_nsec / zx::msec(1).to_nsecs());
	} else if (duration >= zx::usec(1)) {
	snprintf(duration_str, kMaxStringSize, "%.3f us", duration_nsec / zx::usec(1).to_nsecs());
	} else {
	snprintf(duration_str, kMaxStringSize, "%ld ns", duration.to_nsecs());
	}

	if (duration.to_nsecs() == 0) {
	return std::string(duration_str);
	}

	char bytes_second_str[kMaxStringSize];
	const double bytes_second = static_cast<double>(bytes) / (duration_nsec / zx::sec(1).to_nsecs());
	if (bytes_second >= kGigabyte) {
	snprintf(bytes_second_str, kMaxStringSize, " (%.3f GB/s)", bytes_second / kGigabyte);
	} else if (bytes_second >= kMegabyte) {
	snprintf(bytes_second_str, kMaxStringSize, " (%.3f MB/s)", bytes_second / kMegabyte);
	} else if (bytes_second >= kKilobyte) {
	snprintf(bytes_second_str, kMaxStringSize, " (%.3f kB/s)", bytes_second / kKilobyte);
	} else {
	snprintf(bytes_second_str, kMaxStringSize, " (%.3f B/s)", bytes_second);
	}

	return std::string(duration_str) + std::string(bytes_second_str);
	}

	int Info(SdioClient client) {
	struct {
	SdioDeviceCapabilities capability;
	const char* string;
	} constexpr kCapabilityStrings[] = {
	{SdioDeviceCapabilities::kMultiBlock, "MULTI_BLOCK"},
	{SdioDeviceCapabilities::kSrw, "SRW"},
	{SdioDeviceCapabilities::kDirectCommand, "DIRECT_COMMAND"},
	{SdioDeviceCapabilities::kSuspendResume, "SUSPEND_RESUME"},
	{SdioDeviceCapabilities::kLowSpeed, "LOW_SPEED"},
	{SdioDeviceCapabilities::kHighSpeed, "HIGH_SPEED"},
	{SdioDeviceCapabilities::kHighPower, "HIGH_POWER"},
	{SdioDeviceCapabilities::kFourBitBus, "FOUR_BIT_BUS"},
	{SdioDeviceCapabilities::kHsSdr12, "HS_SDR12"},
	{SdioDeviceCapabilities::kHsSdr25, "HS_SDR25"},
	{SdioDeviceCapabilities::kUhsSdr50, "UHS_SDR50"},
	{SdioDeviceCapabilities::kUhsSdr104, "UHS_SDR104"},
	{SdioDeviceCapabilities::kUhsDdr50, "UHS_DDR50"},
	{SdioDeviceCapabilities::kTypeA, "TYPE_A"},
	{SdioDeviceCapabilities::kTypeB, "TYPE_B"},
	{SdioDeviceCapabilities::kTypeC, "TYPE_C"},
	{SdioDeviceCapabilities::kTypeD, "TYPE_D"},
	};

	auto result = client->GetDevHwInfo();
	if (!result.ok()) {
	fprintf(stderr, "FIDL call GetDevHwInfo failed: %s\n", zx_status_get_string(result.status()));
	return 1;
	}
	if (result->is_error()) {
	fprintf(stderr, "Failed to get Dev HW info err: %s",
	zx_status_get_string(result->error_value()));
	return result->error_value();
	}

	const SdioHwInfo& info = result.value()->hw_info;
	const SdioDeviceHwInfo& dev_info = info.dev_hw_info;
	const uint32_t caps(dev_info.caps);
	printf("Host:\n Max transfer size: %u\n\n", info.host_max_transfer_size);
	printf("Card:\n");
	printf(
	" SDIO version: %u\n"
	" CCCR version: %u\n"
	" Functions: %u\n"
	" Capabilities: 0x%08x\n"
	" Max transfer speed: ",
	dev_info.sdio_vsn, dev_info.cccr_vsn, dev_info.num_funcs, caps);
	if (dev_info.max_tran_speed > 1000) {
	printf("%.1f Mb/s\n", static_cast<double>(dev_info.max_tran_speed) / 1000.0);
	} else {
	printf("%u kb/s\n", dev_info.max_tran_speed);
	}

	for (size_t i = 0; i < std::size(kCapabilityStrings); i++) {
	if (dev_info.caps & kCapabilityStrings[i].capability) {
	printf(" %s\n", kCapabilityStrings[i].string);
	}
	}

	printf("\n Function:\n");
	const SdioFuncHwInfo& func_info = info.func_hw_info;
	printf(
	" Manufacturer ID: 0x%04x\n"
	" Product ID: 0x%04x\n"
	" Max block size: %u\n"
	" Interface code: 0x%02x\n",
	func_info.manufacturer_id, func_info.product_id, func_info.max_blk_size,
	func_info.fn_intf_code);

	return 0;
	}

	int ReadByte(SdioClient client, uint32_t address, int argc, const char** argv) {
	auto result = client->DoRwByte(false, address, 0);
	if (!result.ok()) {
	fprintf(stderr, "FIDL call DoRwByte failed: %d\n", result.status());
	return 1;
	}
	if (result->is_error()) {
	fprintf(stderr, "Failed to read byte: %s", zx_status_get_string(result->error_value()));
	return 1;
	}

	printf("0x%02x\n", result.value()->read_byte);
	return 0;
	}

	int WriteByte(SdioClient client, uint32_t address, int argc, const char** argv) {
	if (argc < 1) {
	fprintf(stderr, "Expected <byte> argument\n");
	PrintUsage();
	return 1;
	}

	uint8_t write_value = 0;
	if (!ParseNumericalArg(argv[0], &write_value)) {
	return 1;
	}

	auto result = client->DoRwByte(true, address, write_value);
	if (!result.ok()) {
	fprintf(stderr, "FIDL call DoRwByte failed: %d\n", result.status());
	return 1;
	}
	if (result->is_error()) {
	fprintf(stderr, "Failed to write byte: %s", zx_status_get_string(result->error_value()));
	return 1;
	}

	return 0;
	}

	int ReadStress(SdioClient client, uint32_t address, int argc, const char** argv) {
	if (argc < 2) {
	fprintf(stderr, "Expected <size> and <loops> arguments\n");
	PrintUsage();
	return 1;
	}

	uint32_t size = 0;
	if (!ParseNumericalArg(argv[0], &size)) {
	return 1;
	}

	unsigned long loops = 0;
	if (!ParseNumericalArg(argv[1], &loops)) {
	return 1;
	}

	bool incr = true;

	for (int i = 2; i < argc; i++) {
	if (strcmp(argv[i], "--fifo") == 0) {
	incr = false;
	} else {
	fprintf(stderr, "Unexpected option: %s\n", argv[i]);
	PrintUsage();
	return 1;
	}
	}

	zx::vmo dma_vmo;
	zx_status_t status = zx::vmo::create(size, 0, &dma_vmo);
	if (status != ZX_OK) {
	fprintf(stderr, "Failed to create VMO: %s\n", zx_status_get_string(status));
	return 1;
	}

	const zx::time start = zx::clock::get_monotonic();

	for (unsigned long i = 0; i < loops; i++) {
	zx::vmo dup_dma_vmo;
	zx_status_t status = dma_vmo.duplicate(ZX_RIGHT_SAME_RIGHTS, &dup_dma_vmo);
	if (status != ZX_OK) {
	fprintf(stderr, "Failed to duplicate VMO handle for SDIO test: %s\n",
	zx_status_get_string(status));
	return 1;
	}
	fuchsia_hardware_sdmmc::wire::SdmmcBufferRegion buffers[1];
	buffers[0] = fuchsia_hardware_sdmmc::wire::SdmmcBufferRegion{
	.buffer = fuchsia_hardware_sdmmc::wire::SdmmcBuffer::WithVmo(std::move(dup_dma_vmo)),
	.offset = 0,
	.size = size,
	};
	SdioRwTxn txn{
	.addr = address,
	.incr = incr,
	.write = false,
	.buffers = fidl::VectorView<fuchsia_hardware_sdmmc::wire::SdmmcBufferRegion>::FromExternal(
	buffers, 1),
	};

	auto result = client->DoRwTxn(std::move(txn));
	if (!result.ok()) {
	fprintf(stderr, "FIDL call DoRwTxn failed on iteration %lu status: %s\n", i,
	zx_status_get_string(result.status()));
	return 1;
	}
	if (result->is_error()) {
	fprintf(stderr, "DoRwTxn failed on iteration %lu status: %s", i,
	zx_status_get_string(result->error_value()));
	return 1;
	}
	}

	const zx::duration elapsed = zx::clock::get_monotonic() - start;
	const std::string txn_stats = GetTxnStats(elapsed, size * loops);
	printf("Read %lu chunks of %u bytes in %s\n", loops, size, txn_stats.c_str());
	return 0;
	}

	int RunSdioTool(SdioClient client, int argc, const char** argv) {
	if (argc < 1) {
	fprintf(stderr, "Expected <command> argument\n");
	PrintUsage();
	return 1;
	}

	const char* const command = argv[0];
	if (strcmp(command, "info") == 0) {
	return Info(std::move(client));
	}

	if (argc < 2) {
	fprintf(stderr, "Expected <address> argument\n");
	PrintUsage();
	return 1;
	}

	const char* const address_str = argv[1];

	argc -= 2;
	argv += 2;

	uint32_t address = 0;
	if (!ParseNumericalArg(address_str, &address)) {
	return 1;
	}

	constexpr uint32_t kMaxSdioAddress = (1 << 17) - 1;

	if (address > kMaxSdioAddress) {
	fprintf(stderr, "Address must be less than 0x%x: %s\n", kMaxSdioAddress, address_str);
	return 1;
	}

	if (strcmp(command, "read-byte") == 0) {
	return ReadByte(std::move(client), address, argc, argv);
	} else if (strcmp(command, "write-byte") == 0) {
	return WriteByte(std::move(client), address, argc, argv);
	} else if (strcmp(command, "read-stress") == 0) {
	return ReadStress(std::move(client), address, argc, argv);
	} else {
	fprintf(stderr, "Unexpected command: %s\n", command);
	PrintUsage();
	return 1;
	}
	}

	} // namespace sdio