cnc-club.ru

Код: Выделить всё

nkp@nkp-desktop:~/diff_hos_mod$ diff /home/nkp/diff_hos_mod/s/hostmot2.c   /home/nkp/diff_hos_mod/m/hostmot2.c
59,62d58
< int sserial_baudrate = 2500000;
< RTAPI_MP_INT(sserial_baudrate, "Over-ride the standard smart-serial baud rate. For flashing remote firmware only.");
< 
< 
1050d1045
<     hm2->sserial.baudrate = sserial_baudrate;




===================================================================
nkp@nkp-desktop:~/diff_hos_mod$ diff /home/nkp/diff_hos_mod/s/setsserial.c  /home/nkp/diff_hos_mod/m/setsserial.c
1,21d0
< //
< //    Copyright (C) 2011 Andy Pugh
< //
< //    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 2 of the License, or
< //    (at your option) any later version.
< //
< //    This program is distributed in the hope that it will be useful,
< //    but WITHOUT ANY WARRANTY; without even the implied warranty of
< //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
< //    GNU General Public License for more details.
< //
< //    You should have received a copy of the GNU General Public License
< //    along with this program; if not, write to the Free Software
< //    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
< //
< //
< //    The code in this file is based on UFLBP.PAS by Peter C. Wallace.  
< 
< #include <linux/firmware.h>
26d4
< #include "sserial.h"
40,43c18
< hostmot2_t *hm2;
< hm2_sserial_remote_t *remote;
< 
< int waitfor(void){
---
> int waitfor(hostmot2_t *hm2, hm2_sserial_remote_t *remote){
48c23
<         HM2READ(remote->command_reg_addr, buff);
---
>         hm2->llio->read(hm2->llio, remote->command_reg_addr, &buff, sizeof(u32));
54,62c29,30
<     
<     return 0;
< }
< 
< int doit(void){
<     u32 buff = 0x1000 | (1 << remote->index);
<     HM2WRITE(remote->command_reg_addr, buff);
<     if (waitfor() < 0) return -1;
<     HM2READ(remote->data_reg_addr, buff);
---
>                         
>     hm2->llio->read(hm2->llio, remote->data_reg_addr, &buff, sizeof(u32));
69a38
>         
71,98c40,42
< int stop_all(void){
<     u32 buff=0x8FF;
<     HM2WRITE(remote->command_reg_addr, buff);
<     return waitfor();
< }
< 
< int setup_start(void){
<     u32 buff=0xF00 | 1 << remote->index;
<     HM2WRITE(remote->command_reg_addr, buff);
<     if (waitfor() < 0) return -1;
<     HM2READ(remote->data_reg_addr, buff); 
<     rtapi_print("setup start: data_reg readback = %x\n", buff);
<     if (buff & (1 << remote->index)){
<         rtapi_print("Remote failed to start\n");
<         return -1;
<     }
<     return 0;
< }
< 
< int nv_access(u32 type){
<     u32 buff = LBPNONVOL_flag + LBPWRITE;
<     rtapi_print("buff = %x\n", buff);
<     HM2WRITE(remote->reg_cs_addr, buff);
<     HM2WRITE(remote->reg_0_addr, type);
<     return doit();
< }
< 
< int set_nvram_param(u32 addr, u32 value){
---
> int set_nvram_param(hostmot2_t *hm2, hm2_sserial_remote_t *remote, 
>                     u32 addr, 
>                     u32 value){
99a44
>     u32 doit;
101,109c46
<     if (stop_all() < 0) goto fail0;
<     if (setup_start() < 0) goto fail0;
<     if (nv_access(LBPNONVOLEEPROM) < 0) goto fail0;
<     
<     // value to set
<     HM2WRITE(remote->reg_0_addr, value);
<     buff = WRITE_REM_WORD_CMD | addr; 
<     HM2WRITE(remote->reg_cs_addr, buff);
<     if (doit() < 0) goto fail0;
---
>     doit = 0x1000 | (1 << remote->index);
111c48,64
<     if (nv_access(LBPNONVOLCLEAR) < 0) goto fail0;
---
>     //Stop
>     buff=0x8FF;
>     hm2->llio->write(hm2->llio, remote->command_reg_addr, &buff, sizeof(u32));
>     if (waitfor(hm2, remote) < 0) { goto fail0;}
>     
>     // Setup Start
>     buff=0xF00 | 1 << remote->index;
>     hm2->llio->write(hm2->llio, remote->command_reg_addr, &buff, sizeof(u32));
>     if (waitfor(hm2, remote) < 0) { goto fail0;}
>     
>     //Setup NV access on the correct channel and DoIt
>     buff = 0xEC000000; // Write access
>     hm2->llio->write(hm2->llio, remote->reg_cs_addr, &buff, sizeof(u32));
>     buff = 0x01;  // write byte
>     hm2->llio->write(hm2->llio, remote->reg_0_addr, &buff, sizeof(u32));
>     hm2->llio->write(hm2->llio, remote->command_reg_addr, &doit, sizeof(u32));
>     if (waitfor(hm2, remote) < 0) { goto fail0;}
112a66,79
>     // value to set
>     hm2->llio->write(hm2->llio, remote->reg_0_addr, &value, sizeof(u32));
>     buff = 0x65000000 | addr; // 16 bit write access request
>     hm2->llio->write(hm2->llio, remote->reg_cs_addr, &buff, sizeof(u32));
>     hm2->llio->write(hm2->llio, remote->command_reg_addr, &doit, sizeof(u32));
>     if (waitfor(hm2, remote) < 0) { goto fail0;}
>     
>      // Write access off
>     buff = 0xEC000000;
>     hm2->llio->write(hm2->llio, remote->reg_cs_addr, &buff, sizeof(u32));
>     buff = 0x00;  //off
>     hm2->llio->write(hm2->llio, remote->reg_0_addr, &buff, sizeof(u32));
>     hm2->llio->write(hm2->llio, remote->command_reg_addr, &doit, sizeof(u32));
> 
116c83
<     HM2WRITE(remote->command_reg_addr, buff);
---
>     hm2->llio->write(hm2->llio, remote->command_reg_addr, &buff, sizeof(u32));
122,420d88
< static void setsserial_release(struct device *dev) {
<     // nothing to do here
< }
< 
< int getlocal(int addr, int bytes){
<     u32 val = 0;
<     u32 buff;
<     for (;bytes--;){
<         buff = READ_LOCAL_CMD | (addr + bytes);
<         HM2WRITE(remote->command_reg_addr, buff);
<         waitfor();
<         HM2READ(remote->data_reg_addr, buff);
<         val = (val << 8) | buff;
<     }    return val;
< }
< 
< int setlocal(int addr, int val, int bytes){
<     u32 b = 0;
<     u32 buff;
<     int i;
<     for (i = 0; i < bytes; i++){
<         b = val & 0xFF;
<         val >>= 8;
<         HM2WRITE(remote->data_reg_addr, b);
<         buff = WRITE_LOCAL_CMD | (addr + i);
<         HM2WRITE(remote->command_reg_addr, buff);
<         if (waitfor() < 0) return -1;
<     }   
<     return 0;
< }
< 
< void sslbp_write_lbp(u32 cmd, u32 data){
<     u32 buff = LBPWRITE + cmd;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     HM2WRITE(remote->reg_0_addr, data);
<     doit();
<     buff = 0;
<     HM2WRITE(remote->reg_cs_addr, buff);
< }
< 
< int sslbp_read_cookie(void){
<     u32 buff = READ_COOKIE_CMD;
<     u32 res;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     if (doit() < 0){
<         HM2_ERR("Error in sslbp_read_cookie, trying to abort\n");
<         return -1;
<     }
<     HM2READ(remote->reg_0_addr, res);
<     buff = 0;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     return res;
< }
< 
< u8 sslbp_read_byte(u32 addr){
<     u32 buff = READ_REM_BYTE_CMD + addr;
<     u32 res;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     if (doit() < 0){
<         HM2_ERR("Error in sslbp_read_byte, trying to abort\n");
<         return -1;
<     }
<     HM2READ(remote->reg_0_addr, res);
<     buff = 0;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     return (u8)res;
< }
< 
< u16 sslbp_read_word(u32 addr){
<     u32 buff = READ_REM_WORD_CMD + addr;
<     u32 res;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     if (doit() < 0){
<         HM2_ERR("Error in sslbp_read_word, trying to abort\n");
<         return -1;
<     }
<     HM2READ(remote->reg_0_addr, res);
<     buff = 0;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     return (u16)res;
< }
< 
< u32 sslbp_read_long(u32 addr){
<     u32 buff = READ_REM_LONG_CMD + addr;
<     u32 res;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     if (doit() < 0){
<         HM2_ERR("Error in sslbp_read_long, trying to abort\n");
<         return -1;
<     }
<     HM2READ(remote->reg_0_addr, buff);
<     buff = 0;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     return res;
< }
< 
< u64 sslbp_read_double(u32 addr){
<     u64 res;
<     u32 buff = READ_REM_DOUBLE_CMD + addr;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     if (doit() < 0){
<         HM2_ERR("Error in sslbp_read_double, trying to abort\n");
<         return -1;
<     }
<     HM2READ(remote->reg_1_addr, buff);
<     res = buff;
<     res <<= 32;
<     HM2READ(remote->reg_0_addr, buff);
<     res += buff;
<     buff = 0;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     return res;
< }
< 
< int sslbp_write_byte(u32 addr, u32 data){
<     u32 buff = WRITE_REM_BYTE_CMD + addr;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     HM2WRITE(remote->reg_0_addr, data);
<     if (doit() < 0){
<         HM2_ERR("Error in sslbp_write_byte, trying to abort\n");
<         return -1;
<     }
<     buff = 0;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     return 0;
< }
< 
< int sslbp_write_word(u32 addr, u32 data){
<     u32 buff = WRITE_REM_WORD_CMD + addr;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     HM2WRITE(remote->reg_0_addr, data);
<     if (doit() < 0){
<         HM2_ERR("Error in sslbp_write_word, trying to abort\n");
<         return -1;
<     }
<     buff = 0;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     return 0;
< }
< 
< int sslbp_write_long(u32 addr, u32 data){
<     u32 buff = WRITE_REM_LONG_CMD + addr;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     HM2WRITE(remote->reg_0_addr, data);
<     if (doit() < 0){
<         HM2_ERR("Error in sslbp_write_long, trying to abort\n");
<         return -1;
<     }
<     buff = 0;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     return 0;
< }
< 
< int sslbp_write_double(u32 addr, u32 data0, u32 data1){
<     u32 buff = WRITE_REM_DOUBLE_CMD + addr;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     HM2WRITE(remote->reg_0_addr, data0);
<     HM2WRITE(remote->reg_1_addr, data1);
<     if (doit() < 0){
<         HM2_ERR("Error in sslbp_write_double, trying to abort\n");
<         return -1;
<     }
<     buff = 0;
<     HM2WRITE(remote->reg_cs_addr, buff);
<     return 0;
< }
< 
<     
< void flash_start(void){
<     sslbp_write_lbp(LBPNONVOL_flag, LBPNONVOLFLASH);
< }
< 
< void flash_stop(void){
<     sslbp_write_lbp(LBPNONVOL_flag, 0);
< }
<     
< int sslbp_flash(char *fname){
<     const struct firmware *fw;
<     struct device dev;
<     int r;
<     int write_sz, erase_sz;
<     
<     if (strstr("8i20", remote->name)){
<         if (hm2->sserial.version < 37){
<             rtapi_print("SSLBP Version must be at least v37 to flash the 8i20"
<                         "This firmware has v%i. Sorry about that\n"
<                         ,hm2->sserial.version);
<             return -1;
<         }
<     }
<     else if (hm2->sserial.version < 34){
<         rtapi_print("SSLBP Version must be at least v34. This firmware has v%i"
<                     "\n",hm2->sserial.version);
<         return -1;
<     }
<     
<     if (hm2->sserial.baudrate != 115200){
<         rtapi_print("To flash firmware the baud rate of the board must be set "
<                     "to 115200 by jumper, and in Hostmot2 using the "
<                     "sserial_baudrate modparam\n");
<         return -1;
<     }
<      
<     //Copied direct from hostmot2.c. A bit of a faff, but seems to be necessary. 
<     memset(&dev, '\0', sizeof(dev));
< #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,30)
<     strncpy(dev.bus_id, hm2->llio->name, BUS_ID_SIZE);
<     dev.bus_id[BUS_ID_SIZE - 1] = '\0';
< #else
<     dev_set_name(&dev, hm2->llio->name);
< #endif
<     dev.release = setsserial_release;
<     r = device_register(&dev);
<     if (r != 0) {
<         HM2_ERR("error with device_register\n");
<         return -1;
<     }
<     r = request_firmware(&fw, fname, &dev);
<     device_unregister(&dev);
<     if (r == -ENOENT) {
<         HM2_ERR("firmware %s not found\n",fname);
<         return -1;
<     }
<     if (r != 0) {
<         HM2_ERR("request for firmware %s failed, aborting\n", fname);
<         return -1;
<     }    
<     rtapi_print("Firmware size 0x%x\n", fw->size);
<     
<     if (setup_start() < 0) goto fail0;
<     flash_start();
<     write_sz = 1 << sslbp_read_byte(LBPFLASHWRITESIZELOC);
<     erase_sz = 1 << sslbp_read_byte(LBPFLASHERASESIZELOC);
<     HM2_PRINT("Write Size = %x, Erase Size = %x\n", write_sz, erase_sz);
<     flash_stop();
<     
<     //Programming Loop
<     {
<         int ReservedBlock = 0;
<         int StartBlock = ReservedBlock + 1;
<         
<         int blocknum = StartBlock;
<         int block_start;
<         int i, j, t;
<         while (blocknum * erase_sz < fw->size){
<             block_start = blocknum * erase_sz;
<             for (t = 0; t < erase_sz && fw->data[block_start + t] == 0 ; t++){ }
<             if (t <  erase_sz){ // found a non-zero byte
<                 flash_start();
<                 sslbp_write_long(LBPFLASHOFFSETLOC, block_start);
<                 sslbp_write_byte(LBPFLASHCOMMITLOC, FLASHERASE_CMD);
<                 if (sslbp_read_cookie() != LBPCOOKIE){
<                     HM2_ERR("Synch failed during block erase: aborting\n");
<                     goto fail0;
<                 }
<                 flash_stop();
<                 HM2_PRINT("Erased block %i\n", blocknum);
<                 flash_start();
<                 for (i = 0; i < erase_sz ; i += write_sz){
<                     sslbp_write_long(LBPFLASHOFFSETLOC, block_start + i);
<                     for (j = 0 ; j < write_sz ; j += 8){
<                         u32 data0, data1, m;
<                         m = block_start + i + j;
<                         data0 = (fw->data[m] 
<                               + (fw->data[m + 1] << 8)
<                               + (fw->data[m + 2] << 16)
<                               + (fw->data[m + 3] << 24));
<                         data1 = (fw->data[m + 4] 
<                               + (fw->data[m + 5] << 8)
<                               + (fw->data[m + 6] << 16)
<                               + (fw->data[m + 7] << 24));
<                         sslbp_write_double(j, data0, data1);
<                     }
<                     sslbp_write_byte(LBPFLASHCOMMITLOC, FLASHWRITE_CMD);
<                     if (sslbp_read_cookie() != LBPCOOKIE){
<                         HM2_ERR("Synch failed during block write: aborting\n");
<                         goto fail0;
<                     }
<                 }
<                 flash_stop();
<                 HM2_PRINT("Wrote block %i\n", blocknum);
<             }
<             else // Looks like an all-zeros block
<             { 
<                 HM2_PRINT("Skipped Block %i\n", blocknum);
<             }
<             blocknum++;
<         }
<     }
<     
<     release_firmware(fw);
<     
<     return 0;
<     
< fail0:
<     flash_stop();
<     return -1;
< }
< 
424c92,94
<     
---
>     hm2_sserial_remote_t *remote;
>     hostmot2_t *hm2;
> 
430,437d99
<     remote = hm2_get_sserial(&hm2, cmd_list[1]);
<     if (! remote) {   
<         rtapi_print_msg(RTAPI_MSG_ERR,
<                         "Unable to find sserial remote corresponding to %s\n", 
<                         cmd_list[1]);
<         return -1;
<     }    
<     
442a105,111
>         remote = hm2_get_sserial(&hm2, cmd_list[1]);
>         if (! remote) {   
>             rtapi_print_msg(RTAPI_MSG_ERR,
>                             "Unable to find sserial remote corresponding to %s\n", 
>                             cmd_list[1]);
>             return -1;
>         }
457c126
<         rtapi_print("remote name = %s ParamAddr = %x Value = %i\n",
---
>         rtapi_print("remote name = %s PamrAddr = %x Value = %i\n",
461c130
<         if (set_nvram_param(addr, value) < 0) {
---
>         if (set_nvram_param(hm2, remote, addr, value) < 0) {
470c139
<     else if (! strncmp("flash", cmd_list[0], 5) && cnt == 3){
---
>     else if (! strncmp("flash", cmd_list[0], 5) && cnt == 2){
472,484d140
<         if ( ! strstr(cmd_list[2], ".BIN")){
<             rtapi_print("Smart-Serial remote firmwares are .BIN format\n "
<                         "flashing with the wrong one would be bad. Aborting\n");
<             return -EINVAL;
<         }
<         if (sslbp_flash(cmd_list[2]) < 0){
<             rtapi_print_msg(RTAPI_MSG_ERR, "Firmware Flash Failed\n");
<             return -1;
<         } 
<         else
<         {   rtapi_print_msg(RTAPI_MSG_ERR, "Firmware Flash Success\n");
<             return 0;
<         } 
503d158
< 
nkp@nkp-desktop:~/diff_hos_mod$ 
===============================================================
nkp@nkp-desktop:~/diff_hos_mod$ diff /home/nkp/diff_hos_mod/s/sserial.c  /home/nkp/diff_hos_mod/m/sserial.c
39,42d38
< int getlocal32(hostmot2_t *hm2, hm2_sserial_instance_t *inst, int addr);
< int getlocal8(hostmot2_t *hm2, hm2_sserial_instance_t *inst, int addr);
< int check_set_baudrate(hostmot2_t *hm2, hm2_sserial_instance_t *inst);
< int setlocal32(hostmot2_t *hm2, hm2_sserial_instance_t *inst, int addr, int val);
51c47
<     u32 ddr_reg, src_reg, buff;
---
>     u32 ddr_reg, src_reg, addr, buff;
158c154
<         HM2WRITE(inst->command_reg_addr, buff);
---
>         hm2->llio->write(hm2->llio, inst->command_reg_addr, &buff, sizeof(u32));
160c156
<         HM2WRITE(inst->command_reg_addr, buff);
---
>         hm2->llio->write(hm2->llio, inst->command_reg_addr, &buff, sizeof(u32));
166c162,168
<             buff=getlocal8(hm2, inst, SSLBPMINORREVISIONLOC);
---
>             buff=0x2003; //Read firmware version
>             hm2->llio->write(hm2->llio, inst->command_reg_addr, &buff, sizeof(u32));
>             if (hm2_sserial_waitfor(hm2, inst->command_reg_addr, 0xFFFFFFFF,49) < 0){
>                 r = -EINVAL;
>                 goto fail0;
>             }
>             hm2->llio->read(hm2->llio, inst->data_reg_addr, &buff, sizeof(u32));
169,171d170
<         hm2->sserial.version = buff;
<         
<         if (check_set_baudrate(hm2, inst) < 0) goto fail0;
179d177
<             u32 addr0, addr1, addr2;
181,182c179,180
<             
<             addr0 = md->base_address + 3 * md->register_stride
---
>             // user10 addr
>             addr = md->base_address + 3 * md->register_stride
184,187c182,185
<             HM2READ(addr0, user0);
<             HM2_DBG("Inst %i Chan %i User0 = %x\n", i, c, user0);
< 
<             addr1 = md->base_address + 4 * md->register_stride
---
>             hm2->llio->read(hm2->llio, addr, &user0, sizeof(u32));
>             HM2_DBG("User0 = %x\n", user0);
>             // user1 addr
>             addr = md->base_address + 4 * md->register_stride
189,239c187,196
<             HM2READ(addr1, user1);
<             HM2_DBG("Inst %i Chan %i User1 = %x\n", i, c, user1);
<             
<             addr2 = md->base_address + 5 * md->register_stride
<             + i * md->instance_stride + c * sizeof(u32);
<             HM2READ(addr2, user2);
<             HM2_DBG("Inst %i Chan %i User2 = %x\n", i, c, user2);
<             
<             if (hm2->sserial.baudrate == 115200
<                 && hm2->config.sserial_modes[i][c] != 'x') { //setup mode
<                 rtapi_print("Setup mode\n");
<                 if ((user1 & 0xFF00) == 0x4900){ //XiXXboard
<                     
<                     rtapi_print("found a %4s\n", (char*)&user1);
<                     
<                     inst->num_remotes += 1;
<                     inst->tag |= 1<<c;
<                 }
<                 else { // Look for 8i20s with the CRC check off
<                     int lbpstride = getlocal8(hm2, inst, SSLBPCHANNELSTRIDELOC);
<                     int crc_addr = getlocal8(hm2, inst, SSLBPCHANNELSTARTLOC) 
<                     + (c * lbpstride) + 30;
<                     
<                     rtapi_print("Looking for 8i20s, crc_addr = %i\n", crc_addr);
<                     
<                     if (getlocal8(hm2, inst, SSLBPMINORREVISIONLOC) < 37 ){
<                         HM2_PRINT("Unable to check for 8i20s with firmware < 37 "
<                                   "If you are not trying to reflash an 8i20 then"
<                                   " ignore this message.\n");
<                     }
<                     else if (setlocal32(hm2, inst, crc_addr, 0xFF) < 0) {
<                         HM2_ERR("Unable to disable CRC to check for old 8i20s");
<                     }
<                     else if ( hm2_sserial_stopstart(hm2, md, inst, 0xF00) < 0) {
<                         goto fail0;
<                     }
<                     else {
<                         HM2READ(addr1, user1);
<                         
<                         rtapi_print("found a %4s\n", (char*)&user1);
<                         
<                         if ((user1 & 0xFF00) == 0x4900){ //XiXXboard
<                             inst->num_remotes += 1;
<                             inst->tag |= 1<<c;
<                         }
<                     }
<                 }
<             }
<             else if ((user2 & 0x0000ffff) // Parameter discovery
<                      || user1 == HM2_SSERIAL_TYPE_7I64 //predate discovery
<                      || user1 == HM2_SSERIAL_TYPE_8I20 ){
---
>             hm2->llio->read(hm2->llio, addr, &user1, sizeof(u32));
>             HM2_DBG("User1 = %x\n", user1);
>             // user2 addr
>             addr = md->base_address + 5 * md->register_stride
>                                     + i * md->instance_stride + c * sizeof(u32);
>             hm2->llio->read(hm2->llio, addr, &user2, sizeof(u32));
>             HM2_DBG("User2 = %x\n", user2);
>             if ((user2 & 0x0000ffff) // Parameter discovery
>                 || user1 == HM2_SSERIAL_TYPE_7I64 //predate discovery
>                 || user1 == HM2_SSERIAL_TYPE_8I20){
243,250c200
<             else if (hm2->config.sserial_modes[i][c] != 'x'){
<                 HM2_ERR("Unsupported Device (%4s) found on sserial %d "
<                         "channel %d\n", (char*)&user1, i, c);
<             }
<             
<             // nothing connected, or masked by config or wrong baudrate or.....
<             // make the pins into GPIO. 
<             if ((inst->tag & 1<<c) == 0){ 
---
>             else if (user1 == 0){ // nothing connected, or masked by config
259c209,213
< 
---
>             else
>             {
>                 HM2_ERR("Unsupported Device (%s) found on sserial %d "
>                         "channel %d\n", (char*)&user1, i, c);
>             }
275c229,237
<                 //goto fail0; // Ignore it for the moment. 
---
>                 ///////////////////////
>                 buff=0x2003; //Stop All
>                     hm2->llio->write(hm2->llio,hm2->sserial.instance[i].command_reg_addr, &buff, sizeof(u32));
>                 if (0 > hm2_sserial_waitfor(hm2, hm2->sserial.instance[i].command_reg_addr, 0xFFFFFFFF, 1012)){
>                     HM2_ERR("Timeout in random debug code\n");
>                 }
>                 hm2->llio->read(hm2->llio,hm2->sserial.instance[i].data_reg_addr, &buff, sizeof(u32));
>                 HM2_PRINT("data reg readback after it all turned bad: %x\n", buff);
>                 //goto fail0;
425d386
<             chan->myinst = inst->index;
587,594c548
<         if (hm2->sserial.baudrate == 115200) {
<             HM2_PRINT("Setup mode, creating no pins for smart-serial channel %s\n",
<                       chan->name);
<             chan->num_confs = 0;
<             chan->num_globals = 0;
<             return 0;
<         }
<         else if (strstr(chan->name, "8i20")){
---
>         if (strstr(chan->name, "8i20")){
600d553
<         else { HM2_ERR("No GTOC in sserial read globals\n"); return -1;}
1581,1658d1533
< int getlocal8(hostmot2_t *hm2, hm2_sserial_instance_t *inst, int addr){
<     u32 val = 0;
<     u32 buff;
<     buff = READ_LOCAL_CMD | addr;
<     HM2WRITE(inst->command_reg_addr, buff);
<     hm2_sserial_waitfor(hm2, inst->command_reg_addr, 0xFFFFFFFF, 22);
<     HM2READ(inst->data_reg_addr, buff);
<     val = (val << 8) | buff;
<     return val;
< }
< 
< int getlocal32(hostmot2_t *hm2, hm2_sserial_instance_t *inst, int addr){
<     u32 val = 0;
<     int bytes = 4;
<     u32 buff;
<     for (;bytes--;){
<         buff = READ_LOCAL_CMD | (addr + bytes);
<         HM2WRITE(inst->command_reg_addr, buff);
<         hm2_sserial_waitfor(hm2, inst->command_reg_addr, 0xFFFFFFFF, 22);
<         HM2READ(inst->data_reg_addr, buff);
<         val = (val << 8) | buff;
<     }    
<     return val;
< }
< 
< int setlocal32(hostmot2_t *hm2, hm2_sserial_instance_t *inst, int addr, int val){
<     int bytes = 0;
<     u32 buff;
<     for (;bytes < 4; bytes++){
<         
<         if (hm2_sserial_waitfor(hm2, inst->command_reg_addr, 0xFFFFFFFF, 22) < 0) {
<             HM2_ERR("Command register not ready\n");
<             return -1;
<         }
<         
<         buff = val & 0xff;
<         val >>= 8;
<         HM2WRITE(inst->data_reg_addr, buff);
<         buff = WRITE_LOCAL_CMD | (addr + bytes);
<         HM2WRITE(inst->command_reg_addr, buff);
<         
<         if (hm2_sserial_waitfor(hm2, inst->command_reg_addr, 0xFFFFFFFF, 22) < 0) {
<             HM2_ERR("Write failure attempting to set baud rate\n");
<             return -1;
<         }
<     }    
<     return 0;
< }
< 
< int check_set_baudrate(hostmot2_t *hm2, hm2_sserial_instance_t *inst){
<     u32 baudrate;
<     int baudaddr;
<     int lbpstride; 
<     u32 buff;
<     int c;
<     
<     lbpstride = getlocal8(hm2, inst, SSLBPCHANNELSTRIDELOC);
<     HM2_PRINT("num_channels = %i\n", inst->num_channels);
<     for (c = 0; c < inst->num_channels; c++){
<         baudaddr = getlocal8(hm2, inst, SSLBPCHANNELSTARTLOC) + (c * lbpstride) + 42;
<         baudrate = getlocal32(hm2, inst, baudaddr);
<         HM2_PRINT("Chan %i baudrate = %i\n", c, baudrate);
<         if (baudrate != hm2->sserial.baudrate) {
<             if (setlocal32(hm2, inst, baudaddr, hm2->sserial.baudrate) < 0) {
<                 HM2_ERR("Problem setting new baudrate, power-off reset may be needed to"
<                         " recover from this.\n");
<                 return -1;
<             }
<             baudrate = getlocal32(hm2, inst, baudaddr);
<             HM2_PRINT("Chan %i. Baudrate set to %i\n", c, baudrate);
<         }
<     }
<     buff = 0x800; HM2WRITE(inst->command_reg_addr, buff); // stop all
<     
<     return 0;
< }
< 
<