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