// SPDX-License-Identifier: GPL-2.0+ /* * (C) Copyright 2002 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com */ /* * SPI Read/Write Utilities */ #include #include #include #include #include /*----------------------------------------------------------------------- * Definitions */ #ifndef MAX_SPI_BYTES #define MAX_SPI_BYTES 64 /* Maximum number of bytes we can handle */ #endif /* * Values from last command. */ static unsigned int bus; static unsigned int cs; static unsigned int mode; static int bitlen; static unsigned int speed = 10000000; static uchar dout[MAX_SPI_BYTES]; static uchar din[MAX_SPI_BYTES]; typedef struct { /* data */ char* cmd_str; unsigned char cmd_code; }ate_cmd_t; static ate_cmd_t g_ate_cmd_table[] = { {"rd.b",0xb1}, {"rd.w",0xb3}, {"rd.l",0xb2}, {"wr.b",0xa1}, {"wr.w",0xa3}, {"wr.l",0xa2}, }; static inline int ate_is_write_cmd(unsigned char cmd){ if(cmd == 0xa1 || cmd == 0xa2 || cmd == 0xa3 ) { return 1; } else { return 0; } } static int ate_get_reg_width(unsigned char cmd) { int len = 0; switch (cmd) { case 0xa1: case 0xb1: len = 1; break; case 0xa2: case 0xb2: len = 4; break; case 0xa3: case 0xb3: len = 2; break; default: break; } return len; } static inline int ate_get_write_rsp(unsigned char *rsp, unsigned char *err_code) { /* 0xc1 + err_code*/ if(rsp == NULL || err_code == NULL) return -1; *err_code = *(rsp+1); return 0; } static int ate_get_read_value(unsigned char *rsp, unsigned int reg_len, unsigned int *val) { unsigned i; if(rsp == NULL || val == NULL) return -1; /*0xc1 + 1/2/4B */ *val = 0; for(i = 0; i < reg_len; i++) { *val |= *(rsp+1+i) << (i*8); } return 0; } static int ate_build_cmd_frame(unsigned char cmd,unsigned long long reg_addr, unsigned int reg_value) { int spi_frame_index = 0,i,len; memset(dout,0,sizeof(dout)); memset(din,0,sizeof(din)); /*fill cmd code*/ dout[spi_frame_index++] = cmd; //printf("spi_frame_index: %d\n",spi_frame_index); /*fill reg_addr,exp 0xffea000000 -> 0x00 0x00 0x00 0xea 0xff */ for(i = 0; i < 5; i++){ dout[spi_frame_index++] = (unsigned char)((reg_addr >> i*8 ) &0xFF); } //printf("spi_frame_index: %d\n",spi_frame_index); /*check whether send reg_value and reg_value length in bytes */ len = ate_get_reg_width(cmd); /* fill reg-value */ if(ate_is_write_cmd(cmd)) { for(i = 0; i < len; i++) { dout[spi_frame_index++] = (unsigned char)((reg_value >> i*8 ) &0xFF); } } //printf("spi_frame_index: %d\n",spi_frame_index); /*insert 2-byte or 3byte dummy data */ if(ate_is_write_cmd(cmd)) { spi_frame_index +=2; }else { spi_frame_index +=2; } //printf("spi_frame_index: %d %d\n",len,spi_frame_index); /*pading clk for rsp */ if(ate_is_write_cmd(cmd)) { /*0xc1 + err_code(1B)*/ spi_frame_index +=2; }else { /*0xc1 + 1B/2B/4B data */ spi_frame_index +=len + 1; } //printf("spi_frame_index: %d\n",spi_frame_index); #if 0 for(i= 0; i < spi_frame_index; i++){ if(i == 0) printf("spi_tx_frame:"); printf("%02x ",dout[i]); if(i == spi_frame_index-1) printf("\n"); } #endif return spi_frame_index; } static int ate_get_cmd_code(char*pcmd, uchar* cmd) { unsigned int table_len = sizeof(g_ate_cmd_table)/sizeof(g_ate_cmd_table[0]); unsigned int i; for(i = 0 ; i < table_len; i++){ if(!strcmp(pcmd,g_ate_cmd_table[i].cmd_str)){ *cmd = g_ate_cmd_table[i].cmd_code; return 0; } } return -1; } static void ate_spi_config(unsigned int bus, unsigned int cs, unsigned mode, unsigned int speed) { bus = bus; cs = cs; mode = mode; speed = speed; return; } static int do_spi_xfer(int bus, int cs ,int bprint_rx) { struct spi_slave *slave; int ret = 0; int j; #ifdef CONFIG_DM_SPI char name[30], *str; struct udevice *dev; snprintf(name, sizeof(name), "generic_%d:%d", bus, cs); str = strdup(name); if (!str) return -ENOMEM; ret = spi_get_bus_and_cs(bus, cs, speed, mode, "spi_generic_drv", str, &dev, &slave); if (ret) return ret; #else slave = spi_setup_slave(bus, cs, speed, mode); if (!slave) { printf("Invalid device %d:%d\n", bus, cs); return -EINVAL; } #endif ret = spi_claim_bus(slave); if (ret) goto done; printf("out:\n"); if(bprint_rx) { for (j = 0; j < ((bitlen + 7) / 8); j++) printf("%02X", dout[j]); printf("\n"); } ret = spi_xfer(slave, bitlen, dout, din, SPI_XFER_BEGIN | SPI_XFER_END); #ifndef CONFIG_DM_SPI /* We don't get an error code in this case */ if (ret) ret = -EIO; #endif if (ret) { printf("Error %d during SPI transaction\n", ret); } else { printf("in:\n"); if(bprint_rx) { for (j = 0; j < ((bitlen + 7) / 8); j++) printf("%02X", din[j]); printf("\n"); } } done: spi_release_bus(slave); #ifndef CONFIG_DM_SPI spi_free_slave(slave); #endif return ret; } /* * SPI read/write * * Syntax: * spi {dev} {num_bits} {dout} * {dev} is the device number for controlling chip select (see TBD) * {num_bits} is the number of bits to send & receive (base 10) * {dout} is a hexadecimal string of data to send * The command prints out the hexadecimal string received via SPI. */ int do_spi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *cp = 0; uchar tmp; int j; /* * We use the last specified parameters, unless new ones are * entered. */ if ((flag & CMD_FLAG_REPEAT) == 0) { if (argc >= 2) { mode = CONFIG_DEFAULT_SPI_MODE; bus = simple_strtoul(argv[1], &cp, 10); if (*cp == ':') { cs = simple_strtoul(cp+1, &cp, 10); } else { cs = bus; bus = CONFIG_DEFAULT_SPI_BUS; } if (*cp == '.') mode = simple_strtoul(cp+1, NULL, 10); } if (argc >= 3) bitlen = simple_strtoul(argv[2], NULL, 10); if (argc >= 4) { cp = argv[3]; for(j = 0; *cp; j++, cp++) { tmp = *cp - '0'; if(tmp > 9) tmp -= ('A' - '0') - 10; if(tmp > 15) tmp -= ('a' - 'A'); if(tmp > 15) { printf("Hex conversion error on %c\n", *cp); return 1; } if((j % 2) == 0) dout[j / 2] = (tmp << 4); else dout[j / 2] |= tmp; } } } if ((bitlen < 0) || (bitlen > (MAX_SPI_BYTES * 8))) { printf("Invalid bitlen %d\n", bitlen); return 1; } if (do_spi_xfer(bus, cs,1)) return 1; return 0; } static char ate_cmd_help [] = { "ate_spi speed wr{.b .w .l} addr data \n" "ate_spi speed rd{.b .w .l} addr\n" "{speed} is baud rate of spi, uinit in hz\n" "{ rd{.b .w .l}| wr{.b .w .l} } is the reading or writing reg operation\n" "{addr} is chip reg addr\n" "{data} is the data while opertion is writing\n" }; /* * SPI read/write * * Syntax: * ate_spi {dev} {rd|wr} {b|w|l} {addr} {data} * {dev} is the device number for controlling chip select (see TBD) * {rd|wr} is the reading or writing reg operation * {b|w|l} is the width of reg value * {addr} is chip reg addr * {data} is the data while opertion is writing * The command prints out the hexadecimal string received via SPI. */ int do_ate_spi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { int ret,frame_len; unsigned char cmd = 0; unsigned long long reg_addr = 0; unsigned int reg_value = 0; /* * We use the last specified parameters, unless new ones are * entered. */ if ((flag & CMD_FLAG_REPEAT) == 0) { /* parser argv */ if(argc < 4){ printf("cmd err \n"); printf("%s",ate_cmd_help); } /*get speed */ speed = simple_strtoul(argv[1],NULL,10); if(speed < 1000000) { printf("speed need bigger than 1000000 hz\n"); return -1; } /* * cs = cs0 * mode = mode0 * speed = 1000000(default) * bus = 0 */ ate_spi_config(0,0,0,10000000); /*get cmd code*/ ret = ate_get_cmd_code(argv[2],&cmd); if(ret){ printf("unknow cmd code \n"); printf("%s",ate_cmd_help); return ret; } /* get reg_addr */ reg_addr = simple_strtoull(argv[3],NULL,16); if(ate_is_write_cmd(cmd)){ reg_value = simple_strtoul(argv[4],NULL,16); } } /*build cmd frame */ frame_len = ate_build_cmd_frame(cmd,reg_addr,reg_value); if(frame_len < 0) return -1; bitlen = frame_len<<3; /*send cmd frame and receive result */ if (do_spi_xfer(bus, cs,0)) return 1; /* get rsp */ if(ate_is_write_cmd(cmd)){ unsigned char err_code = 0xde; ret = ate_get_write_rsp(&din[frame_len-2],&err_code); printf("0x%02x\n",err_code); //printf(" frame_len %d ret = %d rsp = %02x\n",frame_len,ret,err_code); }else { unsigned int val = 0; unsigned int reg_len = 0; reg_len = ate_get_reg_width(cmd); ate_get_read_value(&din[frame_len-reg_len-1],reg_len,&val); if(reg_len == 1){ printf("0x%02x \n",val); } if(reg_len == 2){ printf("0x%04x \n",val); } if(reg_len == 4){ printf("0x%08x \n",val); } } return 0; } /***************************************************/ int spi_tst_cfg (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *cp = 0; if(argc != 3){ return -1; } speed = simple_strtoul(argv[1],&cp,10); mode = simple_strtoul(argv[2],&cp,10); return 0; } int spi_tst_xfer (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *cp = 0; uchar tmp; int j; /* * We use the last specified parameters, unless new ones are * entered. */ if ((flag & CMD_FLAG_REPEAT) == 0) { bus = simple_strtoul(argv[1], &cp, 10); cs = simple_strtoul(argv[2], &cp, 10); bitlen = simple_strtoul(argv[3], NULL, 10); cp = argv[4]; for(j = 0; *cp; j++, cp++) { tmp = *cp - '0'; if(tmp > 9) tmp -= ('A' - '0') - 10; if(tmp > 15) tmp -= ('a' - 'A'); if(tmp > 15) { printf("Hex conversion error on %c\n", *cp); return 1; } if((j % 2) == 0) dout[j / 2] = (tmp << 4); else dout[j / 2] |= tmp; } } if ((bitlen < 0) || (bitlen > (MAX_SPI_BYTES * 8))) { printf("Invalid bitlen %d\n", bitlen); return -1; } if (do_spi_xfer(bus, cs,1)) return -1; return 0; } U_BOOT_CMD( sspi, 5, 1, do_spi, "SPI utility command", "[:][.] - Send and receive bits\n" " - Identifies the SPI bus\n" " - Identifies the chip select\n" " - Identifies the SPI mode to use\n" " - Number of bits to send (base 10)\n" " - Hexadecimal string that gets sent" ); U_BOOT_CMD( spi_tst_xfer, 5, 1, spi_tst_xfer, "do spi xfer op", "spi_tst_xfer bus(n) cs(n) bits_len(nbyte*8) data(e.g:aabbccddee...)\n" ); U_BOOT_CMD( spi_tst_cfg, 3, 1, spi_tst_cfg, "config spi speed and mode", "spi_tst_cfg speed(hz) mode(0/1/2/3)\n" ); U_BOOT_CMD( ate_spi, 5, 1, do_ate_spi, "ate_spi test command", ate_cmd_help );