Код: Выделить всё
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;
< }
<
<
Вроде в правах поставил галку "разрешить исполнение программы" Если выполняю в терминале "chmod a+x mesaflash" пишет "chmod: невозможно получить доступ к «mesaflash»: Нет такого файла или каталога"
