gpio: tqmx86: really make IRQ optional
[linux-2.6-microblaze.git] / drivers / spi / spi-dln2.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Driver for the Diolan DLN-2 USB-SPI adapter
4  *
5  * Copyright (c) 2014 Intel Corporation
6  */
7
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/platform_device.h>
11 #include <linux/mfd/dln2.h>
12 #include <linux/spi/spi.h>
13 #include <linux/pm_runtime.h>
14 #include <asm/unaligned.h>
15
16 #define DLN2_SPI_MODULE_ID              0x02
17 #define DLN2_SPI_CMD(cmd)               DLN2_CMD(cmd, DLN2_SPI_MODULE_ID)
18
19 /* SPI commands */
20 #define DLN2_SPI_GET_PORT_COUNT                 DLN2_SPI_CMD(0x00)
21 #define DLN2_SPI_ENABLE                         DLN2_SPI_CMD(0x11)
22 #define DLN2_SPI_DISABLE                        DLN2_SPI_CMD(0x12)
23 #define DLN2_SPI_IS_ENABLED                     DLN2_SPI_CMD(0x13)
24 #define DLN2_SPI_SET_MODE                       DLN2_SPI_CMD(0x14)
25 #define DLN2_SPI_GET_MODE                       DLN2_SPI_CMD(0x15)
26 #define DLN2_SPI_SET_FRAME_SIZE                 DLN2_SPI_CMD(0x16)
27 #define DLN2_SPI_GET_FRAME_SIZE                 DLN2_SPI_CMD(0x17)
28 #define DLN2_SPI_SET_FREQUENCY                  DLN2_SPI_CMD(0x18)
29 #define DLN2_SPI_GET_FREQUENCY                  DLN2_SPI_CMD(0x19)
30 #define DLN2_SPI_READ_WRITE                     DLN2_SPI_CMD(0x1A)
31 #define DLN2_SPI_READ                           DLN2_SPI_CMD(0x1B)
32 #define DLN2_SPI_WRITE                          DLN2_SPI_CMD(0x1C)
33 #define DLN2_SPI_SET_DELAY_BETWEEN_SS           DLN2_SPI_CMD(0x20)
34 #define DLN2_SPI_GET_DELAY_BETWEEN_SS           DLN2_SPI_CMD(0x21)
35 #define DLN2_SPI_SET_DELAY_AFTER_SS             DLN2_SPI_CMD(0x22)
36 #define DLN2_SPI_GET_DELAY_AFTER_SS             DLN2_SPI_CMD(0x23)
37 #define DLN2_SPI_SET_DELAY_BETWEEN_FRAMES       DLN2_SPI_CMD(0x24)
38 #define DLN2_SPI_GET_DELAY_BETWEEN_FRAMES       DLN2_SPI_CMD(0x25)
39 #define DLN2_SPI_SET_SS                         DLN2_SPI_CMD(0x26)
40 #define DLN2_SPI_GET_SS                         DLN2_SPI_CMD(0x27)
41 #define DLN2_SPI_RELEASE_SS                     DLN2_SPI_CMD(0x28)
42 #define DLN2_SPI_SS_VARIABLE_ENABLE             DLN2_SPI_CMD(0x2B)
43 #define DLN2_SPI_SS_VARIABLE_DISABLE            DLN2_SPI_CMD(0x2C)
44 #define DLN2_SPI_SS_VARIABLE_IS_ENABLED         DLN2_SPI_CMD(0x2D)
45 #define DLN2_SPI_SS_AAT_ENABLE                  DLN2_SPI_CMD(0x2E)
46 #define DLN2_SPI_SS_AAT_DISABLE                 DLN2_SPI_CMD(0x2F)
47 #define DLN2_SPI_SS_AAT_IS_ENABLED              DLN2_SPI_CMD(0x30)
48 #define DLN2_SPI_SS_BETWEEN_FRAMES_ENABLE       DLN2_SPI_CMD(0x31)
49 #define DLN2_SPI_SS_BETWEEN_FRAMES_DISABLE      DLN2_SPI_CMD(0x32)
50 #define DLN2_SPI_SS_BETWEEN_FRAMES_IS_ENABLED   DLN2_SPI_CMD(0x33)
51 #define DLN2_SPI_SET_CPHA                       DLN2_SPI_CMD(0x34)
52 #define DLN2_SPI_GET_CPHA                       DLN2_SPI_CMD(0x35)
53 #define DLN2_SPI_SET_CPOL                       DLN2_SPI_CMD(0x36)
54 #define DLN2_SPI_GET_CPOL                       DLN2_SPI_CMD(0x37)
55 #define DLN2_SPI_SS_MULTI_ENABLE                DLN2_SPI_CMD(0x38)
56 #define DLN2_SPI_SS_MULTI_DISABLE               DLN2_SPI_CMD(0x39)
57 #define DLN2_SPI_SS_MULTI_IS_ENABLED            DLN2_SPI_CMD(0x3A)
58 #define DLN2_SPI_GET_SUPPORTED_MODES            DLN2_SPI_CMD(0x40)
59 #define DLN2_SPI_GET_SUPPORTED_CPHA_VALUES      DLN2_SPI_CMD(0x41)
60 #define DLN2_SPI_GET_SUPPORTED_CPOL_VALUES      DLN2_SPI_CMD(0x42)
61 #define DLN2_SPI_GET_SUPPORTED_FRAME_SIZES      DLN2_SPI_CMD(0x43)
62 #define DLN2_SPI_GET_SS_COUNT                   DLN2_SPI_CMD(0x44)
63 #define DLN2_SPI_GET_MIN_FREQUENCY              DLN2_SPI_CMD(0x45)
64 #define DLN2_SPI_GET_MAX_FREQUENCY              DLN2_SPI_CMD(0x46)
65 #define DLN2_SPI_GET_MIN_DELAY_BETWEEN_SS       DLN2_SPI_CMD(0x47)
66 #define DLN2_SPI_GET_MAX_DELAY_BETWEEN_SS       DLN2_SPI_CMD(0x48)
67 #define DLN2_SPI_GET_MIN_DELAY_AFTER_SS         DLN2_SPI_CMD(0x49)
68 #define DLN2_SPI_GET_MAX_DELAY_AFTER_SS         DLN2_SPI_CMD(0x4A)
69 #define DLN2_SPI_GET_MIN_DELAY_BETWEEN_FRAMES   DLN2_SPI_CMD(0x4B)
70 #define DLN2_SPI_GET_MAX_DELAY_BETWEEN_FRAMES   DLN2_SPI_CMD(0x4C)
71
72 #define DLN2_SPI_MAX_XFER_SIZE                  256
73 #define DLN2_SPI_BUF_SIZE                       (DLN2_SPI_MAX_XFER_SIZE + 16)
74 #define DLN2_SPI_ATTR_LEAVE_SS_LOW              BIT(0)
75 #define DLN2_TRANSFERS_WAIT_COMPLETE            1
76 #define DLN2_TRANSFERS_CANCEL                   0
77 #define DLN2_RPM_AUTOSUSPEND_TIMEOUT            2000
78
79 struct dln2_spi {
80         struct platform_device *pdev;
81         struct spi_master *master;
82         u8 port;
83
84         /*
85          * This buffer will be used mainly for read/write operations. Since
86          * they're quite large, we cannot use the stack. Protection is not
87          * needed because all SPI communication is serialized by the SPI core.
88          */
89         void *buf;
90
91         u8 bpw;
92         u32 speed;
93         u16 mode;
94         u8 cs;
95 };
96
97 /*
98  * Enable/Disable SPI module. The disable command will wait for transfers to
99  * complete first.
100  */
101 static int dln2_spi_enable(struct dln2_spi *dln2, bool enable)
102 {
103         u16 cmd;
104         struct {
105                 u8 port;
106                 u8 wait_for_completion;
107         } tx;
108         unsigned len = sizeof(tx);
109
110         tx.port = dln2->port;
111
112         if (enable) {
113                 cmd = DLN2_SPI_ENABLE;
114                 len -= sizeof(tx.wait_for_completion);
115         } else {
116                 tx.wait_for_completion = DLN2_TRANSFERS_WAIT_COMPLETE;
117                 cmd = DLN2_SPI_DISABLE;
118         }
119
120         return dln2_transfer_tx(dln2->pdev, cmd, &tx, len);
121 }
122
123 /*
124  * Select/unselect multiple CS lines. The selected lines will be automatically
125  * toggled LOW/HIGH by the board firmware during transfers, provided they're
126  * enabled first.
127  *
128  * Ex: cs_mask = 0x03 -> CS0 & CS1 will be selected and the next WR/RD operation
129  *                       will toggle the lines LOW/HIGH automatically.
130  */
131 static int dln2_spi_cs_set(struct dln2_spi *dln2, u8 cs_mask)
132 {
133         struct {
134                 u8 port;
135                 u8 cs;
136         } tx;
137
138         tx.port = dln2->port;
139
140         /*
141          * According to Diolan docs, "a slave device can be selected by changing
142          * the corresponding bit value to 0". The rest must be set to 1. Hence
143          * the bitwise NOT in front.
144          */
145         tx.cs = ~cs_mask;
146
147         return dln2_transfer_tx(dln2->pdev, DLN2_SPI_SET_SS, &tx, sizeof(tx));
148 }
149
150 /*
151  * Select one CS line. The other lines will be un-selected.
152  */
153 static int dln2_spi_cs_set_one(struct dln2_spi *dln2, u8 cs)
154 {
155         return dln2_spi_cs_set(dln2, BIT(cs));
156 }
157
158 /*
159  * Enable/disable CS lines for usage. The module has to be disabled first.
160  */
161 static int dln2_spi_cs_enable(struct dln2_spi *dln2, u8 cs_mask, bool enable)
162 {
163         struct {
164                 u8 port;
165                 u8 cs;
166         } tx;
167         u16 cmd;
168
169         tx.port = dln2->port;
170         tx.cs = cs_mask;
171         cmd = enable ? DLN2_SPI_SS_MULTI_ENABLE : DLN2_SPI_SS_MULTI_DISABLE;
172
173         return dln2_transfer_tx(dln2->pdev, cmd, &tx, sizeof(tx));
174 }
175
176 static int dln2_spi_cs_enable_all(struct dln2_spi *dln2, bool enable)
177 {
178         u8 cs_mask = GENMASK(dln2->master->num_chipselect - 1, 0);
179
180         return dln2_spi_cs_enable(dln2, cs_mask, enable);
181 }
182
183 static int dln2_spi_get_cs_num(struct dln2_spi *dln2, u16 *cs_num)
184 {
185         int ret;
186         struct {
187                 u8 port;
188         } tx;
189         struct {
190                 __le16 cs_count;
191         } rx;
192         unsigned rx_len = sizeof(rx);
193
194         tx.port = dln2->port;
195         ret = dln2_transfer(dln2->pdev, DLN2_SPI_GET_SS_COUNT, &tx, sizeof(tx),
196                             &rx, &rx_len);
197         if (ret < 0)
198                 return ret;
199         if (rx_len < sizeof(rx))
200                 return -EPROTO;
201
202         *cs_num = le16_to_cpu(rx.cs_count);
203
204         dev_dbg(&dln2->pdev->dev, "cs_num = %d\n", *cs_num);
205
206         return 0;
207 }
208
209 static int dln2_spi_get_speed(struct dln2_spi *dln2, u16 cmd, u32 *freq)
210 {
211         int ret;
212         struct {
213                 u8 port;
214         } tx;
215         struct {
216                 __le32 speed;
217         } rx;
218         unsigned rx_len = sizeof(rx);
219
220         tx.port = dln2->port;
221
222         ret = dln2_transfer(dln2->pdev, cmd, &tx, sizeof(tx), &rx, &rx_len);
223         if (ret < 0)
224                 return ret;
225         if (rx_len < sizeof(rx))
226                 return -EPROTO;
227
228         *freq = le32_to_cpu(rx.speed);
229
230         return 0;
231 }
232
233 /*
234  * Get bus min/max frequencies.
235  */
236 static int dln2_spi_get_speed_range(struct dln2_spi *dln2, u32 *fmin, u32 *fmax)
237 {
238         int ret;
239
240         ret = dln2_spi_get_speed(dln2, DLN2_SPI_GET_MIN_FREQUENCY, fmin);
241         if (ret < 0)
242                 return ret;
243
244         ret = dln2_spi_get_speed(dln2, DLN2_SPI_GET_MAX_FREQUENCY, fmax);
245         if (ret < 0)
246                 return ret;
247
248         dev_dbg(&dln2->pdev->dev, "freq_min = %d, freq_max = %d\n",
249                 *fmin, *fmax);
250
251         return 0;
252 }
253
254 /*
255  * Set the bus speed. The module will automatically round down to the closest
256  * available frequency and returns it. The module has to be disabled first.
257  */
258 static int dln2_spi_set_speed(struct dln2_spi *dln2, u32 speed)
259 {
260         int ret;
261         struct {
262                 u8 port;
263                 __le32 speed;
264         } __packed tx;
265         struct {
266                 __le32 speed;
267         } rx;
268         int rx_len = sizeof(rx);
269
270         tx.port = dln2->port;
271         tx.speed = cpu_to_le32(speed);
272
273         ret = dln2_transfer(dln2->pdev, DLN2_SPI_SET_FREQUENCY, &tx, sizeof(tx),
274                             &rx, &rx_len);
275         if (ret < 0)
276                 return ret;
277         if (rx_len < sizeof(rx))
278                 return -EPROTO;
279
280         return 0;
281 }
282
283 /*
284  * Change CPOL & CPHA. The module has to be disabled first.
285  */
286 static int dln2_spi_set_mode(struct dln2_spi *dln2, u8 mode)
287 {
288         struct {
289                 u8 port;
290                 u8 mode;
291         } tx;
292
293         tx.port = dln2->port;
294         tx.mode = mode;
295
296         return dln2_transfer_tx(dln2->pdev, DLN2_SPI_SET_MODE, &tx, sizeof(tx));
297 }
298
299 /*
300  * Change frame size. The module has to be disabled first.
301  */
302 static int dln2_spi_set_bpw(struct dln2_spi *dln2, u8 bpw)
303 {
304         struct {
305                 u8 port;
306                 u8 bpw;
307         } tx;
308
309         tx.port = dln2->port;
310         tx.bpw = bpw;
311
312         return dln2_transfer_tx(dln2->pdev, DLN2_SPI_SET_FRAME_SIZE,
313                                 &tx, sizeof(tx));
314 }
315
316 static int dln2_spi_get_supported_frame_sizes(struct dln2_spi *dln2,
317                                               u32 *bpw_mask)
318 {
319         int ret;
320         struct {
321                 u8 port;
322         } tx;
323         struct {
324                 u8 count;
325                 u8 frame_sizes[36];
326         } *rx = dln2->buf;
327         unsigned rx_len = sizeof(*rx);
328         int i;
329
330         tx.port = dln2->port;
331
332         ret = dln2_transfer(dln2->pdev, DLN2_SPI_GET_SUPPORTED_FRAME_SIZES,
333                             &tx, sizeof(tx), rx, &rx_len);
334         if (ret < 0)
335                 return ret;
336         if (rx_len < sizeof(*rx))
337                 return -EPROTO;
338         if (rx->count > ARRAY_SIZE(rx->frame_sizes))
339                 return -EPROTO;
340
341         *bpw_mask = 0;
342         for (i = 0; i < rx->count; i++)
343                 *bpw_mask |= BIT(rx->frame_sizes[i] - 1);
344
345         dev_dbg(&dln2->pdev->dev, "bpw_mask = 0x%X\n", *bpw_mask);
346
347         return 0;
348 }
349
350 /*
351  * Copy the data to DLN2 buffer and change the byte order to LE, requested by
352  * DLN2 module. SPI core makes sure that the data length is a multiple of word
353  * size.
354  */
355 static int dln2_spi_copy_to_buf(u8 *dln2_buf, const u8 *src, u16 len, u8 bpw)
356 {
357 #ifdef __LITTLE_ENDIAN
358         memcpy(dln2_buf, src, len);
359 #else
360         if (bpw <= 8) {
361                 memcpy(dln2_buf, src, len);
362         } else if (bpw <= 16) {
363                 __le16 *d = (__le16 *)dln2_buf;
364                 u16 *s = (u16 *)src;
365
366                 len = len / 2;
367                 while (len--)
368                         *d++ = cpu_to_le16p(s++);
369         } else {
370                 __le32 *d = (__le32 *)dln2_buf;
371                 u32 *s = (u32 *)src;
372
373                 len = len / 4;
374                 while (len--)
375                         *d++ = cpu_to_le32p(s++);
376         }
377 #endif
378
379         return 0;
380 }
381
382 /*
383  * Copy the data from DLN2 buffer and convert to CPU byte order since the DLN2
384  * buffer is LE ordered. SPI core makes sure that the data length is a multiple
385  * of word size. The RX dln2_buf is 2 byte aligned so, for BE, we have to make
386  * sure we avoid unaligned accesses for 32 bit case.
387  */
388 static int dln2_spi_copy_from_buf(u8 *dest, const u8 *dln2_buf, u16 len, u8 bpw)
389 {
390 #ifdef __LITTLE_ENDIAN
391         memcpy(dest, dln2_buf, len);
392 #else
393         if (bpw <= 8) {
394                 memcpy(dest, dln2_buf, len);
395         } else if (bpw <= 16) {
396                 u16 *d = (u16 *)dest;
397                 __le16 *s = (__le16 *)dln2_buf;
398
399                 len = len / 2;
400                 while (len--)
401                         *d++ = le16_to_cpup(s++);
402         } else {
403                 u32 *d = (u32 *)dest;
404                 __le32 *s = (__le32 *)dln2_buf;
405
406                 len = len / 4;
407                 while (len--)
408                         *d++ = get_unaligned_le32(s++);
409         }
410 #endif
411
412         return 0;
413 }
414
415 /*
416  * Perform one write operation.
417  */
418 static int dln2_spi_write_one(struct dln2_spi *dln2, const u8 *data,
419                               u16 data_len, u8 attr)
420 {
421         struct {
422                 u8 port;
423                 __le16 size;
424                 u8 attr;
425                 u8 buf[DLN2_SPI_MAX_XFER_SIZE];
426         } __packed *tx = dln2->buf;
427         unsigned tx_len;
428
429         BUILD_BUG_ON(sizeof(*tx) > DLN2_SPI_BUF_SIZE);
430
431         if (data_len > DLN2_SPI_MAX_XFER_SIZE)
432                 return -EINVAL;
433
434         tx->port = dln2->port;
435         tx->size = cpu_to_le16(data_len);
436         tx->attr = attr;
437
438         dln2_spi_copy_to_buf(tx->buf, data, data_len, dln2->bpw);
439
440         tx_len = sizeof(*tx) + data_len - DLN2_SPI_MAX_XFER_SIZE;
441         return dln2_transfer_tx(dln2->pdev, DLN2_SPI_WRITE, tx, tx_len);
442 }
443
444 /*
445  * Perform one read operation.
446  */
447 static int dln2_spi_read_one(struct dln2_spi *dln2, u8 *data,
448                              u16 data_len, u8 attr)
449 {
450         int ret;
451         struct {
452                 u8 port;
453                 __le16 size;
454                 u8 attr;
455         } __packed tx;
456         struct {
457                 __le16 size;
458                 u8 buf[DLN2_SPI_MAX_XFER_SIZE];
459         } __packed *rx = dln2->buf;
460         unsigned rx_len = sizeof(*rx);
461
462         BUILD_BUG_ON(sizeof(*rx) > DLN2_SPI_BUF_SIZE);
463
464         if (data_len > DLN2_SPI_MAX_XFER_SIZE)
465                 return -EINVAL;
466
467         tx.port = dln2->port;
468         tx.size = cpu_to_le16(data_len);
469         tx.attr = attr;
470
471         ret = dln2_transfer(dln2->pdev, DLN2_SPI_READ, &tx, sizeof(tx),
472                             rx, &rx_len);
473         if (ret < 0)
474                 return ret;
475         if (rx_len < sizeof(rx->size) + data_len)
476                 return -EPROTO;
477         if (le16_to_cpu(rx->size) != data_len)
478                 return -EPROTO;
479
480         dln2_spi_copy_from_buf(data, rx->buf, data_len, dln2->bpw);
481
482         return 0;
483 }
484
485 /*
486  * Perform one write & read operation.
487  */
488 static int dln2_spi_read_write_one(struct dln2_spi *dln2, const u8 *tx_data,
489                                    u8 *rx_data, u16 data_len, u8 attr)
490 {
491         int ret;
492         struct {
493                 u8 port;
494                 __le16 size;
495                 u8 attr;
496                 u8 buf[DLN2_SPI_MAX_XFER_SIZE];
497         } __packed *tx;
498         struct {
499                 __le16 size;
500                 u8 buf[DLN2_SPI_MAX_XFER_SIZE];
501         } __packed *rx;
502         unsigned tx_len, rx_len;
503
504         BUILD_BUG_ON(sizeof(*tx) > DLN2_SPI_BUF_SIZE ||
505                      sizeof(*rx) > DLN2_SPI_BUF_SIZE);
506
507         if (data_len > DLN2_SPI_MAX_XFER_SIZE)
508                 return -EINVAL;
509
510         /*
511          * Since this is a pseudo full-duplex communication, we're perfectly
512          * safe to use the same buffer for both tx and rx. When DLN2 sends the
513          * response back, with the rx data, we don't need the tx buffer anymore.
514          */
515         tx = dln2->buf;
516         rx = dln2->buf;
517
518         tx->port = dln2->port;
519         tx->size = cpu_to_le16(data_len);
520         tx->attr = attr;
521
522         dln2_spi_copy_to_buf(tx->buf, tx_data, data_len, dln2->bpw);
523
524         tx_len = sizeof(*tx) + data_len - DLN2_SPI_MAX_XFER_SIZE;
525         rx_len = sizeof(*rx);
526
527         ret = dln2_transfer(dln2->pdev, DLN2_SPI_READ_WRITE, tx, tx_len,
528                             rx, &rx_len);
529         if (ret < 0)
530                 return ret;
531         if (rx_len < sizeof(rx->size) + data_len)
532                 return -EPROTO;
533         if (le16_to_cpu(rx->size) != data_len)
534                 return -EPROTO;
535
536         dln2_spi_copy_from_buf(rx_data, rx->buf, data_len, dln2->bpw);
537
538         return 0;
539 }
540
541 /*
542  * Read/Write wrapper. It will automatically split an operation into multiple
543  * single ones due to device buffer constraints.
544  */
545 static int dln2_spi_rdwr(struct dln2_spi *dln2, const u8 *tx_data,
546                          u8 *rx_data, u16 data_len, u8 attr)
547 {
548         int ret;
549         u16 len;
550         u8 temp_attr;
551         u16 remaining = data_len;
552         u16 offset;
553
554         do {
555                 if (remaining > DLN2_SPI_MAX_XFER_SIZE) {
556                         len = DLN2_SPI_MAX_XFER_SIZE;
557                         temp_attr = DLN2_SPI_ATTR_LEAVE_SS_LOW;
558                 } else {
559                         len = remaining;
560                         temp_attr = attr;
561                 }
562
563                 offset = data_len - remaining;
564
565                 if (tx_data && rx_data) {
566                         ret = dln2_spi_read_write_one(dln2,
567                                                       tx_data + offset,
568                                                       rx_data + offset,
569                                                       len, temp_attr);
570                 } else if (tx_data) {
571                         ret = dln2_spi_write_one(dln2,
572                                                  tx_data + offset,
573                                                  len, temp_attr);
574                 } else if (rx_data) {
575                         ret = dln2_spi_read_one(dln2,
576                                                 rx_data + offset,
577                                                 len, temp_attr);
578                  } else {
579                         return -EINVAL;
580                  }
581
582                 if (ret < 0)
583                         return ret;
584
585                 remaining -= len;
586         } while (remaining);
587
588         return 0;
589 }
590
591 static int dln2_spi_prepare_message(struct spi_master *master,
592                                     struct spi_message *message)
593 {
594         int ret;
595         struct dln2_spi *dln2 = spi_master_get_devdata(master);
596         struct spi_device *spi = message->spi;
597
598         if (dln2->cs != spi->chip_select) {
599                 ret = dln2_spi_cs_set_one(dln2, spi->chip_select);
600                 if (ret < 0)
601                         return ret;
602
603                 dln2->cs = spi->chip_select;
604         }
605
606         return 0;
607 }
608
609 static int dln2_spi_transfer_setup(struct dln2_spi *dln2, u32 speed,
610                                    u8 bpw, u8 mode)
611 {
612         int ret;
613         bool bus_setup_change;
614
615         bus_setup_change = dln2->speed != speed || dln2->mode != mode ||
616                            dln2->bpw != bpw;
617
618         if (!bus_setup_change)
619                 return 0;
620
621         ret = dln2_spi_enable(dln2, false);
622         if (ret < 0)
623                 return ret;
624
625         if (dln2->speed != speed) {
626                 ret = dln2_spi_set_speed(dln2, speed);
627                 if (ret < 0)
628                         return ret;
629
630                 dln2->speed = speed;
631         }
632
633         if (dln2->mode != mode) {
634                 ret = dln2_spi_set_mode(dln2, mode & 0x3);
635                 if (ret < 0)
636                         return ret;
637
638                 dln2->mode = mode;
639         }
640
641         if (dln2->bpw != bpw) {
642                 ret = dln2_spi_set_bpw(dln2, bpw);
643                 if (ret < 0)
644                         return ret;
645
646                 dln2->bpw = bpw;
647         }
648
649         return dln2_spi_enable(dln2, true);
650 }
651
652 static int dln2_spi_transfer_one(struct spi_master *master,
653                                  struct spi_device *spi,
654                                  struct spi_transfer *xfer)
655 {
656         struct dln2_spi *dln2 = spi_master_get_devdata(master);
657         int status;
658         u8 attr = 0;
659
660         status = dln2_spi_transfer_setup(dln2, xfer->speed_hz,
661                                          xfer->bits_per_word,
662                                          spi->mode);
663         if (status < 0) {
664                 dev_err(&dln2->pdev->dev, "Cannot setup transfer\n");
665                 return status;
666         }
667
668         if (!xfer->cs_change && !spi_transfer_is_last(master, xfer))
669                 attr = DLN2_SPI_ATTR_LEAVE_SS_LOW;
670
671         status = dln2_spi_rdwr(dln2, xfer->tx_buf, xfer->rx_buf,
672                                xfer->len, attr);
673         if (status < 0)
674                 dev_err(&dln2->pdev->dev, "write/read failed!\n");
675
676         return status;
677 }
678
679 static int dln2_spi_probe(struct platform_device *pdev)
680 {
681         struct spi_master *master;
682         struct dln2_spi *dln2;
683         struct dln2_platform_data *pdata = dev_get_platdata(&pdev->dev);
684         struct device *dev = &pdev->dev;
685         int ret;
686
687         master = spi_alloc_master(&pdev->dev, sizeof(*dln2));
688         if (!master)
689                 return -ENOMEM;
690
691         platform_set_drvdata(pdev, master);
692
693         dln2 = spi_master_get_devdata(master);
694
695         dln2->buf = devm_kmalloc(&pdev->dev, DLN2_SPI_BUF_SIZE, GFP_KERNEL);
696         if (!dln2->buf) {
697                 ret = -ENOMEM;
698                 goto exit_free_master;
699         }
700
701         dln2->master = master;
702         dln2->master->dev.of_node = dev->of_node;
703         dln2->pdev = pdev;
704         dln2->port = pdata->port;
705         /* cs/mode can never be 0xff, so the first transfer will set them */
706         dln2->cs = 0xff;
707         dln2->mode = 0xff;
708
709         /* disable SPI module before continuing with the setup */
710         ret = dln2_spi_enable(dln2, false);
711         if (ret < 0) {
712                 dev_err(&pdev->dev, "Failed to disable SPI module\n");
713                 goto exit_free_master;
714         }
715
716         ret = dln2_spi_get_cs_num(dln2, &master->num_chipselect);
717         if (ret < 0) {
718                 dev_err(&pdev->dev, "Failed to get number of CS pins\n");
719                 goto exit_free_master;
720         }
721
722         ret = dln2_spi_get_speed_range(dln2,
723                                        &master->min_speed_hz,
724                                        &master->max_speed_hz);
725         if (ret < 0) {
726                 dev_err(&pdev->dev, "Failed to read bus min/max freqs\n");
727                 goto exit_free_master;
728         }
729
730         ret = dln2_spi_get_supported_frame_sizes(dln2,
731                                                  &master->bits_per_word_mask);
732         if (ret < 0) {
733                 dev_err(&pdev->dev, "Failed to read supported frame sizes\n");
734                 goto exit_free_master;
735         }
736
737         ret = dln2_spi_cs_enable_all(dln2, true);
738         if (ret < 0) {
739                 dev_err(&pdev->dev, "Failed to enable CS pins\n");
740                 goto exit_free_master;
741         }
742
743         master->bus_num = -1;
744         master->mode_bits = SPI_CPOL | SPI_CPHA;
745         master->prepare_message = dln2_spi_prepare_message;
746         master->transfer_one = dln2_spi_transfer_one;
747         master->auto_runtime_pm = true;
748
749         /* enable SPI module, we're good to go */
750         ret = dln2_spi_enable(dln2, true);
751         if (ret < 0) {
752                 dev_err(&pdev->dev, "Failed to enable SPI module\n");
753                 goto exit_free_master;
754         }
755
756         pm_runtime_set_autosuspend_delay(&pdev->dev,
757                                          DLN2_RPM_AUTOSUSPEND_TIMEOUT);
758         pm_runtime_use_autosuspend(&pdev->dev);
759         pm_runtime_set_active(&pdev->dev);
760         pm_runtime_enable(&pdev->dev);
761
762         ret = devm_spi_register_master(&pdev->dev, master);
763         if (ret < 0) {
764                 dev_err(&pdev->dev, "Failed to register master\n");
765                 goto exit_register;
766         }
767
768         return ret;
769
770 exit_register:
771         pm_runtime_disable(&pdev->dev);
772         pm_runtime_set_suspended(&pdev->dev);
773
774         if (dln2_spi_enable(dln2, false) < 0)
775                 dev_err(&pdev->dev, "Failed to disable SPI module\n");
776 exit_free_master:
777         spi_master_put(master);
778
779         return ret;
780 }
781
782 static int dln2_spi_remove(struct platform_device *pdev)
783 {
784         struct spi_master *master = platform_get_drvdata(pdev);
785         struct dln2_spi *dln2 = spi_master_get_devdata(master);
786
787         pm_runtime_disable(&pdev->dev);
788
789         if (dln2_spi_enable(dln2, false) < 0)
790                 dev_err(&pdev->dev, "Failed to disable SPI module\n");
791
792         return 0;
793 }
794
795 #ifdef CONFIG_PM_SLEEP
796 static int dln2_spi_suspend(struct device *dev)
797 {
798         int ret;
799         struct spi_master *master = dev_get_drvdata(dev);
800         struct dln2_spi *dln2 = spi_master_get_devdata(master);
801
802         ret = spi_master_suspend(master);
803         if (ret < 0)
804                 return ret;
805
806         if (!pm_runtime_suspended(dev)) {
807                 ret = dln2_spi_enable(dln2, false);
808                 if (ret < 0)
809                         return ret;
810         }
811
812         /*
813          * USB power may be cut off during sleep. Resetting the following
814          * parameters will force the board to be set up before first transfer.
815          */
816         dln2->cs = 0xff;
817         dln2->speed = 0;
818         dln2->bpw = 0;
819         dln2->mode = 0xff;
820
821         return 0;
822 }
823
824 static int dln2_spi_resume(struct device *dev)
825 {
826         int ret;
827         struct spi_master *master = dev_get_drvdata(dev);
828         struct dln2_spi *dln2 = spi_master_get_devdata(master);
829
830         if (!pm_runtime_suspended(dev)) {
831                 ret = dln2_spi_cs_enable_all(dln2, true);
832                 if (ret < 0)
833                         return ret;
834
835                 ret = dln2_spi_enable(dln2, true);
836                 if (ret < 0)
837                         return ret;
838         }
839
840         return spi_master_resume(master);
841 }
842 #endif /* CONFIG_PM_SLEEP */
843
844 #ifdef CONFIG_PM
845 static int dln2_spi_runtime_suspend(struct device *dev)
846 {
847         struct spi_master *master = dev_get_drvdata(dev);
848         struct dln2_spi *dln2 = spi_master_get_devdata(master);
849
850         return dln2_spi_enable(dln2, false);
851 }
852
853 static int dln2_spi_runtime_resume(struct device *dev)
854 {
855         struct spi_master *master = dev_get_drvdata(dev);
856         struct dln2_spi *dln2 = spi_master_get_devdata(master);
857
858         return  dln2_spi_enable(dln2, true);
859 }
860 #endif /* CONFIG_PM */
861
862 static const struct dev_pm_ops dln2_spi_pm = {
863         SET_SYSTEM_SLEEP_PM_OPS(dln2_spi_suspend, dln2_spi_resume)
864         SET_RUNTIME_PM_OPS(dln2_spi_runtime_suspend,
865                            dln2_spi_runtime_resume, NULL)
866 };
867
868 static struct platform_driver spi_dln2_driver = {
869         .driver = {
870                 .name   = "dln2-spi",
871                 .pm     = &dln2_spi_pm,
872         },
873         .probe          = dln2_spi_probe,
874         .remove         = dln2_spi_remove,
875 };
876 module_platform_driver(spi_dln2_driver);
877
878 MODULE_DESCRIPTION("Driver for the Diolan DLN2 SPI master interface");
879 MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>");
880 MODULE_LICENSE("GPL v2");
881 MODULE_ALIAS("platform:dln2-spi");