**************************************************************************************

* Build cgminer.exe                                                                  *
**************************************************************************************
Run the MinGW MSYS shell
(Start Icon/keyboard key ==> All Programs ==> MinGW ==> MinGW Shell).
Change the working directory to your CGMiner project folder.
Example: cd cgminer-2.1.2 [Enter Key] if you are unsure then type "ls -la"
Another way is to type "cd cg" and then press the tab key; It will auto fill.
Type the lines below one at a time. Look for problems after each one before going on
to the next.

      adl.sh (optional - see below)
      autoreconf -fvi
      CFLAGS="-O2 -msse2" ./configure (additional config options, see below)
      make
      strip cgminer.exe  <== only do this if you are not compiling for debugging

driver-lketc.c

@@ -1,6 +1,6 @@
 /*
  * Copyright 2013-2014 Con Kolivas <kernel@kolivas.org>
- * Copyright 2014 LKETC Integrated Systems Limited
+ * Copyright 2014 Lketc Integrated Systems Limited
  * Copyright 2014 Dominik Lehner
  *
  * This program is free software; you can redistribute it and/or modify it
@@ -43,7 +43,7 @@
 
 // Configuration options
 extern bool opt_lketc_debug;
-extern int opt_lketc_chips_count;		// number of Zeus chips chained together
+extern int opt_lketc_chips_count;		// number of Lketc chips chained together
 extern int opt_lketc_chip_clk;			// frequency to run chips with
 extern bool opt_lketc_nocheck_golden;		// bypass hashrate check
 
@@ -60,12 +60,8 @@ static struct name_chip_map {
 	char	*model_name;
 	int	chips_count;
 } lketc_models[] = {
-	{ "Blizzard",		6  },
-	//{ "Cyclone",		96 },	// model renamed??
-	{ "Hurricane X2",	48 },
-	{ "Hurricane X3",	64 },
-	{ "Thunder X2",		96 },
-	{ "Thunder X3",		128 },
+	{ "Stick",			1  },
+	{ "Dragon",		2  },
 	{ NULL, 0 }
 };
 
@@ -329,7 +325,7 @@ static void lketc_get_device_options(const char *devid, int *chips_count, int *c
 		switch (index++) {
 			case 1:			// chip count
 				if (lval < LKETC_MIN_CHIPS || lval > LKETC_MAX_CHIPS) {
-					applog(LOG_ERR, "Invalid chip count %ld for Zeus device %s",
+					applog(LOG_ERR, "Invalid chip count %ld for Lketc device %s",
 					       lval, devid);
 					break;
 				}
@@ -337,7 +333,7 @@ static void lketc_get_device_options(const char *devid, int *chips_count, int *c
 				break;
 			case 2:			// clock
 				if (lval < LKETC_CLK_MIN || lval > LKETC_CLK_MAX) {
-					applog(LOG_ERR, "Invalid clock speed %ld for Zeus device %s",
+					applog(LOG_ERR, "Invalid clock speed %ld for Lketc device %s",
 					       lval, devid);
 					break;
 				}
@@ -395,7 +391,7 @@ static bool lketc_initialize_cp2102(struct cgpu_info *lketc)
 			CP210X_VALUE_DATA, interface, C_SETDATA))
 		return false;
 
-	// Zeusminers have baud hardcoded to 115200, and reject baud commands, even to same value
+	// Lketcminers have baud hardcoded to 115200, and reject baud commands, even to same value
 	// Set the baud
 	//if (lketc_usb_control_transfer_data(lketc, CP210X_TYPE_OUT, CP210X_REQUEST_BAUD,
 	//		0, interface, &baudrate, sizeof(baudrate), C_SETBAUD))
@@ -404,15 +400,9 @@ static bool lketc_initialize_cp2102(struct cgpu_info *lketc)
 	return true;
 }
 
-static bool lketc_initialize_ftdi(struct cgpu_info *lketc)
-{
-	int interface = usb_interface(lketc);
-	return true;
-
-}
-
 static bool lketc_initialize_usb(struct cgpu_info *lketc)
 {
+	struct LKETC_INFO *info = lketc->device_data;
 	enum sub_ident ident;
 
 	if (lketc->usbinfo.nodev)
@@ -422,6 +412,7 @@ static bool lketc_initialize_usb(struct cgpu_info *lketc)
 
 	switch (ident) {
 	case IDENT_LKE:
+		info->read_data_offset = 0;
 		return lketc_initialize_cp2102(lketc);
 	default:
 		applog(LOG_ERR, "lketc_initialize_usb called on wrong device, ident=%d", ident);
@@ -468,7 +459,7 @@ static struct cgpu_info *lketc_detect_one_usb(struct libusb_device *dev, struct
 
 	lketc->usbdev->usb_type = USB_TYPE_STD;
 	if (!lketc_initialize_usb(lketc)) {
-		applog(LOG_ERR, "Failed to initialize Zeus USB-UART interface");
+		applog(LOG_ERR, "Failed to initialize Lketc USB-UART interface");
 		goto alldealloc;
 	}
 
@@ -529,12 +520,12 @@ static bool lketc_detect_one_serial(const char *devpath)
 	//chips_count_max = opt_lketc_chips_count_max;
 
 	if (initial_startup_phase)
-		applog(LOG_INFO, "Zeus Detect: Attempting to open %s", devpath);
+		applog(LOG_INFO, "Lketc Detect: Attempting to open %s", devpath);
 
 	fd = lketc_serial_open_detect(devpath, baud, true);
 	if (unlikely(fd == -1)) {
 		if (initial_startup_phase)
-			applog(LOG_ERR, "Zeus Detect: Failed to open %s", devpath);
+			applog(LOG_ERR, "Lketc Detect: Failed to open %s", devpath);
 		return false;
 	}
 
@@ -542,7 +533,7 @@ static bool lketc_detect_one_serial(const char *devpath)
 
 	// from 150M step to the high or low speed. we need to add delay and resend to init chip
 	if (chip_clk > 150)
-		freqcode_init = lketc_clk_to_freqcode(165);
+		freqcode_init = lketc_clk_to_freqcode(170);
 	else
 		freqcode_init = lketc_clk_to_freqcode(139);
 
@@ -592,7 +583,7 @@ static bool lketc_detect_one_serial(const char *devpath)
 		nonce = be32toh(nonce);
 
 		if (nonce != golden_nonce_val) {
-			applog(LOG_ERR, "Zeus Detect: "
+			applog(LOG_ERR, "Lketc Detect: "
 					"Test failed at %s: got %08x, should be: %08x",
 					devpath, nonce, golden_nonce_val);
 			return false;
@@ -608,7 +599,7 @@ static bool lketc_detect_one_serial(const char *devpath)
 		golden_speed_per_core = (((chip_clk * 2.) / 3.) * 1024.) / 8.;
 	}
 
-	/* We have a real Zeus miner! */
+	/* We have a real Lketc miner! */
 	struct cgpu_info *lketc;
 	struct LKETC_INFO *info;
 
@@ -626,10 +617,10 @@ static bool lketc_detect_one_serial(const char *devpath)
 	lketc->deven = DEV_ENABLED;
 	lketc->threads = 1;
 
-	applog(LOG_NOTICE, "Found Zeus at %s, mark as %d",
+	applog(LOG_NOTICE, "Found Lketc at %s, mark as %d",
 			devpath, lketc->device_id);
 
-	applog(LOG_INFO, "Zeus: Init: %d baud=%d cores_per_chip=%d chips_count=%d",
+	applog(LOG_INFO, "Lketc: Init: %d baud=%d cores_per_chip=%d chips_count=%d",
 			lketc->device_id, baud, cores_per_chip, chips_count);
 
 	info->device_fd = -1;
@@ -661,6 +652,7 @@ static bool lketc_detect_one_serial(const char *devpath)
 		quit(1, "chips_count_max must be a power of 2");
 	info->chip_clk = chip_clk;
 	info->chips_bit_num = log_2(chips_count_max);
+	info->read_data_offset = 0;
 
 	if (!add_cgpu(lketc))
 		quit(1, "Failed to add_cgpu");
@@ -690,23 +682,35 @@ static void lketc_purge_work(struct cgpu_info *lketc)
 static bool lketc_read_response(struct cgpu_info *lketc)
 {
 	struct LKETC_INFO *info = lketc->device_data;
-	unsigned char evtpkt[LKETC_EVENT_PKT_LEN];
+	unsigned char evtpkt[LKETC_READ_BUFFER];
 	uint32_t nonce, chip, core;
 	int ret, err;
 	double duration_s;
 	bool valid;
 
 	if (using_libusb(info)) {
-		err = usb_read_timeout(lketc, (char *)evtpkt, sizeof(evtpkt), &ret, 250, C_GETRESULTS);
+		//err = usb_read_timeout(lketc, (char *)evtpkt, sizeof(evtpkt), &ret, 250, C_GETRESULTS);
+		err = usb_read_once(lketc, (char *)evtpkt, sizeof(evtpkt), &ret, C_GETRESULTS);
+
+#if LKETC_PROTOCOL_DEBUG
+		if (opt_lketc_debug) {
+			char *hexstr;
+			hexstr = bin2hex(evtpkt, ret);
+			applog(LOG_DEBUG, "< %s    err=%d ret=%d", hexstr, err, ret);
+			free(hexstr);
+		}
+#endif
+
 		if (err != LIBUSB_SUCCESS && err != LIBUSB_ERROR_TIMEOUT) {
 			applog(LOG_ERR, "%s%d: USB read error: %s",
 				lketc->drv->name, lketc->device_id, libusb_error_name(err));
 			return false;
-		} else if (err == LIBUSB_ERROR_TIMEOUT) {
-			return true;
 		}
+
+		if (ret < LKETC_EVENT_PKT_LEN + info->read_data_offset)
+			return true;
 	} else {
-		ret = lketc_serial_read(info->device_fd, evtpkt, sizeof(evtpkt), 1, NULL);
+		ret = lketc_serial_read(info->device_fd, evtpkt, LKETC_EVENT_PKT_LEN, 1, NULL);
 		if (ret < 0) {			// error
 			info->serial_reopen = true;
 			notify_send_work_thread(lketc);
@@ -719,7 +723,7 @@ static bool lketc_read_response(struct cgpu_info *lketc)
 
 	cgtime(&info->workend);
 
-	memcpy(&nonce, evtpkt, sizeof(evtpkt));
+	memcpy(&nonce, evtpkt + info->read_data_offset, LKETC_EVENT_PKT_LEN);
 	nonce = be32toh(nonce);
 
 	mutex_lock(&info->lock);
@@ -809,6 +813,14 @@ static bool lketc_send_work(struct cgpu_info *lketc, struct work *work)
 	rev(cmdpkt + 4, 80);
 
 	if (using_libusb(info)) {	// in libusb mode we send via usb ;)
+#if LKETC_PROTOCOL_DEBUG
+		if (opt_lketc_debug) {
+			char *hexstr;
+			hexstr = bin2hex(cmdpkt, sizeof(cmdpkt));
+			applog(LOG_DEBUG, "> %s", hexstr);
+			free(hexstr);
+		}
+#endif
 		if (usb_write(lketc, (char *)cmdpkt, sizeof(cmdpkt), &ret, C_SENDWORK) != LIBUSB_SUCCESS ||
 			ret != sizeof(cmdpkt))
 			return false;
@@ -832,7 +844,7 @@ static void *lketc_send_work_thread(void *data)
 	struct timeval tv_now, tv_spent, tv_rem;
 	int retval;
 
-	snprintf(threadname, sizeof(threadname), "Zeus/%d", lketc->device_id);
+	snprintf(threadname, sizeof(threadname), "Lketc/%d", lketc->device_id);
 	RenameThread(threadname);
 	applog(LOG_INFO, "%s%d: serial I/O thread running, %s",
 						lketc->drv->name, lketc->device_id, threadname);
@@ -909,7 +921,6 @@ static int lketc_autoscan()
 	int found = 0;
 	applog(LOG_DEBUG, "lketc_autoscan() called");
 	found += serial_autodetect_udev(lketc_detect_one_serial, LKETC_USB_ID_MODEL_STR1);
-	found += serial_autodetect_udev(lketc_detect_one_serial, LKETC_USB_ID_MODEL_STR2);
 	return found;
 }
 
@@ -978,7 +989,7 @@ static int64_t lketc_scanwork(struct thr_info *thr)
 		return 0;
 	}
 
-	if (unlikely(lketc_read_response(lketc) < 0))  // reads either from serial or libusb or times out
+	if (unlikely(!lketc_read_response(lketc)))  // reads either from serial or libusb or times out
 		return 0;
 
 	if (thr->work_restart || thr->work_update) {
@@ -1134,7 +1145,7 @@ static void lketc_shutdown(struct thr_info *thr)
 
 struct device_drv lketc_drv = {
 		.drv_id = DRIVER_lketc,
-		.dname = "Zeus",
+		.dname = "LKETC",
 		.name = "LKE",
 		.max_diff = 32768,
 		.drv_detect = lketc_detect,

driver-lketc.h

@@ -20,7 +20,7 @@
 #define LKETC_READ_BUFFER		LKETC_EVENT_PKT_LEN + 2	// 2 = max value of read_data_offset; allows 2 extra FTDI status bytes
 
 #define LKETC_CLK_MAX			329	// 0xff * 3/2
-#define LKETC_CLK_MIN			2
+#define LKETC_CLK_MIN			180
 
 #define LKETC_USB_ID_MODEL_STR1		"CP2103_USB_to_UART_Bridge_Controller"
 #define LKETC_USB_ID_MODEL_STR2		"FT232R_USB_UART"
@@ -64,6 +64,7 @@ struct LKETC_INFO {
 	int		chips_count;
 	int		chip_clk;
 	int		chips_bit_num;		// log2(chips_count_max)
+	int		read_data_offset;
 };
 
 extern struct device_drv lketc_drv;

fpgautils.c

@@ -42,6 +42,93 @@
 #include "miner.h"
 #include "fpgautils.h"
 
+#ifdef WIN32
+ssize_t win32read(int fd, void *buf, size_t count)
+{
+	OVERLAPPED osRead = { 0 };
+	HANDLE fh;
+	DWORD win32errno;
+	size_t actual;
+	bool success = false;
+
+	fh = (HANDLE)_get_osfhandle(fd);
+	if (fh == INVALID_HANDLE_VALUE)
+		return -1;
+
+	// Create the overlapped event. Must be closed before exiting
+	// to avoid a handle leak.
+	osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	if (osRead.hEvent == NULL)
+		return -1;
+
+	// Issue read operation.
+	if (!ReadFile(fh, buf, count, (PDWORD)&actual, &osRead)) {
+		win32errno = GetLastError();
+		if (win32errno != ERROR_IO_PENDING) {
+			success = false;
+		} else {
+			// Write is pending
+			if (!GetOverlappedResult(fh, &osRead, (PDWORD)&actual, TRUE)) {
+				win32errno = GetLastError();
+				success = false;
+			} else {
+				// asynchronous read completed
+				success = true;
+			}
+		}
+	} else {
+		// read completed immediately
+		success = true;
+	}
+
+	CloseHandle(osRead.hEvent);
+	SetLastError(win32errno);
+	return (success) ? (ssize_t)actual : -1;
+}
+
+ssize_t win32write(int fd, const void *buf, size_t count)
+{
+	OVERLAPPED osWrite = { 0 };
+	HANDLE fh;
+	DWORD win32errno;
+	size_t actual;
+	bool success = false;
+
+	fh = (HANDLE)_get_osfhandle(fd);
+	if (fh == INVALID_HANDLE_VALUE)
+		return -1;
+
+	// Create this write operation's OVERLAPPED structure's hEvent.
+	osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	if (osWrite.hEvent == NULL)
+		return -1;
+
+	// Issue read operation.
+	if (!WriteFile(fh, buf, count, (PDWORD)&actual, &osWrite)) {
+		win32errno = GetLastError();
+		if (win32errno != ERROR_IO_PENDING) {
+			success = false;
+		} else {
+			// Write is pending
+			if (!GetOverlappedResult(fh, &osWrite, (PDWORD)&actual, TRUE)) {
+				win32errno = GetLastError();
+				success = false;
+			} else {
+				// asynchronous read completed
+				success = true;
+			}
+		}
+	} else {
+		// read completed immediately
+		success = true;
+	}
+
+	CloseHandle(osWrite.hEvent);
+	SetLastError(win32errno);
+	return (success) ? (ssize_t)actual : -1;
+}
+#endif
+
 #ifdef HAVE_LIBUDEV
 int serial_autodetect_udev(detectone_func_t detectone, const char*prodname)
 {
@@ -109,11 +196,10 @@ int serial_autodetect_devserial(__maybe_unused detectone_func_t detectone, __may
 #endif
 }
 
-int _serial_detect(struct device_drv *drv, detectone_func_t detectone, autoscan_func_t autoscan, bool forceauto)
+int _serial_detect(struct device_drv *drv, detectone_func_t detectone, autoscan_func_t autoscan, bool forceauto, bool inhibitauto)
 {
 	struct string_elist *iter, *tmp;
 	const char *dev, *colon;
-	bool inhibitauto = false;
 	char found = 0;
 	size_t namel = strlen(drv->name);
 	size_t dnamel = strlen(drv->dname);

fpgautils.h

@@ -13,18 +13,25 @@
 #include <stdbool.h>
 #include <stdio.h>
 
+#include "miner.h"
+
 typedef bool(*detectone_func_t)(const char*);
 typedef int(*autoscan_func_t)();
 
-extern int _serial_detect(struct device_drv *drv, detectone_func_t, autoscan_func_t, bool force_autoscan);
+#ifdef WIN32
+extern ssize_t win32read(int fd, void *buf, size_t count);
+extern ssize_t win32write(int fd, const void *buf, size_t count);
+#endif
+
+extern int _serial_detect(struct device_drv *drv, detectone_func_t, autoscan_func_t, bool force_autoscan, bool inhibit_autoscan);
 #define serial_detect_fauto(drv, detectone, autoscan)  \
-	_serial_detect(drv, detectone, autoscan, true)
+	_serial_detect(drv, detectone, autoscan, true, false)
 #define serial_detect_iauto(drv, detectone, autoscan)  \
-	_serial_detect(drv, detectone, autoscan, false)
+	_serial_detect(drv, detectone, autoscan, false, true)
 #define serial_detect_auto(drv, detectone, autoscan)  \
-	_serial_detect(drv, detectone, autoscan, false)
+	_serial_detect(drv, detectone, autoscan, false, false)
 #define serial_detect(drv, detectone)  \
-	_serial_detect(drv, detectone, NULL, false)
+	_serial_detect(drv, detectone, NULL, false, false)
 extern int serial_autodetect_devserial(detectone_func_t, const char *prodname);
 extern int serial_autodetect_udev(detectone_func_t, const char *prodname);
 

hexdump.c

@@ -30,7 +30,7 @@ static char nibble[] = {
 static void hexdump(const uint8_t *p, unsigned int len)
 {
 	unsigned int i, addr;
-	unsigned int wordlen = sizeof(unsigned int);
+	unsigned int wordlen = sizeof(void*);
 	unsigned char v, line[BYTES_PER_LINE * 5];
 
 	for (addr = 0; addr < len; addr += BYTES_PER_LINE) {

logging.h

@@ -126,5 +126,4 @@ extern void _simplelog(int prio, const char *str, bool force);
 } while (0)
 
 #endif
-
 #endif /* __LOGGING_H__ */