spi: kirkwood: add orion-spi compatible string
[oweals/u-boot.git] / drivers / misc / atsha204a-i2c.c
1 /*
2  * I2C Driver for Atmel ATSHA204 over I2C
3  *
4  * Copyright (C) 2014 Josh Datko, Cryptotronix, jbd@cryptotronix.com
5  *               2016 Tomas Hlavacek, CZ.NIC, tmshlvck@gmail.com
6  *               2017 Marek Behun, CZ.NIC, marek.behun@nic.cz
7  *
8  * This program is free software; you can redistribute  it and/or modify it
9  * under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12
13 #include <common.h>
14 #include <dm.h>
15 #include <i2c.h>
16 #include <errno.h>
17 #include <atsha204a-i2c.h>
18
19 #define ATSHA204A_TWLO                  60
20 #define ATSHA204A_TRANSACTION_TIMEOUT   100000
21 #define ATSHA204A_TRANSACTION_RETRY     5
22 #define ATSHA204A_EXECTIME              5000
23
24 DECLARE_GLOBAL_DATA_PTR;
25
26 /*
27  * The ATSHA204A uses an (to me) unknown CRC-16 algorithm.
28  * The Reveng CRC-16 catalogue does not contain it.
29  *
30  * Because in Atmel's documentation only a primitive implementation
31  * can be found, I have implemented this one with lookup table.
32  */
33
34 /*
35  * This is the code that computes the table below:
36  *
37  * int i, j;
38  * for (i = 0; i < 256; ++i) {
39  *      u8 c = 0;
40  *      for (j = 0; j < 8; ++j) {
41  *              c = (c << 1) | ((i >> j) & 1);
42  *      }
43  *      bitreverse_table[i] = c;
44  * }
45  */
46
47 static u8 const bitreverse_table[256] = {
48         0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
49         0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
50         0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
51         0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
52         0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
53         0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
54         0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
55         0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
56         0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
57         0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
58         0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
59         0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
60         0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
61         0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
62         0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
63         0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
64         0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
65         0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
66         0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
67         0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
68         0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
69         0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
70         0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
71         0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
72         0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
73         0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
74         0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
75         0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
76         0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
77         0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
78         0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
79         0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
80 };
81
82 /*
83  * This is the code that computes the table below:
84  *
85  * int i, j;
86  * for (i = 0; i < 256; ++i) {
87  *      u16 c = i << 8;
88  *      for (j = 0; j < 8; ++j) {
89  *              int b = c >> 15;
90  *              c <<= 1;
91  *              if (b)
92  *                      c ^= 0x8005;
93  *      }
94  *      crc16_table[i] = c;
95  * }
96  */
97 static u16 const crc16_table[256] = {
98         0x0000, 0x8005, 0x800f, 0x000a, 0x801b, 0x001e, 0x0014, 0x8011,
99         0x8033, 0x0036, 0x003c, 0x8039, 0x0028, 0x802d, 0x8027, 0x0022,
100         0x8063, 0x0066, 0x006c, 0x8069, 0x0078, 0x807d, 0x8077, 0x0072,
101         0x0050, 0x8055, 0x805f, 0x005a, 0x804b, 0x004e, 0x0044, 0x8041,
102         0x80c3, 0x00c6, 0x00cc, 0x80c9, 0x00d8, 0x80dd, 0x80d7, 0x00d2,
103         0x00f0, 0x80f5, 0x80ff, 0x00fa, 0x80eb, 0x00ee, 0x00e4, 0x80e1,
104         0x00a0, 0x80a5, 0x80af, 0x00aa, 0x80bb, 0x00be, 0x00b4, 0x80b1,
105         0x8093, 0x0096, 0x009c, 0x8099, 0x0088, 0x808d, 0x8087, 0x0082,
106         0x8183, 0x0186, 0x018c, 0x8189, 0x0198, 0x819d, 0x8197, 0x0192,
107         0x01b0, 0x81b5, 0x81bf, 0x01ba, 0x81ab, 0x01ae, 0x01a4, 0x81a1,
108         0x01e0, 0x81e5, 0x81ef, 0x01ea, 0x81fb, 0x01fe, 0x01f4, 0x81f1,
109         0x81d3, 0x01d6, 0x01dc, 0x81d9, 0x01c8, 0x81cd, 0x81c7, 0x01c2,
110         0x0140, 0x8145, 0x814f, 0x014a, 0x815b, 0x015e, 0x0154, 0x8151,
111         0x8173, 0x0176, 0x017c, 0x8179, 0x0168, 0x816d, 0x8167, 0x0162,
112         0x8123, 0x0126, 0x012c, 0x8129, 0x0138, 0x813d, 0x8137, 0x0132,
113         0x0110, 0x8115, 0x811f, 0x011a, 0x810b, 0x010e, 0x0104, 0x8101,
114         0x8303, 0x0306, 0x030c, 0x8309, 0x0318, 0x831d, 0x8317, 0x0312,
115         0x0330, 0x8335, 0x833f, 0x033a, 0x832b, 0x032e, 0x0324, 0x8321,
116         0x0360, 0x8365, 0x836f, 0x036a, 0x837b, 0x037e, 0x0374, 0x8371,
117         0x8353, 0x0356, 0x035c, 0x8359, 0x0348, 0x834d, 0x8347, 0x0342,
118         0x03c0, 0x83c5, 0x83cf, 0x03ca, 0x83db, 0x03de, 0x03d4, 0x83d1,
119         0x83f3, 0x03f6, 0x03fc, 0x83f9, 0x03e8, 0x83ed, 0x83e7, 0x03e2,
120         0x83a3, 0x03a6, 0x03ac, 0x83a9, 0x03b8, 0x83bd, 0x83b7, 0x03b2,
121         0x0390, 0x8395, 0x839f, 0x039a, 0x838b, 0x038e, 0x0384, 0x8381,
122         0x0280, 0x8285, 0x828f, 0x028a, 0x829b, 0x029e, 0x0294, 0x8291,
123         0x82b3, 0x02b6, 0x02bc, 0x82b9, 0x02a8, 0x82ad, 0x82a7, 0x02a2,
124         0x82e3, 0x02e6, 0x02ec, 0x82e9, 0x02f8, 0x82fd, 0x82f7, 0x02f2,
125         0x02d0, 0x82d5, 0x82df, 0x02da, 0x82cb, 0x02ce, 0x02c4, 0x82c1,
126         0x8243, 0x0246, 0x024c, 0x8249, 0x0258, 0x825d, 0x8257, 0x0252,
127         0x0270, 0x8275, 0x827f, 0x027a, 0x826b, 0x026e, 0x0264, 0x8261,
128         0x0220, 0x8225, 0x822f, 0x022a, 0x823b, 0x023e, 0x0234, 0x8231,
129         0x8213, 0x0216, 0x021c, 0x8219, 0x0208, 0x820d, 0x8207, 0x0202,
130 };
131
132 static inline u16 crc16_byte(u16 crc, const u8 data)
133 {
134         u16 t = crc16_table[((crc >> 8) ^ bitreverse_table[data]) & 0xff];
135         return ((crc << 8) ^ t);
136 }
137
138 static u16 atsha204a_crc16(const u8 *buffer, size_t len)
139 {
140         u16 crc = 0;
141
142         while (len--)
143                 crc = crc16_byte(crc, *buffer++);
144
145         return cpu_to_le16(crc);
146 }
147
148 static int atsha204a_send(struct udevice *dev, const u8 *buf, u8 len)
149 {
150         fdt_addr_t *priv = dev_get_priv(dev);
151         struct i2c_msg msg;
152
153         msg.addr = *priv;
154         msg.flags = I2C_M_STOP;
155         msg.len = len;
156         msg.buf = (u8 *) buf;
157
158         return dm_i2c_xfer(dev, &msg, 1);
159 }
160
161 static int atsha204a_recv(struct udevice *dev, u8 *buf, u8 len)
162 {
163         fdt_addr_t *priv = dev_get_priv(dev);
164         struct i2c_msg msg;
165
166         msg.addr = *priv;
167         msg.flags = I2C_M_RD | I2C_M_STOP;
168         msg.len = len;
169         msg.buf = (u8 *) buf;
170
171         return dm_i2c_xfer(dev, &msg, 1);
172 }
173
174 static int atsha204a_recv_resp(struct udevice *dev,
175                                struct atsha204a_resp *resp)
176 {
177         int res;
178         u16 resp_crc, computed_crc;
179         u8 *p = (u8 *) resp;
180
181         res = atsha204a_recv(dev, p, 4);
182         if (res)
183                 return res;
184
185         if (resp->length > 4) {
186                 if (resp->length > sizeof(*resp))
187                         return -EMSGSIZE;
188
189                 res = atsha204a_recv(dev, p + 4, resp->length - 4);
190                 if (res)
191                         return res;
192         }
193
194         resp_crc = (u16) p[resp->length - 2]
195                    | (((u16) p[resp->length - 1]) << 8);
196         computed_crc = atsha204a_crc16(p, resp->length - 2);
197
198         if (resp_crc != computed_crc) {
199                 debug("Invalid checksum in ATSHA204A response\n");
200                 return -EBADMSG;
201         }
202
203         return 0;
204 }
205
206 int atsha204a_wakeup(struct udevice *dev)
207 {
208         u8 req[4];
209         struct atsha204a_resp resp;
210         int try, res;
211
212         debug("Waking up ATSHA204A\n");
213
214         for (try = 1; try <= 10; ++try) {
215                 debug("Try %i... ", try);
216
217                 memset(req, 0, 4);
218                 res = atsha204a_send(dev, req, 4);
219                 if (res) {
220                         debug("failed on I2C send, trying again\n");
221                         continue;
222                 }
223
224                 udelay(ATSHA204A_TWLO);
225
226                 res = atsha204a_recv_resp(dev, &resp);
227                 if (res) {
228                         debug("failed on receiving response, ending\n");
229                         return res;
230                 }
231
232                 if (resp.code != ATSHA204A_STATUS_AFTER_WAKE) {
233                         debug ("failed (responce code = %02x), ending\n",
234                                resp.code);
235                         return -EBADMSG;
236                 }
237
238                 debug("success\n");
239                 break;
240         }
241
242         return 0;
243 }
244
245 int atsha204a_idle(struct udevice *dev)
246 {
247         int res;
248         u8 req = ATSHA204A_FUNC_IDLE;
249
250         res = atsha204a_send(dev, &req, 1);
251         if (res)
252                 debug("Failed putting ATSHA204A idle\n");
253         return res;
254 }
255
256 int atsha204a_sleep(struct udevice *dev)
257 {
258         int res;
259         u8 req = ATSHA204A_FUNC_IDLE;
260
261         res = atsha204a_send(dev, &req, 1);
262         if (res)
263                 debug("Failed putting ATSHA204A to sleep\n");
264         return res;
265 }
266
267 static int atsha204a_transaction(struct udevice *dev, struct atsha204a_req *req,
268                                 struct atsha204a_resp *resp)
269 {
270         int res, timeout = ATSHA204A_TRANSACTION_TIMEOUT;
271
272         res = atsha204a_send(dev, (u8 *) req, req->length + 1);
273         if (res) {
274                 debug("ATSHA204A transaction send failed\n");
275                 return -EBUSY;
276         }
277
278         do {
279                 res = atsha204a_recv_resp(dev, resp);
280                 if (!res || res == -EMSGSIZE || res == -EBADMSG)
281                         break;
282
283                 debug("ATSHA204A transaction polling for response "
284                       "(timeout = %d)\n", timeout);
285
286                 udelay(ATSHA204A_EXECTIME);
287                 timeout -= ATSHA204A_EXECTIME;
288         } while (timeout > 0);
289
290         if (timeout <= 0) {
291                 debug("ATSHA204A transaction timed out\n");
292                 return -ETIMEDOUT;
293         }
294
295         return res;
296 }
297
298 static void atsha204a_req_crc32(struct atsha204a_req *req)
299 {
300         u8 *p = (u8 *) req;
301         u16 computed_crc;
302         u16 *crc_ptr = (u16 *) &p[req->length - 1];
303
304         /* The buffer to crc16 starts at byte 1, not 0 */
305         computed_crc = atsha204a_crc16(p + 1, req->length - 2);
306
307         *crc_ptr = cpu_to_le16(computed_crc);
308 }
309
310 int atsha204a_read(struct udevice *dev, enum atsha204a_zone zone, bool read32,
311                   u16 addr, u8 *buffer)
312 {
313         int res, retry = ATSHA204A_TRANSACTION_RETRY;
314         struct atsha204a_req req;
315         struct atsha204a_resp resp;
316
317         req.function = ATSHA204A_FUNC_COMMAND;
318         req.length = 7;
319         req.command = ATSHA204A_CMD_READ;
320
321         req.param1 = (u8) zone;
322         if (read32)
323                 req.param1 |= 0x80;
324
325         req.param2 = cpu_to_le16(addr);
326
327         atsha204a_req_crc32(&req);
328
329         do {
330                 res = atsha204a_transaction(dev, &req, &resp);
331                 if (!res)
332                         break;
333
334                 debug("ATSHA204A read retry (%d)\n", retry);
335                 retry--;
336                 atsha204a_wakeup(dev);
337         } while (retry >= 0);
338         
339         if (res) {
340                 debug("ATSHA204A read failed\n");
341                 return res;
342         }
343
344         if (resp.length != (read32 ? 32 : 4) + 3) {
345                 debug("ATSHA204A read bad response length (%d)\n",
346                       resp.length);
347                 return -EBADMSG;
348         }
349
350         memcpy(buffer, ((u8 *) &resp) + 1, read32 ? 32 : 4);
351
352         return 0;
353 }
354
355 int atsha204a_get_random(struct udevice *dev, u8 *buffer, size_t max)
356 {
357         int res;
358         struct atsha204a_req req;
359         struct atsha204a_resp resp;
360
361         req.function = ATSHA204A_FUNC_COMMAND;
362         req.length = 7;
363         req.command = ATSHA204A_CMD_RANDOM;
364
365         req.param1 = 1;
366         req.param2 = 0;
367
368         /* We do not have to compute the checksum dynamically */
369         req.data[0] = 0x27;
370         req.data[1] = 0x47;
371
372         res = atsha204a_transaction(dev, &req, &resp);
373         if (res) {
374                 debug("ATSHA204A random transaction failed\n");
375                 return res;
376         }
377
378         memcpy(buffer, ((u8 *) &resp) + 1, max >= 32 ? 32 : max);
379         return 0;
380 }
381
382 static int atsha204a_ofdata_to_platdata(struct udevice *dev)
383 {
384         fdt_addr_t *priv = dev_get_priv(dev);
385         fdt_addr_t addr;
386
387         addr = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev), "reg");
388         if (addr == FDT_ADDR_T_NONE) {
389                 debug("Can't get ATSHA204A I2C base address\n");
390                 return -ENXIO;
391         }
392
393         *priv = addr;
394         return 0;
395 }
396
397 static const struct udevice_id atsha204a_ids[] = {
398         { .compatible = "atmel,atsha204a" },
399         { }
400 };
401
402 U_BOOT_DRIVER(atsha204) = {
403         .name                   = "atsha204",
404         .id                     = UCLASS_MISC,
405         .of_match               = atsha204a_ids,
406         .ofdata_to_platdata     = atsha204a_ofdata_to_platdata,
407         .priv_auto_alloc_size   = sizeof(fdt_addr_t),
408 };