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