1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright 2008 Extreme Engineering Solutions, Inc. 4 */ 5 6 /* 7 * Driver for DS4510, a CPU supervisor with integrated EEPROM, SRAM, 8 * and 4 programmable non-volatile GPIO pins. 9 */ 10 11 #include <common.h> 12 #include <i2c.h> 13 #include <command.h> 14 #include "ds4510.h" 15 16 enum { 17 DS4510_CMD_INFO, 18 DS4510_CMD_DEVICE, 19 DS4510_CMD_NV, 20 DS4510_CMD_RSTDELAY, 21 DS4510_CMD_OUTPUT, 22 DS4510_CMD_INPUT, 23 DS4510_CMD_PULLUP, 24 DS4510_CMD_EEPROM, 25 DS4510_CMD_SEEPROM, 26 DS4510_CMD_SRAM, 27 }; 28 29 /* 30 * Write to DS4510, taking page boundaries into account 31 */ 32 static int ds4510_mem_write(uint8_t chip, int offset, uint8_t *buf, int count) 33 { 34 int wrlen; 35 int i = 0; 36 37 do { 38 wrlen = DS4510_EEPROM_PAGE_SIZE - 39 DS4510_EEPROM_PAGE_OFFSET(offset); 40 if (count < wrlen) 41 wrlen = count; 42 if (i2c_write(chip, offset, 1, &buf[i], wrlen)) 43 return -1; 44 45 /* 46 * This delay isn't needed for SRAM writes but shouldn't delay 47 * things too much, so do it unconditionally for simplicity 48 */ 49 udelay(DS4510_EEPROM_PAGE_WRITE_DELAY_MS * 1000); 50 count -= wrlen; 51 offset += wrlen; 52 i += wrlen; 53 } while (count > 0); 54 55 return 0; 56 } 57 58 /* 59 * General read from DS4510 60 */ 61 static int ds4510_mem_read(uint8_t chip, int offset, uint8_t *buf, int count) 62 { 63 return i2c_read(chip, offset, 1, buf, count); 64 } 65 66 /* 67 * Write SEE bit in config register. 68 * nv = 0 - Writes to SEEPROM registers behave like EEPROM 69 * nv = 1 - Writes to SEEPROM registers behave like SRAM 70 */ 71 static int ds4510_see_write(uint8_t chip, uint8_t nv) 72 { 73 uint8_t data; 74 75 if (i2c_read(chip, DS4510_CFG, 1, &data, 1)) 76 return -1; 77 78 if (nv) /* Treat SEEPROM bits as EEPROM */ 79 data &= ~DS4510_CFG_SEE; 80 else /* Treat SEEPROM bits as SRAM */ 81 data |= DS4510_CFG_SEE; 82 83 return ds4510_mem_write(chip, DS4510_CFG, &data, 1); 84 } 85 86 /* 87 * Write de-assertion of reset signal delay 88 */ 89 static int ds4510_rstdelay_write(uint8_t chip, uint8_t delay) 90 { 91 uint8_t data; 92 93 if (i2c_read(chip, DS4510_RSTDELAY, 1, &data, 1)) 94 return -1; 95 96 data &= ~DS4510_RSTDELAY_MASK; 97 data |= delay & DS4510_RSTDELAY_MASK; 98 99 return ds4510_mem_write(chip, DS4510_RSTDELAY, &data, 1); 100 } 101 102 /* 103 * Write pullup characteristics of IO pins 104 */ 105 static int ds4510_pullup_write(uint8_t chip, uint8_t val) 106 { 107 val &= DS4510_IO_MASK; 108 109 return ds4510_mem_write(chip, DS4510_PULLUP, (uint8_t *)&val, 1); 110 } 111 112 /* 113 * Read pullup characteristics of IO pins 114 */ 115 static int ds4510_pullup_read(uint8_t chip) 116 { 117 uint8_t val; 118 119 if (i2c_read(chip, DS4510_PULLUP, 1, &val, 1)) 120 return -1; 121 122 return val & DS4510_IO_MASK; 123 } 124 125 /* 126 * Write drive level of IO pins 127 */ 128 static int ds4510_gpio_write(uint8_t chip, uint8_t val) 129 { 130 uint8_t data; 131 int i; 132 133 for (i = 0; i < DS4510_NUM_IO; i++) { 134 if (i2c_read(chip, DS4510_IO0 - i, 1, &data, 1)) 135 return -1; 136 137 if (val & (0x1 << i)) 138 data |= 0x1; 139 else 140 data &= ~0x1; 141 142 if (ds4510_mem_write(chip, DS4510_IO0 - i, &data, 1)) 143 return -1; 144 } 145 146 return 0; 147 } 148 149 /* 150 * Read drive level of IO pins 151 */ 152 static int ds4510_gpio_read(uint8_t chip) 153 { 154 uint8_t data; 155 int val = 0; 156 int i; 157 158 for (i = 0; i < DS4510_NUM_IO; i++) { 159 if (i2c_read(chip, DS4510_IO0 - i, 1, &data, 1)) 160 return -1; 161 162 if (data & 1) 163 val |= (1 << i); 164 } 165 166 return val; 167 } 168 169 /* 170 * Read physical level of IO pins 171 */ 172 static int ds4510_gpio_read_val(uint8_t chip) 173 { 174 uint8_t val; 175 176 if (i2c_read(chip, DS4510_IO_STATUS, 1, &val, 1)) 177 return -1; 178 179 return val & DS4510_IO_MASK; 180 } 181 182 /* 183 * Display DS4510 information 184 */ 185 static int ds4510_info(uint8_t chip) 186 { 187 int i; 188 int tmp; 189 uint8_t data; 190 191 printf("DS4510 @ 0x%x:\n\n", chip); 192 193 if (i2c_read(chip, DS4510_RSTDELAY, 1, &data, 1)) 194 return -1; 195 printf("rstdelay = 0x%x\n\n", data & DS4510_RSTDELAY_MASK); 196 197 if (i2c_read(chip, DS4510_CFG, 1, &data, 1)) 198 return -1; 199 printf("config = 0x%x\n", data); 200 printf(" /ready = %d\n", data & DS4510_CFG_READY ? 1 : 0); 201 printf(" trip pt = %d\n", data & DS4510_CFG_TRIP_POINT ? 1 : 0); 202 printf(" rst sts = %d\n", data & DS4510_CFG_RESET ? 1 : 0); 203 printf(" /see = %d\n", data & DS4510_CFG_SEE ? 1 : 0); 204 printf(" swrst = %d\n\n", data & DS4510_CFG_SWRST ? 1 : 0); 205 206 printf("gpio pins: 3210\n"); 207 printf("---------------\n"); 208 printf("pullup "); 209 210 tmp = ds4510_pullup_read(chip); 211 if (tmp == -1) 212 return tmp; 213 for (i = DS4510_NUM_IO - 1; i >= 0; i--) 214 printf("%d", (tmp & (1 << i)) ? 1 : 0); 215 printf("\n"); 216 217 printf("driven "); 218 tmp = ds4510_gpio_read(chip); 219 if (tmp == -1) 220 return -1; 221 for (i = DS4510_NUM_IO - 1; i >= 0; i--) 222 printf("%d", (tmp & (1 << i)) ? 1 : 0); 223 printf("\n"); 224 225 printf("read "); 226 tmp = ds4510_gpio_read_val(chip); 227 if (tmp == -1) 228 return -1; 229 for (i = DS4510_NUM_IO - 1; i >= 0; i--) 230 printf("%d", (tmp & (1 << i)) ? 1 : 0); 231 printf("\n"); 232 233 return 0; 234 } 235 236 cmd_tbl_t cmd_ds4510[] = { 237 U_BOOT_CMD_MKENT(device, 3, 0, (void *)DS4510_CMD_DEVICE, "", ""), 238 U_BOOT_CMD_MKENT(nv, 3, 0, (void *)DS4510_CMD_NV, "", ""), 239 U_BOOT_CMD_MKENT(output, 4, 0, (void *)DS4510_CMD_OUTPUT, "", ""), 240 U_BOOT_CMD_MKENT(input, 3, 0, (void *)DS4510_CMD_INPUT, "", ""), 241 U_BOOT_CMD_MKENT(pullup, 4, 0, (void *)DS4510_CMD_PULLUP, "", ""), 242 U_BOOT_CMD_MKENT(info, 2, 0, (void *)DS4510_CMD_INFO, "", ""), 243 U_BOOT_CMD_MKENT(rstdelay, 3, 0, (void *)DS4510_CMD_RSTDELAY, "", ""), 244 U_BOOT_CMD_MKENT(eeprom, 6, 0, (void *)DS4510_CMD_EEPROM, "", ""), 245 U_BOOT_CMD_MKENT(seeprom, 6, 0, (void *)DS4510_CMD_SEEPROM, "", ""), 246 U_BOOT_CMD_MKENT(sram, 6, 0, (void *)DS4510_CMD_SRAM, "", ""), 247 }; 248 249 int do_ds4510(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 250 { 251 static uint8_t chip = 0x51; 252 cmd_tbl_t *c; 253 ulong ul_arg2 = 0; 254 ulong ul_arg3 = 0; 255 int tmp; 256 ulong addr; 257 ulong off; 258 ulong cnt; 259 int end; 260 int (*rw_func)(uint8_t, int, uint8_t *, int); 261 262 c = find_cmd_tbl(argv[1], cmd_ds4510, ARRAY_SIZE(cmd_ds4510)); 263 264 /* All commands but "device" require 'maxargs' arguments */ 265 if (!c || !((argc == (c->maxargs)) || 266 (((int)c->cmd == DS4510_CMD_DEVICE) && 267 (argc == (c->maxargs - 1))))) { 268 return cmd_usage(cmdtp); 269 } 270 271 /* arg2 used as chip addr and pin number */ 272 if (argc > 2) 273 ul_arg2 = simple_strtoul(argv[2], NULL, 16); 274 275 /* arg3 used as output/pullup value */ 276 if (argc > 3) 277 ul_arg3 = simple_strtoul(argv[3], NULL, 16); 278 279 switch ((int)c->cmd) { 280 case DS4510_CMD_DEVICE: 281 if (argc == 3) 282 chip = ul_arg2; 283 printf("Current device address: 0x%x\n", chip); 284 return 0; 285 case DS4510_CMD_NV: 286 return ds4510_see_write(chip, ul_arg2); 287 case DS4510_CMD_OUTPUT: 288 tmp = ds4510_gpio_read(chip); 289 if (tmp == -1) 290 return -1; 291 if (ul_arg3) 292 tmp |= (1 << ul_arg2); 293 else 294 tmp &= ~(1 << ul_arg2); 295 return ds4510_gpio_write(chip, tmp); 296 case DS4510_CMD_INPUT: 297 tmp = ds4510_gpio_read_val(chip); 298 if (tmp == -1) 299 return -1; 300 return (tmp & (1 << ul_arg2)) != 0; 301 case DS4510_CMD_PULLUP: 302 tmp = ds4510_pullup_read(chip); 303 if (tmp == -1) 304 return -1; 305 if (ul_arg3) 306 tmp |= (1 << ul_arg2); 307 else 308 tmp &= ~(1 << ul_arg2); 309 return ds4510_pullup_write(chip, tmp); 310 case DS4510_CMD_INFO: 311 return ds4510_info(chip); 312 case DS4510_CMD_RSTDELAY: 313 return ds4510_rstdelay_write(chip, ul_arg2); 314 case DS4510_CMD_EEPROM: 315 end = DS4510_EEPROM + DS4510_EEPROM_SIZE; 316 off = DS4510_EEPROM; 317 break; 318 case DS4510_CMD_SEEPROM: 319 end = DS4510_SEEPROM + DS4510_SEEPROM_SIZE; 320 off = DS4510_SEEPROM; 321 break; 322 case DS4510_CMD_SRAM: 323 end = DS4510_SRAM + DS4510_SRAM_SIZE; 324 off = DS4510_SRAM; 325 break; 326 default: 327 /* We should never get here... */ 328 return 1; 329 } 330 331 /* Only eeprom, seeprom, and sram commands should make it here */ 332 if (strcmp(argv[2], "read") == 0) 333 rw_func = ds4510_mem_read; 334 else if (strcmp(argv[2], "write") == 0) 335 rw_func = ds4510_mem_write; 336 else 337 return cmd_usage(cmdtp); 338 339 addr = simple_strtoul(argv[3], NULL, 16); 340 off += simple_strtoul(argv[4], NULL, 16); 341 cnt = simple_strtoul(argv[5], NULL, 16); 342 343 if ((off + cnt) > end) { 344 printf("ERROR: invalid len\n"); 345 return -1; 346 } 347 348 return rw_func(chip, off, (uint8_t *)addr, cnt); 349 } 350 351 U_BOOT_CMD( 352 ds4510, 6, 1, do_ds4510, 353 "ds4510 eeprom/seeprom/sram/gpio access", 354 "device [dev]\n" 355 " - show or set current device address\n" 356 "ds4510 info\n" 357 " - display ds4510 info\n" 358 "ds4510 output pin 0|1\n" 359 " - set pin low or high-Z\n" 360 "ds4510 input pin\n" 361 " - read value of pin\n" 362 "ds4510 pullup pin 0|1\n" 363 " - disable/enable pullup on specified pin\n" 364 "ds4510 nv 0|1\n" 365 " - make gpio and seeprom writes volatile/non-volatile" 366 "\n" 367 "ds4510 rstdelay 0-3\n" 368 " - set reset output delay" 369 "\n" 370 "ds4510 eeprom read addr off cnt\n" 371 "ds4510 eeprom write addr off cnt\n" 372 " - read/write 'cnt' bytes at EEPROM offset 'off'\n" 373 "ds4510 seeprom read addr off cnt\n" 374 "ds4510 seeprom write addr off cnt\n" 375 " - read/write 'cnt' bytes at SRAM-shadowed EEPROM offset 'off'\n" 376 "ds4510 sram read addr off cnt\n" 377 "ds4510 sram write addr off cnt\n" 378 " - read/write 'cnt' bytes at SRAM offset 'off'" 379 ); 380