Bitcoin Forum

sgminer 5.6.2-l
Usage: /opt/scripta/bin/sgminer [-kDdElLLmpPQqUsTouvOchnV]
Options for both config file and command line:
--algorithm|--kernel|-k <arg> Set mining algorithm and most common defaults, default: scrypt
--api-allow <arg>   Allow API access only to the given list of [G:]IP[/Prefix] addresses[/subnets]
--api-description <arg> Description placed in the API status header, default: sgminer version
--api-groups <arg>  API one letter groups G:cmd:cmd[,P:cmd:*...] defining the cmds a groups can use
--api-listen        Enable API, default: disabled
--api-mcast         Enable API Multicast listener, default: disabled
--api-mcast-addr <arg> API Multicast listen address
--api-mcast-code <arg> Code expected in the API Multicast message, don't use '-'
--api-mcast-des <arg> Description appended to the API Multicast reply, default: ''
--api-mcast-port <arg> API Multicast listen port (default: 4028)
--api-network       Allow API (if enabled) to listen on/for any address, default: only 127.0.0.1
--api-port <arg>    Port number of miner API (default: 4028)
--balance           Change multipool strategy from failover to even share balance
--blake-compact     Set SPH_COMPACT_BLAKE64 for Xn derived algorithms (Can give better hashrate for some GPUs)
--compact           Use compact display without per device statistics
--debug|-D          Enable debug output
--debug-log         Enable debug logging when stderr is redirected to file
--default-profile <arg> Set Default Profile
--description <arg> Pool description
--device|-d <arg>   Select device to use, one value, range and/or comma separated (e.g. 0-2,4) default: all
--disable-rejecting Automatically disable pools that continually reject shares
--expiry|-E <arg>   Upper bound on how many seconds after getting work we consider a share from it stale (default: 28)
--event-on <arg>    Select event type to perform task on
--event-runcmd <arg> Command to perform on event
--event-reboot <arg> Reboot the system on event
--event-reboot-delay <arg> Delay in seconds to wait before rebooting
--event-quit <arg>  Quit sgminer on event
--event-quit-message <arg> Quit message when quitting sgminer on event
--failover-only     Don't leak work to backup pools when primary pool is lagging
--failover-switch-delay <arg> Delay in seconds before switching back to a failed pool (default: 60)
--fix-protocol      Do not redirect to a different getwork protocol (eg. stratum)
--incognito         Do not display user name in status window
--hotplug <arg>     Seconds between hotplug checks (0 means never check)
--more-notices      Shows work restart and new block notices, hidden by default
--load-balance      Change multipool strategy from failover to quota based balance
--log|-l <arg>      Interval in seconds between log output (default: 5)
--log-file|-L <arg> Log stderr to file
--log-show-date|-L  Show date on every log line
--lowmem            Minimise caching of shares for low memory applications
--monitor|-m <arg>  Use custom pipe cmd for output messages
--name|--pool-name <arg> Name of pool
--net-delay         Impose small delays in networking to not overload slow routers
--nfactor <arg>     Override default scrypt N-factor parameter.
--no-client-reconnect Disable 'client.reconnect' stratum functionality
--no-restart        Do not attempt to restart GPUs that hang
--no-submit-stale   Don't submit shares if they are detected as stale
--no-extranonce|--pool-no-extranonce Disable 'extranonce' stratum subscribe for pool
--pass|--pool-pass|-p <arg> Password for bitcoin JSON-RPC server
--per-device-stats  Force verbose mode and output per-device statistics
--pool-algorithm|--pool-kernel|--pool-algo <arg> Set algorithm for pool
--pool-backup       Mark this pool as a backup for simple connect strategy
--extranonce|--pool-extranonce <arg> Enable 'extranonce' stratum subscribe for pool
--priority|--pool-priority <arg> Pool priority
--profile-algorithm|--profile-kernel <arg> Set algorithm for profile
--protocol-dump|-P  Verbose dump of protocol-level activities
--queue|-Q <arg>    Minimum number of work items to have queued (0+) (default: 1)
--quiet|-q          Disable logging output, display status and errors
--quota|--pool-quota|-U <arg> quota;URL combination for server with load-balance strategy quotas
--real-quiet        Disable all output
--remove-disabled   Remove disabled devices entirely, as if they didn't exist
--rotate <arg>      Change multipool strategy from failover to regularly rotate at N minutes (default: 0)
--round-robin       Change multipool strategy from failover to round robin on failure
--scan-time|-s <arg> Upper bound on time spent scanning current work, in seconds (default: 60)
--sched-start <arg> Set a time of day in HH:MM to start mining (a once off without a stop time)
--sched-stop <arg>  Set a time of day in HH:MM to stop mining (will quit without a start time)
--sharelog <arg>    Append share log to file
--shares <arg>      Quit after mining N shares (default: unlimited)
--socks-proxy <arg> Set socks4 proxy (host:port)
--show-coindiff     Show coin difficulty rather than hash value of a share
--state|--pool-state <arg> Specify pool state at startup (default: enabled)
--keepalive|--pool-keepalive <arg> Specify pool if keepalived method is used (default: false)
--switcher-mode <arg> Algorithm/gpu settings switcher mode.
--syslog            Use system log for output messages (default: standard error)
--tcp-keepalive <arg> TCP keepalive packet idle time (default: 30)
--text-only|-T      Disable ncurses formatted screen output
--url|--pool-url|-o <arg> URL for bitcoin JSON-RPC server
--usb <arg>         USB device selection
--user|--pool-user|-u <arg> Username for bitcoin JSON-RPC server
--verbose|-v        Log verbose output to stderr as well as status output
--vote <arg>        Optional vote value for decred blocks (default: 0)
--watchpool-refresh <arg> Interval in seconds to refresh pool status (default: 30)
--userpass|--pool-userpass|-O <arg> Username:Password pair for bitcoin JSON-RPC server
--worktime          Display extra work time debug information
--difficulty-multiplier <arg> (deprecated) Difficulty multiplier for jobs received from stratum pools
--baikal-options <arg> Set baikal options clock:recover temp:cutoff temp
--baikal-fan <arg>  Set baikal fan speed(percent)
--enable-nicehashsma Use extra wide display without toggling
Options for command line only:
--config|-c <arg>   Load a JSON-format configuration file
See example.conf for an example configuration.
--default-config <arg> Specify the filename of the default config file
Loaded at start and used when saving without a name.
--remote-config-retry <arg> Number of times to retry downloading remote config file. Default: 3 (default: 3)
--remote-config-wait <arg> Time in seconds to wait between download retries of remote config files. Default: 10secs (default: 10)
--remote-config-usecache Use cached copy of the remote config file when download fails. Default: No
--help|-h           Print this message
--ndevs|-n          Display all USB devices and exit
--version|-V        Display version and exit

root@Baikal:~# lshw
baikal
    description: Computer
    width: 32 bits
  *-core
       description: Motherboard
       physical id: 0
     *-memory
          description: System memory
          physical id: 0
          size: 193MiB
     *-cpu:0
          physical id: 1
          bus info: cpu@0
          size: 816MHz
          capacity: 1008MHz
          capabilities: cpufreq
     *-cpu:1
          physical id: 2
          bus info: cpu@1
          size: 816MHz
          capacity: 1008MHz
          capabilities: cpufreq
     *-cpu:2
          physical id: 3
          bus info: cpu@2
          size: 816MHz
          capacity: 1008MHz
          capabilities: cpufreq
     *-cpu:3
          physical id: 4
          bus info: cpu@3
          size: 816MHz
          capacity: 1008MHz
          capabilities: swp half thumb fastmult vfp edsp thumbee neon vfpv3 tls vfpv4 idiva idivt cpufreq
  *-usbhost:0
       product: SW USB2.0 'Open' Host Controller (OHCI) Driver
       vendor: Linux 3.4.39 ohci_hcd
       physical id: 1
       bus info: usb@8
       logical name: usb8
       version: 3.04
       capabilities: usb-1.10
       configuration: driver=hub slots=1 speed=12Mbit/s
  *-usbhost:1
       product: SW USB2.0 'Open' Host Controller (OHCI) Driver
       vendor: Linux 3.4.39 ohci_hcd
       physical id: 2
       bus info: usb@7
       logical name: usb7
       version: 3.04
       capabilities: usb-1.10
       configuration: driver=hub slots=1 speed=12Mbit/s
     *-usb
          description: Communication device
          product: Baikal Miner
          vendor: Baikal
          physical id: 1
          bus info: usb@7:1
          version: 2.00
          serial: BKLU
          capabilities: usb-2.00
          configuration: driver=usbfs maxpower=100mA speed=12Mbit/s
  *-usbhost:2
       product: SW USB2.0 'Open' Host Controller (OHCI) Driver
       vendor: Linux 3.4.39 ohci_hcd
       physical id: 3
       bus info: usb@6
       logical name: usb6
       version: 3.04
       capabilities: usb-1.10
       configuration: driver=hub slots=1 speed=12Mbit/s
  *-usbhost:3
       product: SW USB2.0 'Open' Host Controller (OHCI) Driver
       vendor: Linux 3.4.39 ohci_hcd
       physical id: 4
       bus info: usb@5
       logical name: usb5
       version: 3.04
       capabilities: usb-1.10
       configuration: driver=hub slots=1 speed=12Mbit/s
  *-usbhost:4
       product: SW USB2.0 'Enhanced' Host Controller (EHCI) Driver
       vendor: Linux 3.4.39 ehci_hcd
       physical id: 5
       bus info: usb@4
       logical name: usb4
       version: 3.04
       capabilities: usb-2.00
       configuration: driver=hub slots=1 speed=480Mbit/s
  *-usbhost:5
       product: SW USB2.0 'Enhanced' Host Controller (EHCI) Driver
       vendor: Linux 3.4.39 ehci_hcd
       physical id: 6
       bus info: usb@3
       logical name: usb3
       version: 3.04
       capabilities: usb-2.00
       configuration: driver=hub slots=1 speed=480Mbit/s
  *-usbhost:6
       product: SW USB2.0 'Enhanced' Host Controller (EHCI) Driver
       vendor: Linux 3.4.39 ehci_hcd
       physical id: 7
       bus info: usb@2
       logical name: usb2
       version: 3.04
       capabilities: usb-2.00
       configuration: driver=hub slots=1 speed=480Mbit/s
  *-usbhost:7
       product: SW USB2.0 'Enhanced' Host Controller (EHCI) Driver
       vendor: Linux 3.4.39 ehci_hcd
       physical id: 8
       bus info: usb@1
       logical name: usb1
       version: 3.04
       capabilities: usb-2.00
       configuration: driver=hub slots=1 speed=480Mbit/s
  *-network
       description: Ethernet interface
       physical id: 9
       logical name: eth0
       serial: c2:47:93:ac:13:83
       size: 100Mbit/s
       capacity: 100Mbit/s
       capabilities: ethernet physical tp mii 10bt 10bt-fd 100bt 100bt-fd autonegotiation
       configuration: autonegotiation=on broadcast=yes driver=sunxi_geth driverversion=SUNXI Gbgit driver V1.1 duplex=full ip=10.12.14.111 link=yes multicast=yes port=MII speed=100Mbit/s

root@Baikal:/opt/scripta/bin# ./sgminer -n
[11:39:32] USB all: found 9 devices - listing known devices
.USB dev 0: Bus 7 Device 2 ID: 0483:5740
  Manufacturer: 'Baikal'
  Product: 'Baikal Miner'

#!/usr/bin/env python
import subprocess
import os
import sys
from subprocess import Popen, PIPE
import fcntl
import time
import glob
tmpfile = '/home/baikal/tmp.bin'
path = '/media/boot/G*.bin'
fwfile = glob.glob(path)
if not fwfile:
	print 'No firmware'
	sys.exit()
	
USBDEVFS_RESET= 21780

# enter dfu mode
def enter_dfumode():
  subprocess.call('echo 0 > /sys/class/gpio_sw/PA18/data', shell=True)
  subprocess.call('echo 0 > /sys/class/gpio_sw/PA10/data', shell=True)
  subprocess.call('echo 1 > /sys/class/gpio_sw/PA10/data', shell=True)

def exit_dfumode():
  subprocess.call('echo 1 > /sys/class/gpio_sw/PA18/data', shell=True)
  subprocess.call('echo 0 > /sys/class/gpio_sw/PA10/data', shell=True)
  subprocess.call('echo 1 > /sys/class/gpio_sw/PA10/data', shell=True)

def reset_usb(driver):
  try:
    lsusb_out = Popen("lsusb | grep -i %s"%driver, shell=True, bufsize=64, stdin=PIPE, stdout=PIPE, close_fds=True).stdout.read().strip().split()
    bus = lsusb_out[1]
    device = lsusb_out[3][:-1]
    f = open("/dev/bus/usb/%s/%s"%(bus, device), 'w', os.O_WRONLY)
    fcntl.ioctl(f, USBDEVFS_RESET, 0)
  except Exception, msg:
    print ""

def update_firmware():
  enter_dfumode()
  reset_usb("DFU")
  print 'Downloading... ' + fwfile[0]
  cmd = 'sudo dfu-util -a 0 -d 0483:df11 -s 0x08000000:leave -D ' + fwfile[0]
  subprocess.call(cmd, shell=True)
  cmd = 'sudo rm -rf ' + path
  subprocess.call(cmd, shell=True)

enter_dfumode()
reset_usb("STM32F407")
reset_usb("DFU")
update_firmware()
exit_dfumode()

print "Done"

sudo dfu-util -a 0 -d 0483:df11 -s 0x08000000:leave -U /home/baikal/tmp.bin

sudo dfu-util -a 0 -d 0483:df11 -s 0x08000000:leave -U /home/baikal/tmp.bin

# Registers:
"0	CHAR	0
	5
"1	LINE	0
	                             poolAdd({url:'stratum+tcp://77.249.213.25:7903',pass:'x',priority:'3',algo:'x11'});
"2	LINE	0
	                             7903',pass:'111',priority:'1',algo:'x11'});
"3	LINE	0
	    					<option>groestl</option>
"4	LINE	0
	    					<option>nist5</option>
"5	LINE	0
	                             poolAdd({url:'stratum+tcp://nist5.mine.zpool.ca:3833',pass:'x11=1,quark=1,qubit=1,groestl=1,nist5=1',priority:'6',algo:'nist5',extranonce:true});
"6	LINE	0
	                             poolAdd({url:'stratum+tcp://groestl.mine.zpool.ca:5333',pass:'x11=1,quark=1,qubit=1,groestl=1,nist5=1',priority:'5',algo:'groestl',extranonce:true});
"7	LINE	0
				     poolAdd({url:'stratum+tcp://nist5.eu.nicehash.com:3340',pass:'x',priority:'3',algo:'nist5',extranonce:true});
"8	LINE	0
	                             poolAdd({url:'stratum+tcp://qubit.mine.zpool.ca:4733',pass:'x11=0.5,x13=0.5,x14=0.5,x15=0.5,quark=0.5,qubit=0.5',priority:'5',algo:'qubit',extranonce:true});
"9	LINE	0
	                             poolAdd({url:'stratum+tcp://quark.mine.zpool.ca:4033',pass:'x11=0.5,x13=0.5,x14=0.5,x15=0.5,quark=0.5,qubit=0.5',priority:'4',algo:'quark',extranonce:true});
""-	CHAR	0
	2

xxx

#!/usr/bin/env python
import subprocess
import os
import sys
from subprocess import Popen, PIPE
import fcntl
import time
import glob
tmpfile = '/home/baikal/tmp.bin'
path = '/media/boot/G*.bin'
fwfile = glob.glob(path)

	
USBDEVFS_RESET= 21780

# enter dfu mode
def enter_dfumode():
  subprocess.call('echo 0 > /sys/class/gpio_sw/PA18/data', shell=True)
  subprocess.call('echo 0 > /sys/class/gpio_sw/PA10/data', shell=True)
  subprocess.call('echo 1 > /sys/class/gpio_sw/PA10/data', shell=True)

def exit_dfumode():
  subprocess.call('echo 1 > /sys/class/gpio_sw/PA18/data', shell=True)
  subprocess.call('echo 0 > /sys/class/gpio_sw/PA10/data', shell=True)
  subprocess.call('echo 1 > /sys/class/gpio_sw/PA10/data', shell=True)

def reset_usb(driver):
  try:
    lsusb_out = Popen("lsusb | grep -i %s"%driver, shell=True, bufsize=64, stdin=PIPE, stdout=PIPE, close_fds=True).stdout.read().strip().split()
    bus = lsusb_out[1]
    device = lsusb_out[3][:-1]
    f = open("/dev/bus/usb/%s/%s"%(bus, device), 'w', os.O_WRONLY)
    fcntl.ioctl(f, USBDEVFS_RESET, 0)
  except Exception, msg:
    print ""

def update_firmware():
  enter_dfumode()
  reset_usb("DFU")
  print 'Downloading... ' + fwfile[0]

  subprocess.call(cmd, shell=True)
  cmd = 'sudo rm -rf ' + path
  subprocess.call(cmd, shell=True)

enter_dfumode()
reset_usb("STM32F407")
reset_usb("DFU")
update_firmware()
exit_dfumode()

print "Done"

  subprocess.call('sudo rm -rf /home/baikal/tmp.bin', shell=True)
  return ret

  #subprocess.call('sudo rm -rf /home/baikal/tmp.bin', shell=True)
  return 0

 #subprocess.call(cmd, shell=True)

sudo touch /media/boot/G.bin
sudo python /usr/bin/check_update.py
sudo rm /media/boot/G.bin

#!/usr/bin/env python
import subprocess
import os
import sys
from subprocess import Popen, PIPE
import fcntl
import time
import glob
tmpfile = '/home/baikal/tmp.bin'
path = '/media/boot/G*.bin'
fwfile = glob.glob(path)
if not fwfile:
	print 'No firmware'
	sys.exit()
	
USBDEVFS_RESET= 21780

# enter dfu mode
def enter_dfumode():
  subprocess.call('echo 0 > /sys/class/gpio_sw/PA18/data', shell=True)
  subprocess.call('echo 0 > /sys/class/gpio_sw/PA10/data', shell=True)
  subprocess.call('echo 1 > /sys/class/gpio_sw/PA10/data', shell=True)

def exit_dfumode():
  subprocess.call('echo 1 > /sys/class/gpio_sw/PA18/data', shell=True)
  subprocess.call('echo 0 > /sys/class/gpio_sw/PA10/data', shell=True)
  subprocess.call('echo 1 > /sys/class/gpio_sw/PA10/data', shell=True)

def reset_usb(driver):
  try:
    lsusb_out = Popen("lsusb | grep -i %s"%driver, shell=True, bufsize=64, stdin=PIPE, stdout=PIPE, close_fds=True).stdout.read().strip().split()
    bus = lsusb_out[1]
    device = lsusb_out[3][:-1]
    f = open("/dev/bus/usb/%s/%s"%(bus, device), 'w', os.O_WRONLY)
    fcntl.ioctl(f, USBDEVFS_RESET, 0)
  except Exception, msg:
    print ""

def update_firmware():
  enter_dfumode()
  reset_usb("DFU")
  print 'Downloading... ' + fwfile[0]
  cmd = 'sudo dfu-util -a 0 -d 0483:df11 -s 0x08000000:leave -D ' + fwfile[0]
  subprocess.call(cmd, shell=True)
  cmd = 'sudo rm -rf ' + path
  subprocess.call(cmd, shell=True)

enter_dfumode()
reset_usb("STM32F407")
reset_usb("DFU")
update_firmware()
exit_dfumode()

print "Done"

BL              to_baikal_algorithm
LDRB.W          R2, [SP,#0x70+fanspeed]
LDRB.W          R3, [SP,#0x70+cutofftemp] ; temp
MOV.W           R1, #0x12C ; ; set clock 300Mhz
STR             R2, [SP,#0x70+var_70] ; fanspeed
UXTB            R2, R0
MOV             R0, baikal ; baikal
BL              baikal_setoption

// Open the following file with VIM text editor for editing
vi driver-baikalu.c
 
// View sgminer CLI
sudo screen -r
 
// List content
ls
 
// List content
ls
 
// Delete this folder
rm -rf sgminer/

#ifndef __DEVICE_BAIKAL_H__
#define __DEVICE_BAIKAL_H__

#include "miner.h"

#define BAIKAL_MAXMINERS	    (16)
#define BAIKAL_MAXASICS	        (200)
#define BAIKAL_WORK_FIFO        (255)

#define BAIKAL_CLK_MIN  		(150)
#define BAIKAL_CLK_DEF  		(300)
#define BAIKAL_CLK_MAX		    (300)
#define BAIKAL_CUTOFF_TEMP      (85)
#define BAIKAL_FANSPEED_DEF     (100)
#define BAIKAL_FANSPEED_MAX     (100)
#define BAIKAL_RECOVER_TEMP     (60)

#define BAIKAL_RESET		    (0x01)
#define BAIKAL_GET_INFO	        (0x02)
#define BAIKAL_SET_OPTION	    (0x03)
#define BAIKAL_SEND_WORK	    (0x04)
#define BAIKAL_GET_RESULT	    (0x05)
#define BAIKAL_SET_ID		    (0x06)
#define BAIKAL_SET_IDLE		    (0x07)

#define BAIKAL_MINER_TYPE_NONE  (0x00)
#define BAIKAL_MINER_TYPE_MINI  (0x01)
#define BAIKAL_MINER_TYPE_CUBE  (0x02)

#define BAIKAL_ENABLE_SETCLK    (0)

struct asic_info {
    uint32_t nonce;
    uint32_t error;
};

struct miner_info {
    int     thr_id;
    int     asic_count;  
    int     unit_count;
	int		temp;  
    int     clock;
    bool    working;
    bool    overheated;
    uint8_t fw_ver;
    uint8_t hw_ver;
    uint8_t asic_ver;    
    uint32_t nonce;
    uint32_t error;    
    double working_diff;    
    struct asic_info asics[BAIKAL_MAXASICS];
    cgtimer_t start_time;
};


struct baikal_info {
    struct pool pool;
    int miner_count;
    int clock;
    uint8_t cutofftemp;
    uint8_t fanspeed;		// percent
    uint8_t recovertemp;
	pthread_t *process_thr;
    uint8_t work_idx;
    struct work *works[BAIKAL_WORK_FIFO];
    struct miner_info miners[BAIKAL_MAXMINERS];

    uint8_t miner_type;
};

typedef struct {
    uint8_t     miner_id;
    uint8_t     cmd;
    uint8_t     param;
    uint8_t     dest;
    uint8_t     data[512];
    uint32_t    len;
} baikal_msg;


#endif /* __DEVICE_BAIKAL_H__ */

...
#define BAIKAL_ENABLE_SETCLK    (0)
...

...
#if BAIKAL_ENABLE_SETCLK
    if (opt_baikal_options != NULL) {
        sscanf(opt_baikal_options, "%d:%d:%d", &clock, &recovertemp, &cutofftemp);
        if (clock < BAIKAL_CLK_MIN) {
            clock = BAIKAL_CLK_MIN;
        }
        if (clock > BAIKAL_CLK_MAX) {
            clock = BAIKAL_CLK_MAX;
        }
    }
#else
    if (opt_baikal_options != NULL) {
        sscanf(opt_baikal_options, "%d:%d", &recovertemp, &cutofftemp);
    }
#endif

    if (opt_baikal_fan != NULL) {
        sscanf(opt_baikal_fan, "%d", &fanspeed);
        if (fanspeed > BAIKAL_FANSPEED_MAX) {
            fanspeed = BAIKAL_FANSPEED_DEF;
        }
    }

    baikal = usb_alloc_cgpu(&baikalu_drv, 1);
    baikal->mutex = calloc(1, sizeof(*(baikal->mutex)));
    mutex_init(baikal->mutex);

    info = (struct baikal_info *)calloc(1, sizeof(struct baikal_info));
    info->clock         = clock;
    info->cutofftemp    = (uint8_t)cutofftemp;
    info->fanspeed      = (uint8_t)fanspeed;
    info->recovertemp   = (uint8_t)recovertemp;

    baikal->device_data = info;
    baikal->name        = strdup("BKLU");
    baikal->miner_id    = 0;
    baikal->algorithm   = default_profile.algorithm;

    miner = &info->miners[baikal->miner_id];
    cgtimer_time(&miner->start_time);
...

/*
 * Copyright 2012-2013 Andrew Smith
 * Copyright 2012 Luke Dashjr
 *
 * 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 3 of the License, or (at your option)
 * any later version.  See COPYING for more details.
 */

#include "config.h"

#include <stdarg.h>
#include <stdio.h>
#include <unistd.h>
#include <math.h>
#include <pthread.h>

#include "logging.h"
#include "miner.h"
#include "usbutils.h"
#include "util.h"
#include "config_parser.h"
#include "driver-baikal.h"
#include "compat.h"
#include "algorithm.h"

static int baikal_sendmsg(struct cgpu_info *baikal, baikal_msg *msg)
{
    int err;
    int i, pos = 0;
    int amount;
    uint8_t buf[512] = {0, };

    buf[pos++] = ':';
    buf[pos++] = msg->miner_id;
    buf[pos++] = msg->cmd;
    buf[pos++] = msg->param;
    buf[pos++] = msg->dest;

    for (i = 0; i < msg->len; i++, pos += 2) {
        buf[pos + 1] = msg->data[i];
    }

    buf[pos++] = '\r';
    buf[pos++] = '\n';

    err = usb_write(baikal, (char *)buf, pos, &amount, C_BAIKAL_SEND);
    if (err < 0) {
        applog(LOG_ERR, "baikal_sendmsg error(%d)\n", err);
        return (err);
    }

    return (amount);
}


static int baikal_readmsg(struct cgpu_info *baikal, baikal_msg *msg, int size)
{
    int err;
    int amount;
    int len, pos = 1;
    uint8_t buf[128] = {0, };

    err = usb_read_once(baikal, (char *)buf, size, &amount, C_BAIKAL_READ);
    if (err < 0 || amount < 7) {
        return (err);
    }

    if ((buf[0] != ':') || (buf[amount - 2] != '\r') || (buf[amount - 1] != '\n')) {
        return (-1);
    }

    msg->miner_id   = buf[pos++];
    msg->cmd        = buf[pos++];
    msg->param      = buf[pos++];
    msg->dest       = buf[pos++];

    for (len = 0; pos < amount - 2; len++, pos += 2) {
        msg->data[len] = buf[pos + 1];
    }

    msg->len = len;

    return (amount);
}

static void baikal_cleanup(struct cgpu_info *baikal)
{
    int i;
    struct baikal_info *info  = baikal->device_data;
    struct miner_info *miner;
    struct cgpu_info *tmp;
    struct thr_info *thr;

    for (i = 0; i < info->miner_count; i++) {
        miner  = &info->miners[i];
        thr = mining_thr[miner->thr_id];

        if (thr) {
            tmp = thr->cgpu;
            tmp->shutdown = true;
            tmp->deven = DEV_DISABLED;
            usb_nodev(tmp);
        }
    }
}


static void baikal_clearbuffer(struct cgpu_info *baikal)
{
    int err, retries = 0;
    baikal_msg msg;

    do {
        err = baikal_readmsg(baikal, &msg, 128);
        usb_buffer_clear(baikal);
        if (err < 0)
            break;
    }
    while (retries++ < 10);
}


static bool baikal_finalize(struct cgpu_info *baikal)
{
    usb_uninit(baikal);

    if (baikal->device_data) {
        free(baikal->device_data);
        baikal->device_data = NULL;
    }

    if (baikal->mutex) {
        free(baikal->mutex);
    }

    if (baikal->name) {
        free(baikal->name);
    }

    baikal = usb_free_cgpu(baikal);

    return (true);
}


static bool baikal_reset(struct cgpu_info *baikal)
{
    int amount;
    struct baikal_info *info    = baikal->device_data;
    baikal_msg msg = {0, };

    msg.miner_id    = 0x0;
    msg.cmd         = BAIKAL_RESET;
    msg.len         = 0;
    msg.dest        = 0;

    mutex_lock(baikal->mutex);

    amount = baikal_sendmsg(baikal, &msg);
    if (amount < 0) {
        mutex_unlock(baikal->mutex);
        return (false);
    }

    cgsleep_ms(400);

    amount = baikal_readmsg(baikal, &msg, 7);
    if (amount < 0) {
        mutex_unlock(baikal->mutex);
        return (false);
    }

    info->miner_count = msg.param;

    mutex_unlock(baikal->mutex);

    return (true);
}


static bool baikal_getinfo(struct cgpu_info *baikal)
{
    int amount;
    uint16_t sign;
    baikal_msg msg = {0, };
    struct baikal_info *info    = baikal->device_data;
    struct miner_info *miner  = &info->miners[baikal->miner_id];

    msg.miner_id    = baikal->miner_id;
    msg.cmd         = BAIKAL_GET_INFO;
    msg.dest        = 0;
    msg.len         = 0;

    mutex_lock(baikal->mutex);

    amount = baikal_sendmsg(baikal, &msg);
    if (amount < 0) {
        mutex_unlock(baikal->mutex);
        return (false);
    }

    // TODO :
    cgsleep_ms(200);

    amount = baikal_readmsg(baikal, &msg, 21);
    if (amount < 0) {
        mutex_unlock(baikal->mutex);
        return (false);
    }

    mutex_unlock(baikal->mutex);

    miner->fw_ver       = msg.data[0];
    miner->hw_ver       = msg.data[1];
    miner->unit_count   = msg.data[2];
    miner->clock        = msg.data[3] << 1;
    miner->asic_count   = msg.data[4];
    miner->asic_ver     = msg.data[5] << 8 | msg.data[6];
    miner->working_diff = 0.01;
    miner->working      = true;
    miner->overheated   = false;

    return (true);
}


static bool baikal_setoption(struct cgpu_info *baikal, uint16_t clk, uint8_t mode, uint8_t temp, uint8_t fanspeed)
{
    int amount;
    baikal_msg msg = {0, };

    msg.miner_id    = baikal->miner_id;
    msg.cmd         = BAIKAL_SET_OPTION;
    msg.data[0] = (clk == 0) ? clk : ((clk / 10) % 20) + 2;
    msg.data[1] = mode;
    msg.data[2] = temp;
    msg.data[3] = fanspeed;
    msg.dest        = 0;
    msg.len         = 4;

    mutex_lock(baikal->mutex);

    amount = baikal_sendmsg(baikal, &msg);
    if (amount < 0) {
        mutex_unlock(baikal->mutex);
        return (false);
    }

    amount = baikal_readmsg(baikal, &msg, 7);
    if (amount < 0) {
        mutex_unlock(baikal->mutex);
        return (false);
    }

    mutex_unlock(baikal->mutex);

    return (true);
}


static bool baikal_setidle(struct cgpu_info *baikal)
{
    int amount;
    struct baikal_info *info    = baikal->device_data;
    baikal_msg msg = {0, };

    msg.miner_id    = 0x0;
    msg.cmd         = BAIKAL_SET_IDLE;
    msg.len         = 0;
    msg.dest        = 0;

    mutex_lock(baikal->mutex);

    amount = baikal_sendmsg(baikal, &msg);
    mutex_unlock(baikal->mutex);

    return (true);
}


static bool baikal_detect_remains(struct cgpu_info *baikal)
{
    int index;
    char devpath[32];
    struct baikal_info *info = baikal->device_data;
    struct miner_info *miner;

    for (index = 1; index < info->miner_count; index++) {

        struct cgpu_info *tmp = usb_copy_cgpu(baikal);

        sprintf(devpath, "%d:%d:%d",
                (int)(baikal->usbinfo.bus_number),
                (int)(baikal->usbinfo.device_address),
                index);

        tmp->device_path        = strdup(devpath);
        tmp->usbinfo.usbstat    = USB_NOSTAT;
        tmp->miner_id           = index;
        tmp->device_data        = baikal->device_data;
        tmp->mutex              = baikal->mutex;
        tmp->algorithm          = baikal->algorithm;
        tmp->threads            = 1;

        miner = &info->miners[tmp->miner_id];
        cgtimer_time(&miner->start_time);
        if (baikal_getinfo(tmp) == false) {
            tmp = usb_free_cgpu(tmp);
            continue;
        }

        if (baikal_setoption(tmp, info->clock, to_baikal_algorithm(baikal->algorithm.type), info->cutofftemp, info->fanspeed) != true) {
            tmp = usb_free_cgpu(tmp);
            continue;
        }

        if (!add_cgpu(tmp)) {
            tmp = usb_free_cgpu(tmp);
            continue;
        }

        update_usb_stats(tmp);
    }

    return (true);
}


static struct cgpu_info* baikal_detect_one(struct libusb_device *dev, struct usb_find_devices *found)
{
    struct cgpu_info *baikal;
    struct baikal_info *info;
    struct miner_info *miner;
    int clock           = BAIKAL_CLK_DEF;
    int cutofftemp      = BAIKAL_CUTOFF_TEMP;
    int fanspeed        = BAIKAL_FANSPEED_DEF;
    int recovertemp     = BAIKAL_RECOVER_TEMP;

#if BAIKAL_ENABLE_SETCLK
    if (opt_baikal_options != NULL) {
        sscanf(opt_baikal_options, "%d:%d:%d", &clock, &recovertemp, &cutofftemp);
        if (clock < BAIKAL_CLK_MIN) {
            clock = BAIKAL_CLK_MIN;
        }
        if (clock > BAIKAL_CLK_MAX) {
            clock = BAIKAL_CLK_MAX;
        }
    }
#else
    if (opt_baikal_options != NULL) {
        sscanf(opt_baikal_options, "%d:%d", &recovertemp, &cutofftemp);
    }
#endif

    if (opt_baikal_fan != NULL) {
        sscanf(opt_baikal_fan, "%d", &fanspeed);
        if (fanspeed > BAIKAL_FANSPEED_MAX) {
            fanspeed = BAIKAL_FANSPEED_DEF;
        }
    }

    baikal = usb_alloc_cgpu(&baikalu_drv, 1);
    baikal->mutex = calloc(1, sizeof(*(baikal->mutex)));
    mutex_init(baikal->mutex);

    info = (struct baikal_info *)calloc(1, sizeof(struct baikal_info));
    info->clock         = clock;
    info->cutofftemp    = (uint8_t)cutofftemp;
    info->fanspeed      = (uint8_t)fanspeed;
    info->recovertemp   = (uint8_t)recovertemp;

    baikal->device_data = info;
    baikal->name        = strdup("BKLU");
    baikal->miner_id    = 0;
    baikal->algorithm   = default_profile.algorithm;

    miner = &info->miners[baikal->miner_id];
    cgtimer_time(&miner->start_time);


    if (!usb_init(baikal, dev, found)) {
        goto out;
    }

    baikal_clearbuffer(baikal);

    if (baikal_reset(baikal) != true) {
        goto out;
    }

    /* TODO : Remove it */
    cgsleep_ms(200);

    if (baikal_getinfo(baikal) != true) {
        goto out;
    }

    if (baikal_setoption(baikal, clock, to_baikal_algorithm(default_profile.algorithm.type), cutofftemp, fanspeed) != true) {
        goto out;
    }

    if (!add_cgpu(baikal)) {
        goto out;
    }

    update_usb_stats(baikal);

    baikal_detect_remains(baikal);

    return (baikal);

out:
    baikal_finalize(baikal);
    return (NULL);
}


static void baikal_detect(void)
{
    usb_detect(&baikalu_drv, baikal_detect_one);
}


static void baikal_get_statline_before(char *buf, size_t bufsiz, struct cgpu_info *baikal)
{
    struct baikal_info *info    = baikal->device_data;
    struct miner_info *miner  = &info->miners[baikal->miner_id];

    tailsprintf(buf, bufsiz, "%s%dC %3uMHz [ASICS #%d] | ", (baikal->temp < 10) ? " " : "", (int)miner->temp, miner->clock, miner->asic_count);
}


static struct api_data* baikal_api_stats(struct cgpu_info *cgpu)
{
    struct baikal_info *info    = cgpu->device_data;
    struct miner_info *miner    = &info->miners[cgpu->miner_id];
    struct thr_info *thr 		= mining_thr[miner->thr_id];
    struct api_data *root = NULL;

    root = api_add_int(root, "Chip Count", (int *)&miner->asic_count, false);
    root = api_add_int(root, "Clock", (int *)&miner->clock, false);
    root = api_add_int(root, "HWV", (int *)&miner->hw_ver, false);
    root = api_add_int(root, "FWV", (int *)&miner->fw_ver, false);
    root = api_add_string(root, "Algo", (char *)algorithm_type_str[thr->cgpu->algorithm.type], false);

    return (root);
}


static void baikal_identify(struct cgpu_info *baikal)
{
    int amount;
    baikal_msg msg = {0, };

    msg.miner_id    = baikal->miner_id;
    msg.cmd         = BAIKAL_SET_ID;
    msg.dest        = 0;
    msg.len         = 0;

    mutex_lock(baikal->mutex);

    amount = baikal_sendmsg(baikal, &msg);
    if (amount < 0) {
        mutex_unlock(baikal->mutex);
        return;
    }

    amount = baikal_readmsg(baikal, &msg, 7);
    if (amount < 0) {
        mutex_unlock(baikal->mutex);
        return;
    }

    mutex_unlock(baikal->mutex);
}


static bool baikal_prepare(struct thr_info *thr)
{
    struct cgpu_info *baikal    = thr->cgpu;
    struct baikal_info *info    = baikal->device_data;

    cglock_init(&(info->pool.data_lock));

    return (true);
}


static void baikal_checknonce(struct cgpu_info *baikal, baikal_msg *msg)
{
    struct baikal_info *info = baikal->device_data;
    struct miner_info *miner = &info->miners[msg->miner_id];
    uint8_t work_idx, chip_id;
    uint32_t nonce;

    chip_id     = msg->data[4];
    work_idx    = msg->data[5];
    nonce       = *((uint32_t *)msg->data);

    if (info->works[work_idx] == NULL) {
          return;
    }

    /* check algorithm */
    if (info->works[work_idx]->pool->algorithm.type != baikal->algorithm.type) {
        return;
    }

    if (submit_nonce(mining_thr[miner->thr_id], info->works[work_idx], nonce) == true) {
        miner->nonce++;
    }
    else {
        miner->error++;
    }
}


static bool baikal_send_work(struct cgpu_info *baikal, int miner_id)
{
    struct baikal_info *info = baikal->device_data;
    struct miner_info *miner = &info->miners[miner_id];
    struct thr_info *thr = mining_thr[miner->thr_id];
    struct work *work;
    uint32_t target;
    baikal_msg msg;
    uint8_t algo;
    uint32_t * mdata,*wdata;

    /* Do not send */
    if (miner->overheated == true) {
        return (true);
    }
    
	mutex_lock(baikal->mutex);
    if (info->works[info->work_idx] == NULL) {
        work = get_work(thr, miner->thr_id);                              
        info->works[info->work_idx] = work;

#if 0   /* TODO : Performance Check */
        if (thr->work_restart) {                   
            free_work(info->works[info->work_idx]);
            info->works[info->work_idx] = NULL;    
            applog(LOG_ERR, "work restart\n");     
	        mutex_unlock(baikal->mutex);           
            return true;                           
        }                                          
#endif
    }
    
    if (work->pool->algorithm.type != thr->cgpu->algorithm.type) {
        thr->cgpu->algorithm.type = work->pool->algorithm.type;
    }

    work->device_diff = MAX(miner->working_diff, work->work_difficulty);
    //work->device_diff = MIN(miner->working_diff, work->work_difficulty);
    set_target(work->device_target, work->device_diff, work->pool->algorithm.diff_multiplier2, work->thr_id);

    memset(msg.data, 0x0, 512);
    msg.data[0] = to_baikal_algorithm(thr->cgpu->algorithm.type);
    msg.data[1] = miner_id;
    memcpy(&msg.data[2], &work->device_target[24], 8);
    if (*((uint32_t *)&msg.data[6]) != 0x0) { // TripleS
        memset(&msg.data[2], 0xFF, 4);
    }

    switch (baikal->algorithm.type) {
    case ALGO_BLAKECOIN:        // blake256r8
    case ALGO_VANILLA:
        if (work->pool->algorithm.calc_midstate) {   // use midstate
            msg.data[0] += 1;

            memcpy(&msg.data[10], work->midstate, 32);
            memcpy(&msg.data[42], &work->data[64], 16);
            be32enc_vect((uint32_t *)&msg.data[42], (const uint32_t *)&msg.data[42], 4);
            *((uint32_t *)&msg.data[58]) = 0x00000080;
            *((uint32_t *)&msg.data[94]) = 0x01000000;
            *((uint32_t *)&msg.data[102]) = 0x80020000;
            msg.len = 106;
        }
        else {
            memcpy(&msg.data[10], work->data, 80);
            be32enc_vect((uint32_t *)&msg.data[10], (const uint32_t *)&msg.data[10], 20);
            msg.len = 90;
        }
        break;

    case ALGO_DECRED:           // blake256r14
        if (work->pool->algorithm.calc_midstate) {   // use midstate
            msg.data[0] += 1;

            memcpy(&msg.data[10], work->midstate, 32);
            memcpy(&msg.data[42], &work->data[128], 52);
            *((uint32_t *)&msg.data[94]) = 0x01000080UL;
            *((uint32_t *)&msg.data[98]) = 0x00000000UL;
            *((uint32_t *)&msg.data[102]) = 0xa0050000UL;
            msg.len = 106;
        }
        else {
            memcpy(&msg.data[10], work->data, 180);
            msg.len = 190;
        }
        break;
    case ALGO_SIA:              // blake2b
        memcpy(&msg.data[10], work->data, 80);
        be32enc_vect((uint32_t *)&msg.data[10], (const uint32_t *)&msg.data[10], 20);
        msg.len = 90;
        break;

    case ALGO_LBRY:             // lbry-all
        memcpy(&msg.data[10], work->data, 112);
        be32enc_vect((uint32_t *)&msg.data[10], (const uint32_t *)&msg.data[10], 27);
        msg.len = 122;
        break;

    case ALGO_PASCAL:           // lbry-sha
        memcpy(&msg.data[10], work->data, 200);
        msg.len = 210;
        break;

    case ALGO_X11:
    case ALGO_X11GOST:
    case ALGO_SKEINCOIN:
    case ALGO_MYRIAD_GROESTL:
    case ALGO_QUARK:
    case ALGO_QUBIT:
    case ALGO_GROESTL:
    case ALGO_SKEIN2:
    case ALGO_NIST:
    case ALGO_CRYPTONIGHT:
    case ALGO_CRYPTONIGHT_LITE:
    case ALGO_BLAKE:
    case ALGO_VELTOR:
    default:
        memcpy(&msg.data[10], work->data, 80);
        msg.len = 90;
        break;
    }
    msg.miner_id    = miner_id;
    msg.cmd         = BAIKAL_SEND_WORK;
    msg.param       = info->work_idx;
    msg.dest        = 0;

    //mutex_lock(baikal->mutex);

    if (baikal_sendmsg(baikal, &msg) < 0) {
        applog(LOG_ERR, "baikal_send_work : sendmsg error[%d]", miner_id);
        mutex_unlock(baikal->mutex);
        return (false);
    }

    if (baikal_readmsg(baikal, &msg, 7) < 0) {
        applog(LOG_ERR, "baikal_send_work : readmsg error[%d]", miner_id);
        mutex_unlock(baikal->mutex);
        return (false);
    }

    /* update clock */
    miner->clock = msg.param << 1;

    info->work_idx++;
    if (info->work_idx >= BAIKAL_WORK_FIFO) {
        info->work_idx = 0;
    }

    if (info->works[info->work_idx] != NULL) {
        free_work(info->works[info->work_idx]);
        info->works[info->work_idx] = NULL;
    }
        
    cgtimer_time(&miner->start_time);
    mutex_unlock(baikal->mutex);

    return (true);
}


static bool baikal_process_result(struct cgpu_info *baikal)
{
    struct baikal_info *info = baikal->device_data;
    struct miner_info *miner;
    baikal_msg msg = {0, };
    int i;

    for (i = 0; i < info->miner_count; i++) {
        miner = &info->miners[i];
        if (miner->working == true) {            
            msg.miner_id    = i;
            msg.cmd         = BAIKAL_GET_RESULT;
            msg.dest        = 0;
            msg.len         = 0;

            mutex_lock(baikal->mutex);
            if (baikal_sendmsg(baikal, &msg) < 0) {
                applog(LOG_ERR, "baikal_process_result : sendmsg error");
                mutex_unlock(baikal->mutex);
                return (false);
            }

            if (baikal_readmsg(baikal, &msg, 23) < 0) {
                applog(LOG_ERR, "baikal_process_result : readmsg error miner_id = %d", i);
                mutex_unlock(baikal->mutex);
                return (false);
            }
            mutex_unlock(baikal->mutex);
            
            miner->temp = msg.data[6];

            if (msg.param & 0x01) {
                baikal_checknonce(baikal, &msg);
            }

            if (msg.param & 0x02) {
                baikal_send_work(baikal, i);    
            }

            if (msg.param & 0x04) {
                baikal_cleanup(baikal);  /* new miner detect*/              
            }              

            if (miner->temp > info->cutofftemp) {
                miner->overheated = true;
            }
            else if (miner->temp < info->recovertemp) {
                miner->overheated = false;
            }
            cgsleep_ms(1);
        }        
    }

    return (true);
}

static int64_t baikal_hash_done(struct cgpu_info *baikal, struct miner_info *miner, int elpased)
{
    int64_t hash_done = 0;

    switch(baikal->algorithm.type) {        
    case ALGO_CRYPTONIGHT:
        hash_done = miner->clock * miner->asic_count * elpased / 1776;
        break;
    case ALGO_CRYPTONIGHT_LITE:
        hash_done = miner->clock * miner->asic_count * elpased / 888;
        break;
    case ALGO_X11:
    case ALGO_QUARK:
    case ALGO_QUBIT:
    case ALGO_NIST:  
    case ALGO_SKEINCOIN:
    case ALGO_SKEIN2:
    case ALGO_MYRIAD_GROESTL:
    case ALGO_GROESTL:
        hash_done = miner->clock * miner->asic_count * elpased * 128;
        break;
    case ALGO_X11GOST:
    case ALGO_VELTOR:
        hash_done = miner->clock * miner->asic_count * elpased * 18;
        break;
    
    case ALGO_BLAKECOIN:
    case ALGO_DECRED:
    case ALGO_VANILLA:
    case ALGO_BLAKE:
        hash_done = miner->clock * miner->asic_count * elpased * 2048;
        break;

    case ALGO_SIA:    
        hash_done = miner->clock * miner->asic_count * elpased * 1024;
        break;    
    case ALGO_LBRY:
    case ALGO_PASCAL:
        hash_done = miner->clock * miner->asic_count * elpased * 512;
        break;
    }

    return hash_done;
}


static int64_t baikal_scanhash(struct thr_info *thr)
{
    struct cgpu_info *baikal = thr->cgpu;
    struct baikal_info *info = baikal->device_data;
    struct miner_info *miner = &info->miners[baikal->miner_id];
    cgtimer_t now;
    int elapsed, i;

    if (baikal->usbinfo.nodev) {
        return (-1);
    }

    if (baikal->miner_id == 0) {
        if (baikal_process_result(baikal) != true) {
            baikal_cleanup(baikal);
            return (-1);
        }
    }
    else {
        cgsleep_ms(100);
    }

    baikal->temp = miner->temp;

    cgtimer_time(&now);
    elapsed = cgtimer_to_ms(&now) - cgtimer_to_ms(&miner->start_time);
    miner->start_time = now; 

    return (baikal_hash_done(baikal, miner, elapsed));    
}


static void baikal_update_work(struct cgpu_info *baikal)
{
    int i, j;
    struct timeval now;
    struct baikal_info *info = baikal->device_data;    
    //struct thr_info *thr = mining_thr[miner->thr_id];

    /* TODO : check when bk1791 160 chips used */
    if (baikal->miner_id == 0) {
        for (i = 0; i < info->miner_count; i++) {
            struct miner_info *miner = &info->miners[i];
            if (miner->working == true) {
                for (j = 0; j < miner->unit_count; j++) {
                    if (baikal_send_work(baikal, i) != true) {
                        baikal_cleanup(baikal);
                    }
                }
            }
        }
    }
}


static bool baikal_init(struct thr_info *thr)
{
    struct cgpu_info *baikal    = thr->cgpu;
    struct baikal_info *info    = baikal->device_data;
    struct miner_info *miner    = &info->miners[baikal->miner_id];

    //memset(miner, 0, sizeof(struct miner_info));
    miner->thr_id               = thr->id;
    cgtimer_time(&miner->start_time);
    return (true);
}


static void baikal_shutdown(struct thr_info *thr)
{
    struct cgpu_info *baikal = thr->cgpu;
    struct baikal_info *info = baikal->device_data;

    if (baikal->miner_id == 0) {
        baikal_setidle(baikal);
    }

    baikal->shutdown = true;
}


struct device_drv baikalu_drv = {
    .drv_id					= DRIVER_baikalu,
    .dname					= "Baikal",
    .name					= "BKLU",
    .drv_detect				= baikal_detect,
    .get_statline_before	= baikal_get_statline_before,
    .get_api_stats			= baikal_api_stats,
    .identify_device		= baikal_identify,
    .thread_prepare			= baikal_prepare,
    .thread_init			= baikal_init,
    .hash_work              = hash_driver_work,
    .update_work            = baikal_update_work,
    //.flush_work             = baikal_update_work,
    .scanwork				= baikal_scanhash,
    .thread_shutdown        = baikal_shutdown,
};

CRYPTONIGHT
CRYPTONIGHT_LITE
X11
QUARK
QUBIT
NIST
SKEINCOIN
SKEIN2
MYRIAD_GROESTL
GROESTL
X11GOST
VELTOR
BLAKECOIN
DECRED
VANILLA
BLAKE
SIA    
LBRY
PASCAL

ALGO_X11
ALGO_QUARK
ALGO_QUBIT
etc...

msg.data[0] = (clk == 0) ? clk : ((clk / 10) % 20) + 2;

#ifndef ALGORITHM_H
#define ALGORITHM_H

#include "config.h"

#ifdef __APPLE_CC__
#include <OpenCL/opencl.h>
#else
#ifdef USE_GPU
#include <CL/cl.h>
#endif
#endif

#include <inttypes.h>
#include <stdbool.h>
#include <stddef.h>

#ifdef USE_GPU
#include "ocl/build_kernel.h"   // For the build_kernel_data type
#endif 

#define SUPPORT_SIAPOOL        (0)

typedef enum {
  ALGO_UNK,
  ALGO_CRE,
  ALGO_SCRYPT,
  ALGO_NSCRYPT,
  ALGO_PASCAL,
  ALGO_X11,
  ALGO_X11GOST,
  ALGO_X13,
  ALGO_X14,
  ALGO_X15,
  ALGO_KECCAK,
  ALGO_QUARK,
  ALGO_TWE,
  ALGO_FUGUE,
  ALGO_NIST,
  ALGO_FRESH,
  ALGO_WHIRL,
  ALGO_NEOSCRYPT,
  ALGO_WHIRLPOOLX,
  ALGO_LYRA2RE,
  ALGO_LYRA2REV2,
  ALGO_PLUCK,
  ALGO_YESCRYPT,
  ALGO_YESCRYPT_MULTI,
  ALGO_BLAKECOIN,
  ALGO_BLAKE,
  ALGO_SIA,
  ALGO_DECRED,
  ALGO_VANILLA,
  ALGO_LBRY,
  ALGO_CRYPTONIGHT,
  ALGO_CRYPTONIGHT_LITE,
  ALGO_SKEINCOIN,
  ALGO_SKEIN2,
  ALGO_QUBIT,
  ALGO_MYRIAD_GROESTL,
  ALGO_GROESTL,
  ALGO_DIDAMOND,
  ALGO_NEVACOIN,
  ALGO_VELTOR,
  ALGO_MAX
} algorithm_type_t;


extern const char *algorithm_type_str[];

extern void gen_hash(const unsigned char *data, unsigned int len, unsigned char *hash);

#ifdef USE_GPU
struct __clState;
#endif 

struct _dev_blk_ctx;

#ifdef USE_GPU
struct _build_kernel_data;
#endif 

struct cgpu_info;
struct work;

/* Describes the Scrypt parameters and hashing functions used to mine
 * a specific coin.
 */
typedef struct _algorithm_t {
  char     name[20]; /* Human-readable identifier */
  algorithm_type_t type; //algorithm type
  const char *kernelfile; /* alternate kernel file */
  uint32_t n;        /* N (CPU/Memory tradeoff parameter) */
  uint8_t  nfactor;  /* Factor of N above (n = 2^nfactor) */
  double   diff_multiplier1;
  double   diff_multiplier2;
  double   share_diff_multiplier;
  uint32_t xintensity_shift;
  uint32_t intensity_shift;
  uint32_t found_idx;
  unsigned long long   diff_numerator;
  uint32_t diff1targ;
  size_t n_extra_kernels;
  long rw_buffer_size;
#ifdef USE_GPU
  cl_command_queue_properties cq_properties;
#endif 
  void(*regenhash)(struct work *);
  void(*calc_midstate)(struct work *);
  void(*prepare_work)(struct _dev_blk_ctx *, uint32_t *, uint32_t *);
#ifdef USE_GPU
  cl_int(*queue_kernel)(struct __clState *, struct _dev_blk_ctx *, cl_uint);
#endif 
  void(*gen_hash)(const unsigned char *, unsigned int, unsigned char *);

#ifdef USE_GPU
  void(*set_compile_options)(struct _build_kernel_data *, struct cgpu_info *, struct _algorithm_t *);
#endif 
} algorithm_t;

typedef struct _algorithm_settings_t
{
	const char *name;
	algorithm_type_t type;
	const char *kernelfile;
	double   diff_multiplier1;
	double   diff_multiplier2;
	double   share_diff_multiplier;
	uint32_t xintensity_shift;
	uint32_t intensity_shift;
	uint32_t found_idx;
	unsigned long long   diff_numerator;
	uint32_t diff1targ;
	size_t n_extra_kernels;
	long rw_buffer_size;
#ifdef USE_GPU
	cl_command_queue_properties cq_properties;
#endif 
	void     (*regenhash)(struct work *);
	void     (*calc_midstate)(struct work *);
	void     (*prepare_work)(struct _dev_blk_ctx *, uint32_t *, uint32_t *);
#ifdef USE_GPU
	cl_int   (*queue_kernel)(struct __clState *, struct _dev_blk_ctx *, cl_uint);
#endif 
	void     (*gen_hash)(const unsigned char *, unsigned int, unsigned char *);
#ifdef USE_GPU
	void     (*set_compile_options)(build_kernel_data *, struct cgpu_info *, algorithm_t *);
#endif 
} algorithm_settings_t;

/* Set default parameters based on name. */
void set_algorithm(algorithm_t* algo, const char* name);

/* Set to specific N factor. */
void set_algorithm_nfactor(algorithm_t* algo, const uint8_t nfactor);

/* Compare two algorithm parameters */
bool cmp_algorithm(const algorithm_t* algo1, const algorithm_t* algo2);

int to_baikal_algorithm(algorithm_type_t type);

#endif /* ALGORITHM_H */

int to_baikal_algorithm(algorithm_type_t type);

#ifdef USE_BAIKAL
int to_baikal_algorithm(algorithm_type_t type)
{
    switch (type) {
    case ALGO_X11:
        return 1;
    case ALGO_X13:
        return 2;
    case ALGO_X14:
        return 3;
    case ALGO_X15:            
        return 4;
    case ALGO_QUARK:        
        return 5;
    case ALGO_QUBIT:
        return 6;   
    default:
        return 0;
        break;
    }
}
#endif 

...
static bool baikal_send_work(struct cgpu_info *baikal, int miner_id)
{
    struct baikal_info *info = baikal->device_data;
    struct miner_info *miner = &info->miners[miner_id];
    struct thr_info *thr = mining_thr[miner->thr_id];
    struct work *work;
    uint32_t target;
    baikal_msg msg;
    uint8_t algo;
    uint32_t * mdata,*wdata;

    /* Do not send */
    if (miner->overheated == true) {
        return (true);
    }

    mutex_lock(baikal->mutex);
    if (info->works[info->work_idx] == NULL) {
        work = get_work(thr, miner->thr_id);                              
        info->works[info->work_idx] = work;

#if 0   /* TODO : Performance Check */
        if (thr->work_restart) {                   
            free_work(info->works[info->work_idx]);
            info->works[info->work_idx] = NULL;    
            applog(LOG_ERR, "work restart\n");     
            mutex_unlock(baikal->mutex);           
            return true;                           
        }                                          
#endif
    }
    
    if (work->pool->algorithm.type != thr->cgpu->algorithm.type) {
        thr->cgpu->algorithm.type = work->pool->algorithm.type;
    }

    work->device_diff = MAX(miner->working_diff, work->work_difficulty);
    //work->device_diff = MIN(miner->working_diff, work->work_difficulty);
    set_target(work->device_target, work->device_diff, work->pool->algorithm.diff_multiplier2, work->thr_id);

    memset(msg.data, 0x0, 512);
    msg.data[0] = to_baikal_algorithm(thr->cgpu->algorithm.type);
    msg.data[1] = miner_id;
    memcpy(&msg.data[2], &work->device_target[24], 8);
    if (*((uint32_t *)&msg.data[6]) != 0x0) { // TripleS
        memset(&msg.data[2], 0xFF, 4);
    }

    switch (baikal->algorithm.type) {
    case ALGO_BLAKECOIN:        // blake256r8
        if (work->pool->algorithm.calc_midstate) {   // use midstate
            msg.data[0] += 1;

            memcpy(&msg.data[10], work->midstate, 32);
            memcpy(&msg.data[42], &work->data[64], 16);
            be32enc_vect((uint32_t *)&msg.data[42], (const uint32_t *)&msg.data[42], 4);
            *((uint32_t *)&msg.data[58]) = 0x00000080;
            *((uint32_t *)&msg.data[94]) = 0x01000000;
            *((uint32_t *)&msg.data[102]) = 0x80020000;
            msg.len = 106;
        }
        else {
            memcpy(&msg.data[10], work->data, 80);
            be32enc_vect((uint32_t *)&msg.data[10], (const uint32_t *)&msg.data[10], 20);
            msg.len = 90;
        }
        break;

    case ALGO_DECRED:           // blake256r14
        if (work->pool->algorithm.calc_midstate) {   // use midstate
            msg.data[0] += 1;

            memcpy(&msg.data[10], work->midstate, 32);
            memcpy(&msg.data[42], &work->data[128], 52);
            *((uint32_t *)&msg.data[94]) = 0x01000080UL;
            *((uint32_t *)&msg.data[98]) = 0x00000000UL;
            *((uint32_t *)&msg.data[102]) = 0xa0050000UL;
            msg.len = 106;
        }
        else {
            memcpy(&msg.data[10], work->data, 180);
            msg.len = 190;
        }
        break;
    case ALGO_SIA:              // blake2b
        memcpy(&msg.data[10], work->data, 80);
        be32enc_vect((uint32_t *)&msg.data[10], (const uint32_t *)&msg.data[10], 20);
        msg.len = 90;
        break;

    case ALGO_LBRY:             // lbry-all
        memcpy(&msg.data[10], work->data, 112);
        be32enc_vect((uint32_t *)&msg.data[10], (const uint32_t *)&msg.data[10], 27);
        msg.len = 122;
        break;

    case ALGO_PASCAL:           // lbry-sha
        memcpy(&msg.data[10], work->data, 200);
        msg.len = 210;
        break;

    case ALGO_X11:
    case ALGO_X11GOST:
    case ALGO_SKEINCOIN:
    case ALGO_MYRIAD_GROESTL:
    case ALGO_QUARK:
    case ALGO_QUBIT:
    case ALGO_GROESTL:
    case ALGO_SKEIN2:
    case ALGO_NIST:
    case ALGO_CRYPTONIGHT:
    case ALGO_CRYPTONIGHT_LITE:
    case ALGO_BLAKE:
    case ALGO_VANILLA:
    case ALGO_VELTOR:
    default:
        memcpy(&msg.data[10], work->data, 80);
        msg.len = 90;
        break;
    }
    msg.miner_id    = miner_id;
    msg.cmd         = BAIKAL_SEND_WORK;
    msg.param       = info->work_idx;
    msg.dest        = 0;

    //mutex_lock(baikal->mutex);

    if (baikal_sendmsg(baikal, &msg) < 0) {
        applog(LOG_ERR, "baikal_send_work : sendmsg error[%d]", miner_id);
        mutex_unlock(baikal->mutex);
        return (false);
    }

    if (baikal_readmsg(baikal, &msg, 7) < 0) {
        applog(LOG_ERR, "baikal_send_work : readmsg error[%d]", miner_id);
        mutex_unlock(baikal->mutex);
        return (false);
    }

    /* update clock */
    miner->clock = msg.param << 1;

    info->work_idx++;
    if (info->work_idx >= BAIKAL_WORK_FIFO) {
        info->work_idx = 0;
    }

    if (info->works[info->work_idx] != NULL) {
        free_work(info->works[info->work_idx]);
        info->works[info->work_idx] = NULL;
    }
        
    cgtimer_time(&miner->start_time);
    mutex_unlock(baikal->mutex);

    return (true);
}
...

...
static int64_t baikal_hash_done(struct cgpu_info *baikal, struct miner_info *miner, int elpased)
{
    int64_t hash_done = 0;

    switch(baikal->algorithm.type) {        
    case ALGO_CRYPTONIGHT:
        hash_done = miner->clock * miner->asic_count * elapsed / 1776;
        break;
    case ALGO_CRYPTONIGHT_LITE:
        hash_done = miner->clock * miner->asic_count * elapsed / 888;
        break;
    case ALGO_X11:
    case ALGO_QUARK:
    case ALGO_QUBIT:
    case ALGO_NIST:  
    case ALGO_SKEINCOIN:
    case ALGO_SKEIN2:
    case ALGO_MYRIAD_GROESTL:
    case ALGO_GROESTL:
        hash_done = miner->clock * miner->asic_count * elapsed * 128;
        break;
    case ALGO_X11GOST:
    case ALGO_VELTOR:
        hash_done = miner->clock * miner->asic_count * elapsed * 18;
        break;
    
    case ALGO_BLAKECOIN
    case ALGO_DECRED
    case ALGO_VANILLA
    case ALGO_BLAKE
        hash_done = miner->clock * miner->asic_count * elapsed * 2048;
        break;

    case ALGO_SIA    
        hash_done = miner->clock * miner->asic_count * elapsed * 1024;
        break;    
    case ALGO_LBRY
    case ALGO_PASCAL
        hash_done = miner->clock * miner->asic_count * elapsed * 512;
        break;
    }

    return hash_done;
}
...

2    400 (Giant B stock)
3    410/210
4    420/220
5    430/230
6    440/240
7    450/250
8    460/260
9    470/270
10   480/280
11   490/290
12   300 (Giant x10 stock)
13   310
14   320
15   330
16   340
17   350
18   360
19   370
20   380
21   390

sgminer 5.6.2-cod3gen - Started: [2018-03-25 16:45:04] - [0 days 00:00:16]
--------------------------------------------------------------------------------
(5s):0.000 (avg):0.000h/s | A:0  R:0  HW:0  WU:0.000/m
ST: 1  SS: 0  NB: 1  LW: 17  GF: 0  RF: 0
Connected to quark.eu.nicehash.com (stratum) diff 40 as user XXX
Block: 51abe371...  Diff:101M  Started: [16:45:03]  Best share: 0
--------------------------------------------------------------------------------
 [U]SB management [P]ool management [S]ettings [D]isplay options [Q]uit
--------------------------------------------------------------------------------
 [2018-03-25 16:45:02.877] Started sgminer 5.6.2-cod3gen
 [2018-03-25 16:45:02.877] * using Jansson 2.7
 [2018-03-25 16:45:02.878] Loaded configuration file /opt/scripta/etc/miner.conf

[b] [2018-03-25 16:45:03.098] No devices detected!
 [2018-03-25 16:45:03.099] Waiting for USB hotplug devices or press q to quit[/b]
 [2018-03-25 16:45:03.099] Probing for an alive pool
 [2018-03-25 16:45:03.480] Startup BaikalMiner initialization... Using settings
from pool quark.eu.nicehash.com.
 [2018-03-25 16:45:03.480] Startup Pool No = 0
 [2018-03-25 16:45:03.498] quark.eu.nicehash.com difficulty changed to 40.960
 [2018-03-25 16:45:09.102] API running in IP access mode on port 4028 (11)

...
	USB_ADD_COMMAND(C_BAIKAL_SEND, "BaikalSend") \
	USB_ADD_COMMAND(C_BAIKAL_READ, "BaikalRead")
...

sgminer 5.6.2-cod3gen - Started: [2018-03-25 20:31:35] - [0 days 00:01:14]
--------------------------------------------------------------------------------
(5s):10.13G (avg):10.27Gh/s | A:829  R:0  HW:37  WU:31147.411/m
ST: 1  SS: 12  NB: 4  LW: 4168  GF: 0  RF: 0
Connected to quark.eu.nicehash.com (stratum) diff 40 as user XXX
Block: 8826b8d8...  Diff:87M  Started: [20:32:35]  Best share: 39.3K
--------------------------------------------------------------------------------
 [U]SB management [P]ool management [S]ettings [D]isplay options [Q]uit
BKLU 0: 39C 300MHz [ASICS #64] | 3.379G/3.616Gh/s | A:288 R: 0 HW:25 WU:10739.883/m
BKLU 1: 39C 300MHz [ASICS #64] | 3.379G/3.610Gh/s | A:287 R: 0 HW: 5 WU:11230.049/m
BKLU 2: 38C 300MHz [ASICS #64] | 3.379G/3.613Gh/s | A:302 R: 0 HW:10 WU:11173.155/m

.iManufacturer = "Baikal", // 25.03.18 changed from "MS Technology" to "Baikal"

#ifndef __DEVICE_BAIKAL_H__
#define __DEVICE_BAIKAL_H__

#include "miner.h"

#define BAIKAL_1751             (0x1)
#define BAIKAL_1772             (0x2)
#define BAIKAL_1791             (0x4)
#define BAIKAL_ALL              (0x7)
#define BAIKAL_TYPE             (BAIKAL_ALL)

#define BAIKAL_MAXMINERS	    (5)
#define BAIKAL_MAXUNIT          (4)
#define BAIKAL_MAXASICS	        (16)
#define BAIKAL_WORK_FIFO        (200)

#define BAIKAL_CLK_MIN  		(150)
#define BAIKAL_CLK_MAX		    (300)

#if BAIKAL_TYPE == BAIKAL_1751
#define BAIKAL_CLK_DEF  		(200)
#elif BAIKAL_TYPE == BAIKAL_1791
#define BAIKAL_CLK_DEF  		(400)
#else
#define BAIKAL_CLK_DEF  		(300)
#endif

#define BAIKAL_CUTOFF_TEMP      (60)
#define BAIKAL_FANSPEED_DEF     (100)
#define BAIKAL_FANSPEED_MAX     (100)
#define BAIKAL_RECOVER_TEMP     (40)

#define BAIKAL_RESET		    (0x01)
#define BAIKAL_GET_INFO	        (0x02)
#define BAIKAL_SET_OPTION	    (0x03)
#define BAIKAL_SEND_WORK	    (0x04)
#define BAIKAL_GET_RESULT	    (0x05)
#define BAIKAL_SET_ID		    (0x06)
#define BAIKAL_SET_IDLE		    (0x07)

#define BAIKAL_MINER_TYPE_NONE  (0x00)
#define BAIKAL_MINER_TYPE_MINI  (0x01)
#define BAIKAL_MINER_TYPE_CUBE  (0x02)

#define BAIKAL_ENABLE_SETCLK    (0)

#define BAIKAL_CHECK_STALE      (0)
#define BAIKAL_EN_HWE           (0)
#define BAIKAL_CLK_FIX          (1)

struct asic_info {
    uint32_t nonce;
    uint32_t error;
};

struct miner_info {
    int     thr_id;
    int     asic_count;  
    int     asic_count_r;  
    int     unit_count;
	int		temp;  
    int     clock;
    int     bbg;
    bool    working;
    bool    overheated;
    uint8_t fw_ver;
    uint8_t hw_ver;
    uint8_t asic_ver;    
    uint32_t nonce;
    uint32_t error;    
    double working_diff;    
    struct asic_info asics[BAIKAL_MAXUNIT][BAIKAL_MAXASICS]; 
    uint8_t work_idx;
    struct work *works[BAIKAL_WORK_FIFO];
    cgtimer_t start_time;
};


struct baikal_info {
    struct pool pool;
    int miner_count;
    int clock;
    uint8_t cutofftemp;
    uint8_t fanspeed;		// percent
    uint8_t recovertemp;
	pthread_t *process_thr;
    struct miner_info miners[BAIKAL_MAXMINERS];    
    uint8_t miner_type;
};

typedef struct {
    uint8_t     miner_id;
    uint8_t     cmd;
    uint8_t     param;
    uint8_t     dest;
    uint8_t     data[512];
    uint32_t    len;
} baikal_msg;


#endif /* __DEVICE_BAIKAL_H__ */

#ifndef __DEVICE_BAIKAL_H__
#define __DEVICE_BAIKAL_H__

#include "miner.h"

#define BAIKAL_1751             (0x1)
#define BAIKAL_1772             (0x2)
#define BAIKAL_1791             (0x4)
#define BAIKAL_ALL              (0x7)
#define BAIKAL_TYPE             (BAIKAL_ALL)

#define BAIKAL_MAXMINERS	    (5)
#define BAIKAL_MAXUNIT          (4)
#define BAIKAL_MAXASICS	        (16)
#define BAIKAL_WORK_FIFO        (200)

#define BAIKAL_CLK_MIN  		(150)
#define BAIKAL_CLK_DEF  		(400)
#define BAIKAL_CLK_MAX		    (400)
#define BAIKAL_CUTOFF_TEMP      (55)
#define BAIKAL_FANSPEED_DEF     (100)
#define BAIKAL_FANSPEED_MAX     (100)
#define BAIKAL_RECOVER_TEMP     (40)

#define BAIKAL_RESET		    (0x01)
#define BAIKAL_GET_INFO	        (0x02)
#define BAIKAL_SET_OPTION	    (0x03)
#define BAIKAL_SEND_WORK	    (0x04)
#define BAIKAL_GET_RESULT	    (0x05)
#define BAIKAL_SET_ID		    (0x06)
#define BAIKAL_SET_IDLE		    (0x07)

#define BAIKAL_MINER_TYPE_NONE  (0x00)
#define BAIKAL_MINER_TYPE_MINI  (0x01)
#define BAIKAL_MINER_TYPE_CUBE  (0x02)

#define BAIKAL_ENABLE_SETCLK    (0)

#define BAIKAL_CHECK_STALE      (0)
#define BAIKAL_EN_HWE           (0)
#define BAIKAL_CLK_FIX          (1)

struct asic_info {
    uint32_t nonce;
    uint32_t error;
};

struct miner_info {
    int     thr_id;
    int     asic_count;  
    int     asic_count_r;  
    int     unit_count;
	int		temp;  
    int     clock;
    int     bbg;
    bool    working;
    bool    overheated;
    uint8_t fw_ver;
    uint8_t hw_ver;
    uint8_t asic_ver;    
    uint32_t nonce;
    uint32_t error;    
    double working_diff;    
    struct asic_info asics[BAIKAL_MAXUNIT][BAIKAL_MAXASICS]; 
    uint8_t work_idx;
    struct work *works[BAIKAL_WORK_FIFO];
    cgtimer_t start_time;
};


struct baikal_info {
    struct pool pool;
    int miner_count;
    int clock;
    uint8_t cutofftemp;
    uint8_t fanspeed;		// percent
    uint8_t recovertemp;
	pthread_t *process_thr;
    struct miner_info miners[BAIKAL_MAXMINERS];    
    uint8_t miner_type;
};

typedef struct {
    uint8_t     miner_id;
    uint8_t     cmd;
    uint8_t     param;
    uint8_t     dest;
    uint8_t     data[512];
    uint32_t    len;
} baikal_msg;


#endif /* __DEVICE_BAIKAL_H__ */

sgminer 5.6.2-cod3gen - Started: [2018-03-26 00:38:34] - [0 days 10:12:35]
--------------------------------------------------------------------------------
(5s):10.82G (avg):10.81Gh/s | A:9148  R:78  HW:381  WU:33820.422/m
ST: 1  SS: 0  NB: 638  LW: 2261672  GF: 0  RF: 0
Connected to quark.eu.nicehash.com (stratum) diff 5.24K as user XXX
Block: 57e616c6...  Diff:117M  Started: [10:48:08]  Best share: 10.8M
--------------------------------------------------------------------------------
 [U]SB management [P]ool management [S]ettings [D]isplay options [Q]uit
BKLU 0: 38C 400MHz [ASICS #64] | 3.604G/3.604Gh/s | A:2763 R: 21 HW: 54 WU:9921.705/m
BKLU 1: 38C 400MHz [ASICS #64] | 3.604G/3.604Gh/s | A:3194 R: 27 HW:150 WU:11941.753/m
BKLU 2: 38C 400MHz [ASICS #64] | 3.604G/3.604Gh/s | A:3191 R: 30 HW:177 WU:11956.965/m

./configure 
make
ls
chmod a+x ./update.sh 
ls
sudo ./update.sh 
sudo screen -r
sudo /opt/scripta/startup/miner-stop.sh 
sudo screen -r
sudo reboot
vi /etc/rc.local 
ls
cd
ls
ls -al
rm -rf .subversion/
ls
sudo shutdown -h now
sudo chmod 755 /etc/rc.local
sudo reboot
lsmod
sudo shutdown -h now
ls
vi /etc/rc.local 
sudo screen -r
ls
cd scripta/
ls
cd etc/
ls
sudo cp /etc/rc.local  rc.local.zero 
ls
svn diff
cd
ls
cd ls
sudo vi /etc/rc.local 
sudo reboot
ls
sudo vi /etc/rc.local 
sudo reboot
ls
sudo /etc/rc.local 
sudo vi /etc/rc.local 
sudo reboot
ls
sudo ntpd -qg
date
suvo vi /etc/rc.local 
sudo vi /etc/rc.local 
sudo reboot
sudo screen -r
ls
sudo vi /etc/rc.local 
sudo reboot
ls
sudo vi /etc/rc.local 
reboot
sudo reboot
sudo screen -r
ls
sudo vi /etc/rc.local 
sudo reboot
sudo /etc/rc.local 
sudo vi /etc/rc.local 
sudo reboot
sudo vi /etc/rc.local 
sudo reboot
ls
sudo vi  /etc/rc.local 
sudo vi /etc/default/ntp
sduo vi /etc/ntp.conf 
sudo vi /etc/ntp.conf 
sudo reboot
sudo screen -r
ls
sudo vi /etc/rc.local 
ls
sudo vi /etc/rc.local 
sudo reboot
ls
cd scripta/
ls
cd etc/
ls
vi rc.local.zero 
sudo screen -r
sudo reboot
cd scripta/etc/
ls
vi rc.local
vi rc.local.zero 
sudo screen -r
ls
sudo vi /etc/rc.local 
sudo reboot
ls
sudo vi /etc/rc.local 
sudo reboot
sudo screen -r
sudo vi /etc/rc.local 
sudo hwclock --show
sudo hwclock --systohc
sudo hwclock --show
sudo apt-get install fake-hwclock
sudo /etc/init.d/fake-hwclock start
sudo reboot
date
sudo screen -r
ls
sudo vi /etc/rc.local 
sudo reboot
ls
cd scripta/
ls
vi install_zero.sh 
date
sudo screen -r
cd
ls
cd scripta/
ls
cd etc/
ls
cp /etc/rc.local rc.local.zero 
svn commit -m "modify rc.local.zero" .
cd ..
svn update
ls
cp update_one.sh update_zero.sh
vi update_zero.sh 
ls
svn add update_zero.sh 
svn update
svn diff
svn status
svn commit -m ""
ls
chmod a+x ./update_zero.sh 
ls
sudo ./update_zero.sh 
sudo reboot
ls
cd sgminer-5.5.0/
ls
chmod a+x ./autogen.sh 
./autogen.sh 
ls
./configure 
make 
ls
sudo ./update.sh 
cd
ls
sudo screen -r
sudo reboot
sudo screen -r
ls
rm -rf sgminer-5.5.0/
ls
sudo shutdown -h
sudo shutdown -h now
sudo screen -r
sudo apt-get install samba
sudo shutdonw -h now
sudo shutdown -h now
cd /opt/
ls
cd baikal_back20161213185554/
ls
cd e
cd www/
ls
cd html/
ls
cd
ls
cd /opt/
ls
cd scripta/
ls
cd etc/
ls
cd backup/
ls
cd Example/
ls
cd etc/
ls
vi miner.options.json 
sudo vi miner.pools.json 
ls
vi scripta.conf 
ls
vi miner.conf 
sudo vi miner.conf 
cd ..
ls
cd ..
ls
sudo rm -rf Example/
sudo mv 20170209-1925/ Example
cd
ls
sudo cp miner.html /var/www/partials/
sudo cp login.php /var/www/
ls
cd /var/www/
ls
ls -l
vi login.php 
sudo vi login.php 
cd /var/www/partials/
ls
vi miner.html 
cd ..
ls
sudo vi login.php 
ls
sudo shutdown -h now
cd /var/www/
ls
cd
ls
ifconfig
sudo cp login.php /var/www/
ls
sudo cp login.php /var/www/
ls
cd /opt/
ls
cd scripta/
ls
cd etc/
ls
cd backup/
ls
rm -rf Example/
sudo rm -rf Example/
ls
sudo mv 20170210-1625/
sudo mv 20170210-1625/ Example
ls
sudo cp 20170210-1627/* Nicehash-USA/
sudo cp -a  20170210-1627/* Nicehash-USA/
ls
rm -rf 20170210-1627/
sudo rm -rf 20170210-1627/
ls
sudo cp -a 20170210-1630/* Zpool/
sudo rm -rf 20170210-1630/
ls
sudo cp -a 20170210-1631/* Nicehash-Japan/
sudo rm -rf 20170210-1631/
ls
sudo cp -a 20170210-1632/ Zpool/
sudo rm -rf 20170210-1632/
ls -l
ls
l s-l
ls -l;
ls -l
sudo chown -R www-data.www-data .
ls -l
sudo cp -a 20170210-1633/* Nicehash-USA/
ls
cat 20170210-1633/etc/miner.conf 
q
ls
rm -rf 20170210-1633/
sudo rm -rf 20170210-1633/
ls
cd 20170210-1635/
ls
cd etc/
ls
vi miner.
vi miner.conf 
cd ..
ls
sudo cp -a 20170210-1635/* Nicehash-Japan/
sudo rm -rf 20170210-1635/
ls
sudo cp -a 20170210-1652/* Nicehash-Europe/
ls
sudo rm 20170210-1652/
sudo rm -rf 20170210-1652/
ls
sudo cp -a 20170210-1656/* Nicehash-China/
cd Nicehash-
cd Nicehash-China/
cd etc/
ls
vi miner.conf 
cd ..
ls
sudo rm -rf 20170210-1656/
ls
sudo cp -a 20170210-1657/* Miningpoolhub/
sudo rm -rf 20170210-1657/
ls
sudo cp -a 20170210-1702/* Zpool/
sudo rm -rf 20170210-1702/
ls
cd
ls
cp -a /opt/scripta/etc/backup/* . 
ls
rm -rf Example/
rm -rf Miningpoolhub/
rm -rf Nicehash-China/
rm -rf Nicehash-*
ls
rm -rf Zpool/
ls
rm -rf login.php 
rm -rf miner.html 
ls
cd
ls
cd
ls
ls -al
cd .cache/
ls
ls -al
rm -rf motd.legal-displayed 
ls
cd ..
ls
sudo shutdown -h now
ls
df
cd
ls
sudo cp f_settings.php /var/www/
sudo cp miner.html  /var/www/partials/
cd /var/www/
ls
ls -l
cd partials/
ls
ls -l
cd 
ls
cd /opt/scripta/etc/
ls
cd backup/
ls
ls -l
sudo cp -a /home/baikal/backup/* . 
ls -l
cd ..
ls
ls -l
sudo chown -R www-data.root backup/
ls -l
cd backup/
ls -l
cd Example/
ls
ls -l
cd etc/
ls -l
ls
cd
ls
rm -rf f_settings.php 
rm -rf miner.html 
ls
cd /opt/scripta/etc/
ls
vi miner.conf 
ls
sudo shutdown -h now
ls
cd backup/
ls
cd
ls
rm -rf backup/
ls
sudo svn co svn://192.168.0.5/baikal/software/trunk/sgminer-5.5.0
ls
cd sgminer-5.5.0/
ls
chmod a+x autogen.sh 
sudo ./autogen.sh 
ls
./autogen.sh 
ls -l
sudo chown -R baikal.baikal . 
ls -l
./autogen.sh 
./configure 
make
ls
sudo ./update.sh 
ls
cd
ls
sudo rm -rf sgminer-5.5.0/
ls
ls -al
rm -rf .subversion/
ls
sudo shutdown -h now
cd /opt/scripta/etc/
ls
sudo vi /etc/rc.local 
sync
sudo shutdown -h ow
sudo shutdown -h now
sudo halt
sudo cp f_settings.php /var/www/
cd /var/www/
ls
ls -l
vi f_settings.php 
cd
ls
rm f_settings.php 
ls
sudo reboot
sudo halt
vi /var/www/f_settings.php 
ls
sudo screen -r
ls
sudo rm -rf /opt/scripta/bin/sgminer 
sudo screen -r
ls -l /opt/scripta/bin/
ls
sudo cp ./sgminer  /opt/scripta/bin/
cd /opt/scripta/bin/
ls
sudo chmod 755 sgminer 
ls -l
cd
ls
rm -rf sgminer 
sudo screen -r
sudo halt
ls
sudo vi /etc/rc.local 
ls
sudo rm -rf /opt/scripta/bin/sgminer 
sudo cp ./sgminer  /opt/scripta/bin/
cd /opt/scripta/bin/
ls
sudo chmod a+x sgminer 
ls
cd
ls
rm sgminer 
sudo screen -r
sudo reboot
sudo screen -r
ls
sudo vi /etc/rc.local 
sudo reboot
cd /opt/scripta/etc/
ols
ls
sudo vi miner.conf 
sudo vi miner.pools.json 
sudo vi miner.conf 
ls
cd backup/
ls
cd Example/
ls
ced etc/
ls
cd etc/
ls
sudo cp /opt/scripta/etc/miner.conf  . 
ls -l
sudo cp /opt/scripta/etc/miner.pools.json  . 
ls
vi miner.conf 
ls
sudo vi miner.pools.json 
ls
cd
ls
sudo halt
sudo vi /etc/rc.local 
sync
sudo reboot
svn co 
svn co svn://bkls.asuscomm.com/baikal/software/trunk/sgminer-5.5.0
ls
cd sgminer-5.5.0/
ls
chmod a+x autogen.sh 
./autogen.sh 
./configure
make
chmod a+x ./update.sh 
sudo ./update.sh 
sudo reboot
ls
sudo rm -rf sgminer-5.5.0/ 
ls
ls -al
rm -rf .subversion/
sudo halt
sudo screen -r
cd /var/www/
ls
vi login.php 
sudo vi login.php 
cd
ls
htop
top
ls
svn co svn://bkls.asuscomm.com/baikal/software/trunk/sgminer-5.5.0
ls
cd sgminer-5.5.0/
ls
chmod a+x ./autogen.sh 
./autogen.sudo apt-get update
sudo dpkg --configure -a 
sudo apt-get update
sudo dpkg --configure -a 
sudo dpkg --configure
sudo apt-get autoremove
sudo apt-get clean
sudo apt-get update
dmesg
top
ls
sudo apt-get update
dmesg
sudo vi /etc/sysctl.conf 
top
ls
cd /opt/scripta/bin/
ls
mv sgminer sgminer_org
sudo mv sgminer sgminer_org
sudos screen -r
sudo screen -r
qq
sudo screen -r
top
q
sudo apt-get update
dmesg
ls
cd
ls
sudo reboot
ls
top
sudo apt-get update
sudo /etc/init.d/lighttpd stop
sudo /etc/init.d/samba stop
sudo apt-get update
ls
sudo apt-get upgrade
ls
sudo reboot
top
sudo apt-get remove samba
sudo reboot
ls
cd /opt/scripta/bin/
ls
sudo mv sgminer_org sgminer
ls
cd
ls
top
sudo apt-get update
sudo halt
ls
top
sudo apt-get upgrade
sudo apt-get install -y samba avahi-daemon dnsmasq
ls
sudo apt-get upgrade
ls
sudo rm -rf /opt/scripta/bin/sgminer 
sudo mv sgminer  /opt/scripta/bin/
cd /opt/scripta/bin/
ls
sudo chmod a+x sgminer 
ls -l
sudo screen -r
q
sudo /etc/init.d/samba restart
sudo /etc/init.d/avahi-daemon restart
sudo /etc/init.d/dnsmasq restart
sudo reboot
ls
ls -al
rm -rf .subversion/
ls
sudo screen -r
ls
sudo halt
sudo screen -r
sudo halt
ls
ls -al
ls
sudo rm -rf /opt/scripta/bin/sgminer 
sudo mv ./sgminer  /opt/scripta/bin/
sudo screen -r
ls
sudo screen -r
ls
cd
ls
cd /etc/cron.d
ls
vi scripta 
ls
sudo screen -r
cd
ls
cd /opt/scripta/bin/
ls
sudo chmod a+x ./sgminer 
ls
sync
sudo halt
sudo screen -r
ls
kls
sudo vi /etc/rc.local 
sudo shutdown -h now
sudo vi /etc/rc.local
sudo vi /etc/rc.local 
sudo rm /etc/.rc.local.swp 
sudo vi /etc/rc.local 
sync
sudo reboot
sudo vi /etc/rc.local 
ls
top
sudo halt
sudo /etc/init.d/watchdog start
sync
sudo reboot
htop
sudo service watchdog init
sudo service watchdog  start
sync
sudo reboot
htop
sudo update-rc.d
sudo update-rc.d watchdog defaults
sudo reboot
ls
htop
sudo /etc/init.d/watchdog start
htop
sudo service watchdog start
sudo service watchdog restart
sudo service watchdog start
sudo reboot
cd /sys/devices/platform/sunxi-ddrfreq/
ls
cd devfreq/
ls
cd sunxi-ddrfreq/
ls
cat scaling_max_freq 
ls
cat scaling_min_freq 
cat cur_freq 
cat max_freq 
sudo reboot
htop
ps aux
ps aux | grep watch
ls
serice watchdog status
service watchdog status
sudo vi /etc/rc.local 
serice watchdog status
sudo service watchdog status
sudo vi /etc/watchdog.conf 
sudo service watchdog restart
sudo service watchdog status
sudo reboot
service watchdog status
sync
sudo service watchdog status
sudo vi /etc/watchdog.conf 
ls
cd
ls
svn co svn://bkls.asuscomm.com/baikal/software/trunk/sgminer-5.5.0
ls
cd sgminer-5.5.0/
ls
svn update
cd ..
ls
rm -rf .subversion/
ls
ls -al
cd sgminer-5.5.0/
ls
chmod a+x autogen.sh 
./autogen.sh 
./configure
make
sudo ./update.sh 
ls
sudo shutdown -h now
ls
cd sgminer-5.5.0/
ls
svn update
ls
cd .svn/
ls
vi entries 
ls
cd ..
svn relocate
svn help relocate
ls
rm -rf *
ls
ls -al
rm -rf .svn/
ls
cd ..
ls
rm -rf sgminer-5.5.0/
ls
svn co svn://192.168.0.5/baikal/software/trunk/sgminer-5.5.0
cd sgminer-5.5.0/
ls
chmod a+x autogen.sh 
./autogen.sh 
./configure
make
ls
sudo ./update.sh 
ls
sudo shutdown -h now
ls
rm -rf sgminer-5.5.0/
ls
cd
ls
ls -al
rm -rf .subversion/
ls
ls -al
sudo shutdown -h now
cd /opt/scripta/etc/
ls
cd backup/
ls
cd 20170321-1917/
ls
cd etc/
ls
cd ..
ls
cd ..
ls
cd Example/
ls
cd etc/
ls
ls -l
sudo cp ../../20170321-1917/etc/* .
ls
ls -l
cd ..
ls
cd ..
ls
sudo rm -rf 20170321-1917/
ls
cd ..
sudo screen -r
sudo halt
ls
sudo visudo 
sudo visudo
ls
sudo /etc/sudoers
sudo visudo
sudo reboot
ls
sudo visudo 
ls
sudo screen -r
sudo reboot
sudo screen -r
sudo ls
sudo shutdown -h now
ls
sudo screen -r
sudo shutdown
sudo shutdown -h now
ls
cd
ls
sudo sudo ln -fs /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
date
sudo apt-get install ntp
ls
date

sudo timedatectl
sudo /etc/init.d/ntp stop
sudo timedatectl
top
cd /etc/cron.d
ls
vi scripta 
sudo apt-get remove ntp
ntpdate --help
ntpdate /?
ntpdate --help
ntpdate -b
cd
ls
sudo ntpdate -b -u 0.pool.ntp.org
sudo ntpdate -b -u 0.pool.ntp.orgg
sudo ntpdate -b -u 0.pool.ntp.org
ls
cd ~
ls
sudo vi /etc/rc.local 
sudo reboot
dmesg
:q
ls
sudo vi /etc/rc.local 
sudo screen -r
ls
sudo vi /etc/rc.local 
sudo reboot
dmesg
sudo screen -r
ls
sudo vi /etc/rc.local 
sudo reboot
ls
sudo vi /etc/rc.local 
sudo reboot
date
cd
ls
dmesg
sudo /etc/init.d/watchdog start
dmesg
date
dmesg
sudo vi /etc/watchdog.conf 
sudo /etc/init.d/watchdog restart
dmesg
sudo vi /etc/watchdog.conf 
ls
cd
ls
sync
sudo vi /etc/rc.local 
sudo /etc/init.d/watchdog restart
dmesg
ls
sudo visudo
sudo screen -r
ls
cd
ls
sudo screen -r
ls
ls -l /opt/scripta/bin/
ls
sudo rm /opt/scripta/bin/sgminer 
sudo screen -r
sudo mv sgminer /opt/scripta/bin/
cd /opt/scripta/bin/
ls
sudo chmod a+x sgminer 
ls
ls -l
sudo chmod 755 sgminer 
ls
ls -l
sudo screen -r
ls
sudo sync
sudo shutdown -h now
ls -al
cd
ls
sudo screen -r
ls
sudo rm /opt/scripta/bin/sgminer 
cd
ls
cd /opt/scripta/bin/
ls
sudo mv /home/baikal/sgminer  .
ls
sudo chmod a+x ./sgminer 
sudo screen -r
sudo halt
cd /oppu
sudo screen -r
sudo apt-get update baikal
sudo apt-get install gdb
gdb
sudo apt-get update
sudo apt-get install gdb
ls
sudo /opt/scripta/bin/
ls
sudo /opt/scripta/bin/
ls
cd /opt/scripta/bin/
ls
sudo rm sgminer
sudo reboot
ls
cd sgminer-5.6/
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
ls
sudo screen -r
sudo screen -rd
sudo screen -r
sudo apt-get install gdb
cd /opt/scripta/bin/
ls
sudo mv sgminer sgminer_new
cd
ls
cd sgminer-5.6/
ls
vi sgminer.conf
cd
ls
cd /opt/scripta/bin/
ls
sudo mv sgminer_new sgminer
ls
sudo screen -r
ls
cd sgminer-5.6/
ls
vi sgminer.c 
make
sudo ./update.sh 
sudo screen -r
ifconfig
ls
cd sgminer-5.6/
cd /opt/scripta/bin/
ls
sudo rm sgminer
ls
sudo screen -r
q
cd
ls
cd sgminer-5.6/
ls
gdb ./sgminer
./sgminer 
cd
ls
cd .sgminer/
ls
ls -al
cd
ls
cd sgminer-5.6/
ls
sudo ./update.sh 
sudo screen -r
cd
ls
vi sgminer.conf 
sudo vi sgminer.conf 
ls
sudo chmod 777 sgminer.conf 
ls
mv sgminer.conf sgminer-5.6/
cd sgminer-5.6/
ls
./sgminer
./sgminer -c ./sgminer.c
./sgminer -c ./sgminer.conf 
sudo cp sgminer.conf ../.sgminer/
./sgminer
sudo gdb
sudo gdb ./sgminer
ls
vi Makefile
ls
vi driver-baikalu.c 
ls
vi sgminer.c
ls
make
sudo ./update.sh 
sudo screen -r
ls
sudo screen -r
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
ls
vi driver-baikalu.c 
make
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
vi driver-baikal.h 
make
sudo ./update.sh 
sudo screen -r
ls
cd sgminer-5.6/
ls
make
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
sudo ./update.sh 
sudo screen -r
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
vi sgminer.c
vi driver-baikal.h 
vi driver-baikalu.c 
grep -Rni "update_work" .
sudo screen -r
ks
cd sgminer-5.6/
ls
grep -Rni "inappropiate" .
grep -Rni "inappropriately" .
sudo screen -r
vi driver-baikalu.c 
vi sgminer.c
make
ls
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
vi sgminer.c
make
vi sgminer.c
make
sudo ./update.sh 
sudo screen -r
top
ls
cd
ls
ls -al
su root
ls
cd
ls
cd sgminer-5.6/
ls
cd /opt/scripta/
lsl
ls
cd bin/
ls
cd
ls
cd sgminer-5.6/
ls
cd ..
ls
ls -al
cd .sgminer/
ls
cd
ls
finels
ls
cd
ls
su root
htop
ls
cd sgminer-5.6/
ls
make
sudo ./update.sh 
sudo screen -r
ls
make
sudo ./update.sh 
sudo screen -r
ls
cd sgminer-5.6/
ls
vi driver-baikal.h 
ls
vi driver-baikalu.c 
make
cd
ls
cd /opt/scripta/etc/
ls
vi miner.conf 
ls
cd
cd sgminer-5.6/
ls
sudo ./update.sh 
sudo screen -r
sudo ./update.sh 
sudo screen -r
top
htop
cd sgminer-5.6/
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
cd 
ls
su root
su root
ls
cd 
ls
su root
sudo screen -r
ls
cd
su root
cd 
ls
cd sgminer-5.6/
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
sudo reboot
ls
cd sgminer-5.6/
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
ls
sudo ./update.sh 
sudo screen -r
cd
su root
ls
su root
htop
ls
cd sgminer-5.6/
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
ls
cd sgminer-5.6/
ls
vi driver-baikalu.c 
sudo screen -r
sudo ./update.sh 
sudo screen -r
cd
ls
cd cd sgminer-5.6/
ls
vcd sgminer-5.6/
ls
cd sgminer-5.6/
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
sudo screen -rd
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
sudo ./update.sh 
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
ls
cd sgminer-5.6/
ls
make
sudo ./update.sh 
sudo screen -r
sudo screen -rd
ls
cd sgminer-5.6/
ls
vi driver-baikalu.c 
make
vi driver-baikalu.c 
make
vi driver-baikalu.c 
make
ls
vi driver-baikalu.c 
make
vi driver-baikalu.c 
make
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
vi sgminer.c
make
sudo ./update.sh 
sudo screen -r
make
sudo ./update.sh 
sudo screen -r
ls
vi sgminer.c
make
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
vi sgminer.c
make
sudo ./update.sh 
sudo screen -r
vi sgminer.c
make
vi miner.h 
make
sudo ./update.sh 
sudo screen -r
vi sgminer.c
make
sudo ./update.sh 
sudo screen -r
ls
vi sgminer.c
make
sudo ./update.sh 
sudo screen -r
vi sgminer.c
make
sudo ./update.sh 
sduo screen -r
sudo u./upda
sudo ./update.sh 
sudo screen -r
make
sudo ./update.sh 
sudo screen -r
make
sudo ./update.sh 
sudo screen -r
amke
make
sudo ./update.sh 
sudo screen -r
make
sudo ./update.sh 
sudo screen -r
make
sudo ./update.sh 
sudo screen -r
make
sudo ./update.sh 
sudo screen -r
cd sgminer-5.6/
ls
vi algorithm.c 
make
sudo ./update.sh 
sudo screen -r
ls
vi algorithm.c 
make
vi algorithm.c 
make
vi algorithm.c 
make
sudo ./update.sh 
sudo screen -r
ls
vi driver-baikalu.c 
make
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
vi algorithm.c 
make
sudo ./update.sh 
sudo screen -r
df
htop
cd sgminer-5.6/
ls
make
sudo reboot
cd sgminer-5.6/
ls
make
sudo ./update.sh 
sudo screen -r
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
ls
make
vi driver-baikalu.c 
sudo ./update.sh 
sudo screen -r
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
htop
sudo screen -r
cd sgminer-5.6/
ls
vi algorithm.h 
make
sudo ./update.sh 
sudo screen -r
ls
vi algorithm.
vi algorithm.h 
make
vi algorithm.h 
make
vi algorithm.h 
make
sudo ./update.sh 
sudo screen -r
make
sudo ./update.sh 
sudo screen -r
sudo ./update.sh 
sudo screen -r
sudo ./update.sh 
make
sudo ./update.sh 
ls
rm -rf * 
svn co svn://192.168.0.5/pacific/software/sgminer_5.6.x . 
cd ..
ls
svn co svn://192.168.0.5/pacific/software/sgminer_5.6.x .
cd sgminer-5.6/
ls
cd
ls
cd
ls
chmod a+x ./autogen.sh 
./autogen.sh 
./configure
ls
make
sudo ./update.sh 
chmod a+x ./update.sh 
sudo ./update.sh 
chmod a+x ./update.sh 
ls
sudo screen -r
sudo ./update.sh 
df
sudo reboot
ls
cd sgminer-5.6/
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
top
sudo screen -r
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
ls
vi driver-baikalu.c 
vi sgminer.c
ks
ls
sudo ./update.sh 
sudo screen -r
ls
cd
sudo screen -r
cd /opt/scripta/bin/
ls
ls 0l
ls -l
ls
cd
ls
vi driver-baikalu.c 
make
ls
vi sgminer.c 
make
sudo ./update.sh 
vi driver-baikalu.c 
make
vi sgminer.c 
make
sudo ./update.sh 
make
sudo ./update.sh 
ls
sudo ./sgminer /opt/scripta/etc/miner.conf 
sudo ./sgminer -c /opt/scripta/etc/miner.conf 
sudo ./update.sh 
sudo reboot
sudo ./update.sh 
sudo screen -r
ls
svn update
vi sgminer.c
svn diff | ^M 
svn diff
q
svn diff | ^M 
svn diff | ^M
svn diff | grep ^M
make
sudo ./update.sh 
sudo screen -r
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
make
sudo screen -r
vi driver-baikalu.c 
make
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
sudo screen 0r
sudo screen -r
ls
vi usbutils.c 
make
sudo ./update.sh 
sudo screen -r
ls
cd /var/www/
cd partials/
ls
vi miner.html 
sudo vi miner.html 
sudo screen -r
ls
cd
ls
cd driver-baikalu.c 
vi driver-baikalu.c 
make
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
vi driver-baikalu.c 
sudo screen -r
vi driver-baikalu.c 
sudo screen -r
vi driver-baikalu.c 
sudo screen -r
sudo lsusb
sudo shutdown -h now
sudo screen -r
vi usbutils.c 
make
sudo ./update.sh 
sudo screen -r
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
ls
vi usbutils.c 
sudo screen -r
ls
rm *.h
ls
rm *.o
rm *.c
ls
rm *.php
ls
rm Makefile.am 
ls
rm missing NEWS.md sgminer
ls
rm algorithm/
ls -al
ls
rm algorithm/
rm aclocal.m4 API.* AUTHORS.md config*
ls
rm -rf ADL_SDK/ api-example.py  auto* C* doc
ls
rm -rf a* c* e* i* l* 
ls
rm -rf depcomp kernel/ m4 Makefile* man/ M* 
ls
rm -rf mknsis.sh ocl/ README.md  sgminer.c.edited sph stamp-h1 submodules/ tools/ update.sh  winbuild/
ls
ls -al
rm -rf *.swp
ls
ls -al
rm -rf *.*.cwp
l
rm -rf *.*.swp
ls
ls -al
rm -rf .sgminer/
ls
cd .svn/
ls
cd ..
ls
rm -rf .svn/
ls
ls -al
rm .driver-baikalu.c.swp 
rm .git*
ls
rm -rf .libs/
rm -rf .nano/
ls
ls -al
rm -rf .deps/
ls
cd sgminer-5.6/
ls
svn update
cd ..
ls
rm -rf sgminer-5.6/
ls
ls -al
rm -rf .subversion/
ls
cd /opt/scripta/etc/
ls
cd /opt/scripta/
ls
rm -rf 20170210-1632/
sudo rm -rf 20170210-1632/
ls
cd etc/
ls
cd backup/
ls
rm -rf 20170*
sudo rm -rf 20170*
ls
cd
ls
cd
ls
svn co svn://192.168.0.5/pacific/software/sgminer_5.6.x 
ls
cd sgminer_5.6.x/
ls
chmod a+x autogen.sh 
ls
./autogen.sh 
ls
./configure 
make
sudo ./update.sh 
chomod a+x ./update.sh 
chmod a+x ./update.sh 
ls
vi algorithm.h 
vi algorithm.c 
sudo screen -r
cd /var/www/partials/
ls
vi miner.html 
sudo vi miner.html 
sudo screen -=r
sudo screen -r
sudo shutdown -h now
sudo screen -r
sudo shutdown -h now
ls
cd sgminer_5.6.x/
ls
vi usbutils.c 
make
sudo ./update.sh 
sudo screen -r
ls
vi driver-baikalu.c 
vi sgminer
vi sgminer.c 
cd /opt/scripta/
ls
cd etc/
ls
cd backup/
ls
cd 20170913-2245/
ls
cd etc/
ls
vi miner.conf 
ls
cd ..
ls
cd ..
ls
cd 20170913-2314/
ls
cd etc/
ls
vi miner.conf 
cd ..
ls
rm -rf 20170913-2314/
sudo rm -rf 20170913-2*
ls
exit
ls
sudo vi /etc/rc.local 
sync
sudo reboot
ls
cd sgminer_5.6.x/
ls
svn update
cd sgminer_5.6.x/
ls
svn update
ifconfig
svn update
ipconfig
ifconfig
ls
svn update
exit
cd sgminer_5.6.x/
ls
vi sgminer.c 
ls
./autogen.sh 
./configure 
make
sudo ./update.sh 
ls
sudo shutdown -h now
sudo lsusb
cd /sys/class/gpio_sw/
ls
cd PA18/
ls
cd
ls
echo 0 > /sys/class/gpio_sw/PA10/data 
ls
chmod a+x reset
chmod a+x reset.sh 
sudo ./reset.sh 
echo 0 > /sys/class/gpio_sw/PA18/data
sudo ./reset.sh 
lsusb 
ls
sudo ./reset.sh 
lsusb
ls
vi reset.sh 
mv reset.sh downmode.sh
cp downmode.sh normalmode.sh
vi normalmode.sh 
sl
ls
sudo ./normalmode.sh 
lsusb
sudo ./downmode.sh 
lsusb
ls
vi downmode.sh 
./downmode.sh 
sudo ./downmode.sh 
lsusb
sudo ./normalmode.sh 
lsusb
sudo ./downmode.sh 
lsusb
vi downmode.sh 
sudo ./downmode.sh 
lsusb
sudo ./normalmode.sh 
ls
vi reset_usb.c 
ls
vi downmode.sh 
ls
dfu-utils
dfu-util
ls
sudo apt-get install dfu-util
sudo apt-get install dfu-utils
sudo screen -r
q
sudo apt-get install dfu-utils
lks
ls
vi normalmode.sh 
lsusb
ls
vi ret.sh
ls
vi reset_usb.c 
ls
gcc -o reset_usb reset_usb.c `pkg-config --libs libusb-1.0`
vi reset_usb.c 
make
gcc -o reset_usb reset_usb.c `pkg-config --libs libusb-1.0`
ls
sudo ./reset_usb
vi reset_usb.c 
gcc -o reset_usb reset_usb.c `pkg-config --libs libusb-1.0`
sudo ./reset_usb
vi update_firmware.sh
vi update_firmware.sh 
sudo reboot
tail -f dmesg
tail -f /var/log/dmesg 
sudo tail -f /var/log/dmesg 
ls
vi reset.sh
vi reset.sh 
su root
ls
vi reset_usb.c 
gcc -o reset_usb reset_usb.c `pkg-config --libs libusb-1.0`
ls
mv reset_usb exit_dfu
ls
sudo ./exit_dfu 
vi downmode.sh 
ls
sudo ./downmode.sh 
vi update_firmware.sh 
ls
mv exit_dfu reset_dfu
mv enter_dfu reset_stm
ls
w
ls
sudo enter_normalmode.sh
sudo ./enter_normalmode.sh
ls
mv enter_downmmode.sh enter_dfumode.sh
mv enter_normalmode.sh enter_runmode.sh
ls
vi update_firmware.sh 
ls
sudo ./update_firmware.sh 
lsusb
sudo ./update_firmware.sh 
ls
vi update_firmware.sh 
ls
sudo ./update_firmware.sh 
ls
slmod
lsusb
sudo ./enter_dfumode.sh 
lsusb
ls
vi update_firmware.sh 
sudo ./update_firmware.sh 
ls
sudo ./enter_runmode.sh 
sudo lsusb
vi update_firmware.sh 
ls
sudo ./update_firmware.sh 
lsusb
ls
sudo ./enter_dfumode.sh 
sudo ./update_firmware.sh 
lsusb
sudo ./enter_dfumode.sh 
sudo ./update_firmware.sh 
sudo ./reset_dfu 
sudo ./reset_stm 
lsusb
ls
sudo ./enter_dfumode.sh 
lsusb
sudo ./reset_stm 
lsusb
sudo ./reset_dfu 
lsusb
sudo ./update_firmware.sh 
lsusb
sudo ./enter_dfumode.sh 
lsusb
ls
vi enter_dfumode.sh 
ls
sudo ./update_firmware.sh 
sudo ./enter_runmode.sh 
ls
mkdir firmware
ls
mv enter_*.sh firmware/
ls
vm reset_*fir
vm reset_* firmware/
ls
mv reset_* firmware/
ls
mv pacific.bin update_firmware.sh firmware/
ls
cd firmware/
ls
rm reset_usb.c 
ls
sync
cd
ls
cd sgminer_5.6.x/
ls
vi driver-baikal.h 
ls
sudo shutdown -h now
lsusb
cd firmware/
ls
sudo ./enter_runmode.sh 
sudo lsmod
lsusb
ls
vi enter_dfumode.sh 
ls
cat enter_runmode.sh 
cd
ls
cd /opt/scripta/etc/
ls
cd backup/
ls
mv 20171002-1613/ X11
sudo mv 20171002-1613/ X11
ls
sudo mv 20171002-1614/ DC
ls
sudo rm -rf DC
ls
cd sgminer_5.6.x/
ls
cd
su root
ls
cd sgminer_5.6.x/
ls
vi Makefile
ls
./autogen.sh 
ls
vi Makefile.am 
vi configure.ac
./autogen.sh 
./configure
make
sudo ./update.sh 
sync
ls
cd
ls
cd firmware/
ls
sudo halt
ls
cd firmware/
ls
vi enter_dfumode.sh 
vi update_firmware.sh 
cd
ls
ifconfig
ls
cd sgminer_5.6.x/
ls
vi driver-baikalu.c 
make
sudo ./update.sh 
sudo screen -r
ls
sync
make
sudo ./update.sh 
ls
vi driver-baikalu.c 
sudo halt
ls
cd firmware/
ls
vi enter_dfumode.sh 
sudo /opt/scripta/startup/miner-stop.sh 
vi update_firmware.sh 
ls
vi enter_dfumode.sh 
ls
vi update_firmware.sh 
./update_firmware.sh 1
vi update_firmware.sh 
./update_firmware.sh 1
ls
./update_firmware.sh pacific.bin 
dfu-util 
ls
ls
cd sgminer_5.6.x/
ls
make
sudo ./update.sh 
sudo screen -r
ls
sudo sync
sudo halt