Baikal X10 ⚡OVERCLOCK⚡ Claim reward 0.2 BTC for TUTORIAL HOW TO :)⚡⚡⚡⚡

[tboy32c]

I found quit a bit of the source for sgminer after writing the bin image(PiZero_GX10_171229_V1.1.img) to an SD card and looking at deleted files.  ...

Thanks for the info. Care to share what method you used to find the deleted files once the image was written to the SD card? Do the filenames seem to correlate with their contents?

I just used photorec to recovery any/all deleted files, then used astrogrep to do some searching.  The file names do not correlate.  Photorec just gives them a generic name.  We'll need more people searching for the other source files, my brain hurts.  ;o) 

Excellent discovery. Looks like this is pretty much all that is needed to build a custom sgminer for the Giants. Notice all the algorithms listed:

Code:

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

Did you happen to find the file defining

Code:

ALGO_X11
ALGO_QUARK
ALGO_QUBIT
etc...

?

Of particular interest is this line:

Code:

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

It looks like calling baikal_setoption() allows the clock to be set to an arbitrary value.

Does anyone have an opinion on which fork of sgminer is the best to start from? Stripping all the GPU/OpenCL related code should probably be done first, then this source can be added.

[CNoteFan]

Here it is.  A slightly modified algorithm.h file:

Code:

#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 */

[tboy32c]

Here it is.  A slightly modified algorithm.h file:

Thanks. Now I'm interested in:

Code:

int to_baikal_algorithm(algorithm_type_t type);

In a different file:

Code:

#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 

Looks like this is a pretty old version of the source as that list doesn't contain Skein or MGroestl, as the x10 is known to have. This looks like the same list of algorithms that Baikal's older Mini Miner and Giant A900 Dash Miner had so it may not have any new code at all for the x10/B/N (in this deleted version). Maybe it's just as easy as adding a few cases in there for the missing ones and using guess-and-check to get the right values.

[CNoteFan]

Could be.  There are many copies of most of the files, I think they'll need to be compared to figure out the latest version.  I am hoping someone smarter than me can piece it together and at least get the clock rate adjustable.  Give me some more keywords to search for and I'll try to post more information.  The searches take a while to complete.

[fawasme]

Will try to reocover more files. In the other hand, I was messing around the terminal of the X10, went in root mode to some folders inside where they code a lot about the clockrate of each of the three cards, will post about it later on guys.

I do believe Baikal will not help us to make more money, but if we get together we can make this machine a BEAST mining any algo at diffrerent clockrates!

Keep it up guys...very nice work! will help for sure...lets try to get this more private.

[fawasme]

By the way, while looking at some TAR Files recovered, I do see a lot "fakeroot" mentions, and a "ustar" mention, maybe the wanna play us with some fakeroot login through terminal....

I am not a programmer but just saying...

[cod3gen]

Im more interested in what other coins can be mined. Currently what i have figured out is that;
Currently included:
X11
QUARK
QUBIT
SKEIN
MyrGroestl

Possible and highly likely alternatives listed below, however they are defined with a different type of X10 it seems, so im not sure it even will be possible for those that are for sale now:
- Groestl
- Nist5
- X11 Gost
- Veltor

These alternatives are based on recovered files. The code also seems to reveal that they have had the "new" CN miner a long time, actually it would seem as they maybe even started production of that one before X10.

Currently done recovering about 80% of the code, will probably start trying to recompile to see if it works tomorrow.

[ruplikminer]

Im more interested in what other coins can be mined. Currently what i have figured out is that;
Currently included:
X11
QUARK
QUBIT
SKEIN
MyrGroestl

Possible and highly likely alternatives listed below, however they are defined with a different type of X10 it seems, so im not sure it even will be possible for those that are for sale now:
- Groestl
- Nist5
- X11 Gost
- Veltor

These alternatives are based on recovered files. The code also seems to reveal that they have had the "new" CN miner a long time, actually it would seem as they maybe even started production of that one before X10.

Currently done recovering about 80% of the code, will probably start trying to recompile to see if it works tomorrow.

Amazing I am very excited about it. I will have xome X10 soon. Keep us updated!

[CNoteFan]

Here it is.  A slightly modified algorithm.h file:

Thanks. Now I'm interested in:

Code:

int to_baikal_algorithm(algorithm_type_t type);

In a different file:

Code:

#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 

Looks like this is a pretty old version of the source as that list doesn't contain Skein or MGroestl, as the x10 is known to have. This looks like the same list of algorithms that Baikal's older Mini Miner and Giant A900 Dash Miner had so it may not have any new code at all for the x10/B/N (in this deleted version). Maybe it's just as easy as adding a few cases in there for the missing ones and using guess-and-check to get the right values.

Did those earlier generations use pi's also?  I've never messed with them.

Here's a couple snippets from another version that do contain Skein and Myriad Groestl:

Code:

...
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);
}
...

Code:

...
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;
}
...

[adra12]

I just used photorec to recovery any/all deleted files, then used astrogrep to do some searching.  The file names do not correlate.  Photorec just gives them a generic name.  We'll need more people searching for the other source files, my brain hurts.  ;o)  

Can someone post the very first image file for the X10? I have v1.0 and v1.1, but was thinking I heard someone mention an earlier one.

Nice find!
Actually the c file source code looks like that it belongs to a Giant B based on the static bool baikal_send_work function. And the DEVICE_BAIKAL_H header file that you posted seems to belong to a MINI or CUBE miner. Strange...

Could you please upload the v1.0 image file to mega.nz or google drive?

[adra12]

Of particular interest is this line:

Code:

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

It looks like calling baikal_setoption() allows the clock to be set to an arbitrary value.

To be honest I don't get the point of this part ((clk / 10) % 20) + 2
It just doesn't make any sense to me. If the clock is set to 400 MHz, then the msg.data[0] value will be 2. While if the clock is 300 MHz, then msg.data[0] is 12.
What is the logic here?

[cod3gen]

Nice find! Actually the source code looks like that it belongs to a Giant B, is that correct?

From what ive found, source code is same for X10, B and CN.

[tboy32c]

Of particular interest is this line:

Code:

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

It looks like calling baikal_setoption() allows the clock to be set to an arbitrary value.

To be honest I don't get the point of this part ((clk / 10) % 20) + 2
It just doesn't make any sense to me. If the clock is set to 400 MHz, then the msg.data[0] value will be 2. While if the clock is 300 MHz, then msg.data[0] is 12.
What is the logic here?

[divide by 10] indicates 10MHz increments, [mod 20] indicates a lookup table with 20 items, [+ 2] indicates the list begins at index #2:

Code:

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

Not sure whether, for example, #7 would give 450 or 250MHz - an experiment is needed.

[fawasme]

Hey guys,


two things to say,

We need to work on two things, overclocking to 420MHz and to recover the data of the two algorithms. missing:

1) Will upload to Mega the recovered data so you can see for yourself what you can work with..

2) Will it help (overclocking) this info found in the SD Image?

root@Baikal:/sys/bus/cpu/devices/cpu0/cpufreq# ls                         
affected_cpus      cpuinfo_transition_latency   scaling_governor         
boot_lock          dvfs_debug                   scaling_max_freq         
cpuinfo_boot_freq  related_cpus                 scaling_min_freq         
cpuinfo_cur_freq   scaling_available_governors  scaling_setspeed         
cpuinfo_max_freq   scaling_cur_freq             stats
cpuinfo_min_freq   scaling_driver     

---------------------------------
  GNU nano 2.5.3          File: cpuinfo_cur_freq                         
                                                                         
816000                                                                   
                --

Also while messing with the terminal, an auto generated mail went to the root folder saying

Subject: *** SECURITY information for baikal ***                         

baikal : Feb 10 07:34:20 : www-data : user NOT in sudoers ; TTY=unknown ;$
                                                                         
From www-data@baikal  Fri Feb 10 07:35:24 2017                           
Return-Path: <www-data@baikal>                                           
Received: from baikal (baikal [127.0.0.1])                               
        by baikal (8.15.2/8.15.2/Debian-3) with ESMTP id v1A7ZOC3017405   
        for <root@baikal>; Fri, 10 Feb 2017 07:35:24 GMT                 
Received: (from www-data@localhost)                                       
        by baikal (8.15.2/8.15.2/Submit) id v1A7ZOLM017255;               
        Fri, 10 Feb 2017 07:35:24 GMT                                     
Date: Fri, 10 Feb 2017 07:35:24 GMT                                       
Message-Id: <201702100735.v1A7ZOLM017255@baikal>                         
To: root@baikal                                                           
From: www-data@baikal                                                     
Auto-Submitted: auto-generated                                           
Subject: *** SECURITY information for baikal ***                         
                                                                         
baikal : Feb 10 07:34:24 : www-data : user NOT in sudoers ; TTY=unknown ;$

[CNoteFan]

I just used photorec to recovery any/all deleted files, then used astrogrep to do some searching.  The file names do not correlate.  Photorec just gives them a generic name.  We'll need more people searching for the other source files, my brain hurts.  ;o)  

Can someone post the very first image file for the X10? I have v1.0 and v1.1, but was thinking I heard someone mention an earlier one.

Nice find!
Actually the c file source code looks like that it belongs to a Giant B based on the static bool baikal_send_work function. And the DEVICE_BAIKAL_H header file that you posted seems to belong to a MINI or CUBE miner. Strange...

Could you please upload the v1.0 image file to mega.nz or google drive?

Here's a link to the undeleted bin (PiZero_GX10_171229_V1.1.img) file:

https://drive.google.com/file/d/14__gwiueXt-OBfkveUK_eMqmNhKxajni/view?usp=sharing

I haven't started uploading the 4 gig (PiZero_GX10_171229_V1.0.img) file.  I'll do it if you really need it and of course if no one else uploads it!

[pikachuy]

If anyone have the Giant B and Giant x10 and don't mind doing a little work, can you take out the controller board (the board that goes on top of the 3 hash boards) and also the orange pi and swap them?

Want to see if the 3 hashing boards on the Giant B and Giant x10 are the same. If it works, then that means you will only need to update the controller board first, since just swapping out SD Cards does nothing.

It will be pointless trying to compile a custom sgminer if you require to update the controller board first.

[cod3gen]

Ive been able to recompile sgminer based on files from X10 and CN, however some problems at hand with USB communcation to the boards, guess ill figure out those in a while. As an example i found nothing less than 33 different versions of driver-baikalu.c, so there will be some sorting before everythings ok.

Code:

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)

If anyone have the Giant B and Giant x10 and don't mind doing a little work, can you take out the controller board (the board that goes on top of the 3 hash boards) and also the orange pi and swap them?

Want to see if the 3 hashing boards on the Giant B and Giant x10 are the same. If it works, then that means you will only need to update the controller board first, since just swapping out SD Cards does nothing.

It will be pointless trying to compile a custom sgminer if you require to update the controller board first.

X10, B and CN all have different chips, so i dont think it will be possible to cross them, i would not suggest that any one tries this unless they have no problem risking their hardware.

X10 seems to be able to support additional coins: groestl, nist5, x11-gost and veltor, thats atleast what im trying to figure out.

[Selector79]

If anyone have the Giant B and Giant x10 and don't mind doing a little work, can you take out the controller board (the board that goes on top of the 3 hash boards) and also the orange pi and swap them?

Want to see if the 3 hashing boards on the Giant B and Giant x10 are the same. If it works, then that means you will only need to update the controller board first, since just swapping out SD Cards does nothing.

It will be pointless trying to compile a custom sgminer if you require to update the controller board first.

We tryed it.  It does not work.  They are different!

[Ironeinstein]

Uploaded the three firmwares I have here:

https://drive.google.com/open?id=1Xyn5R6X38Jx4i9J50pF_upwgs0hdoXGN

Files are PiZero_GX10_171111_V1.0.img, PiZero_GX10_171229_V1.1.img, PiZero_GB_180105_V1.0.img

[CNoteFan]

Ive been able to recompile sgminer based on files from X10 and CN, however some problems at hand with USB communcation to the boards, guess ill figure out those in a while. As an example i found nothing less than 33 different versions of driver-baikalu.c, so there will be some sorting before everythings ok.

Code:

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)

If anyone have the Giant B and Giant x10 and don't mind doing a little work, can you take out the controller board (the board that goes on top of the 3 hash boards) and also the orange pi and swap them?

Want to see if the 3 hashing boards on the Giant B and Giant x10 are the same. If it works, then that means you will only need to update the controller board first, since just swapping out SD Cards does nothing.

It will be pointless trying to compile a custom sgminer if you require to update the controller board first.

X10, B and CN all have different chips, so i dont think it will be possible to cross them, i would not suggest that any one tries this unless they have no problem risking their hardware.

X10 seems to be able to support additional coins: groestl, nist5, x11-gost and veltor, thats atleast what im trying to figure out.

Great work!
Did you add these changes to usbutils.h?

Code:

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