spi, mpc8xx: Add support for chipselect via GPIO and fixups
[platform/kernel/u-boot.git] / drivers / spi / mt7620_spi.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2020 MediaTek Inc.
4  *
5  * Author: Weijie Gao <weijie.gao@mediatek.com>
6  *
7  * Generic SPI driver for MediaTek MT7620 SoC
8  */
9
10 #include <clk.h>
11 #include <dm.h>
12 #include <dm/device_compat.h>
13 #include <spi.h>
14 #include <linux/bitops.h>
15 #include <linux/iopoll.h>
16 #include <linux/io.h>
17 #include <linux/log2.h>
18
19 #define MT7620_SPI_NUM_CS       2
20 #define MT7620_SPI_MASTER1_OFF  0x00
21 #define MT7620_SPI_MASTER2_OFF  0x40
22
23 /* SPI_STAT */
24 #define   SPI_BUSY              BIT(0)
25
26 /* SPI_CFG */
27 #define   MSB_FIRST             BIT(8)
28 #define   SPI_CLK_POL           BIT(6)
29 #define   RX_CLK_EDGE           BIT(5)
30 #define   TX_CLK_EDGE           BIT(4)
31 #define   SPI_CLK_S             0
32 #define   SPI_CLK_M             GENMASK(2, 0)
33
34 /* SPI_CTL */
35 #define   START_WR              BIT(2)
36 #define   START_RD              BIT(1)
37 #define   SPI_HIGH              BIT(0)
38
39 #define SPI_ARB                 0xf0
40 #define   ARB_EN                BIT(31)
41
42 #define POLLING_SCALE           10
43 #define POLLING_FRAC_USEC       100
44
45 struct mt7620_spi_master_regs {
46         u32 stat;
47         u32 reserved0[3];
48         u32 cfg;
49         u32 ctl;
50         u32 reserved1[2];
51         u32 data;
52 };
53
54 struct mt7620_spi {
55         void __iomem *regs;
56         struct mt7620_spi_master_regs *m[MT7620_SPI_NUM_CS];
57         unsigned int sys_freq;
58         u32 wait_us;
59         uint mode;
60         uint speed;
61 };
62
63 static void mt7620_spi_master_setup(struct mt7620_spi *ms, int cs)
64 {
65         u32 rate, prescale, freq, tmo, cfg;
66
67         /* Calculate the clock divsior */
68         rate = DIV_ROUND_UP(ms->sys_freq, ms->speed);
69         rate = roundup_pow_of_two(rate);
70
71         prescale = ilog2(rate / 2);
72         if (prescale > 6)
73                 prescale = 6;
74
75         /* Calculate the real clock, and usecs for one byte transaction */
76         freq = ms->sys_freq >> (prescale + 1);
77         tmo = DIV_ROUND_UP(8 * 1000000, freq);
78
79         /* 10 times tolerance plus 100us */
80         ms->wait_us = POLLING_SCALE * tmo + POLLING_FRAC_USEC;
81
82         /* set SPI_CFG */
83         cfg = prescale << SPI_CLK_S;
84
85         switch (ms->mode & (SPI_CPOL | SPI_CPHA)) {
86         case SPI_MODE_0:
87                 cfg |= TX_CLK_EDGE;
88                 break;
89         case SPI_MODE_1:
90                 cfg |= RX_CLK_EDGE;
91                 break;
92         case SPI_MODE_2:
93                 cfg |= SPI_CLK_POL | RX_CLK_EDGE;
94                 break;
95         case SPI_MODE_3:
96                 cfg |= SPI_CLK_POL | TX_CLK_EDGE;
97                 break;
98         }
99
100         if (!(ms->mode & SPI_LSB_FIRST))
101                 cfg |= MSB_FIRST;
102
103         writel(cfg, &ms->m[cs]->cfg);
104
105         writel(SPI_HIGH, &ms->m[cs]->ctl);
106 }
107
108 static void mt7620_spi_set_cs(struct mt7620_spi *ms, int cs, bool enable)
109 {
110         if (enable)
111                 mt7620_spi_master_setup(ms, cs);
112
113         if (ms->mode & SPI_CS_HIGH)
114                 enable = !enable;
115
116         if (enable)
117                 clrbits_32(&ms->m[cs]->ctl, SPI_HIGH);
118         else
119                 setbits_32(&ms->m[cs]->ctl, SPI_HIGH);
120 }
121
122 static int mt7620_spi_set_mode(struct udevice *bus, uint mode)
123 {
124         struct mt7620_spi *ms = dev_get_priv(bus);
125
126         ms->mode = mode;
127
128         /* Mode 0 is buggy. Force to use mode 3 */
129         if ((mode & SPI_MODE_3) == SPI_MODE_0)
130                 ms->mode |= SPI_MODE_3;
131
132         return 0;
133 }
134
135 static int mt7620_spi_set_speed(struct udevice *bus, uint speed)
136 {
137         struct mt7620_spi *ms = dev_get_priv(bus);
138
139         ms->speed = speed;
140
141         return 0;
142 }
143
144 static inline int mt7620_spi_busy_poll(struct mt7620_spi *ms, int cs)
145 {
146         u32 val;
147
148         return readl_poll_timeout(&ms->m[cs]->stat, val, !(val & SPI_BUSY),
149                                   ms->wait_us);
150 }
151
152 static int mt7620_spi_read(struct mt7620_spi *ms, int cs, u8 *buf, size_t len)
153 {
154         int ret;
155
156         while (len) {
157                 setbits_32(&ms->m[cs]->ctl, START_RD);
158
159                 ret = mt7620_spi_busy_poll(ms, cs);
160                 if (ret)
161                         return ret;
162
163                 *buf++ = (u8)readl(&ms->m[cs]->data);
164
165                 len--;
166         }
167
168         return 0;
169 }
170
171 static int mt7620_spi_write(struct mt7620_spi *ms, int cs, const u8 *buf,
172                             size_t len)
173 {
174         int ret;
175
176         while (len) {
177                 writel(*buf++, &ms->m[cs]->data);
178                 setbits_32(&ms->m[cs]->ctl, START_WR);
179
180                 ret = mt7620_spi_busy_poll(ms, cs);
181                 if (ret)
182                         return ret;
183
184                 len--;
185         }
186
187         return 0;
188 }
189
190 static int mt7620_spi_xfer(struct udevice *dev, unsigned int bitlen,
191                            const void *dout, void *din, unsigned long flags)
192 {
193         struct udevice *bus = dev->parent;
194         struct mt7620_spi *ms = dev_get_priv(bus);
195         int total_size = bitlen >> 3;
196         int cs, ret = 0;
197
198         /*
199          * This driver only supports half-duplex, so complain and bail out
200          * upon full-duplex messages
201          */
202         if (dout && din) {
203                 dev_err(dev, "mt7620_spi: Only half-duplex is supported\n");
204                 return -EIO;
205         }
206
207         cs = spi_chip_select(dev);
208         if (cs < 0 || cs >= MT7620_SPI_NUM_CS) {
209                 dev_err(dev, "mt7620_spi: Invalid chip select %d\n", cs);
210                 return -EINVAL;
211         }
212
213         if (flags & SPI_XFER_BEGIN)
214                 mt7620_spi_set_cs(ms, cs, true);
215
216         if (din)
217                 ret = mt7620_spi_read(ms, cs, din, total_size);
218         else if (dout)
219                 ret = mt7620_spi_write(ms, cs, dout, total_size);
220
221         if (ret)
222                 dev_err(dev, "mt7620_spi: %s transaction timeout\n",
223                         din ? "read" : "write");
224
225         if (flags & SPI_XFER_END)
226                 mt7620_spi_set_cs(ms, cs, false);
227
228         return ret;
229 }
230
231 static int mt7620_spi_probe(struct udevice *dev)
232 {
233         struct mt7620_spi *ms = dev_get_priv(dev);
234         struct clk clk;
235         int ret;
236
237         ms->regs = dev_remap_addr(dev);
238         if (!ms->regs)
239                 return -EINVAL;
240
241         ms->m[0] = ms->regs + MT7620_SPI_MASTER1_OFF;
242         ms->m[1] = ms->regs + MT7620_SPI_MASTER2_OFF;
243
244         ret = clk_get_by_index(dev, 0, &clk);
245         if (ret < 0) {
246                 dev_err(dev, "mt7620_spi: Please provide a clock!\n");
247                 return ret;
248         }
249
250         clk_enable(&clk);
251
252         ms->sys_freq = clk_get_rate(&clk);
253         if (!ms->sys_freq) {
254                 dev_err(dev, "mt7620_spi: Please provide a valid bus clock!\n");
255                 return -EINVAL;
256         }
257
258         writel(ARB_EN, ms->regs + SPI_ARB);
259
260         return 0;
261 }
262
263 static const struct dm_spi_ops mt7620_spi_ops = {
264         .set_mode = mt7620_spi_set_mode,
265         .set_speed = mt7620_spi_set_speed,
266         .xfer = mt7620_spi_xfer,
267 };
268
269 static const struct udevice_id mt7620_spi_ids[] = {
270         { .compatible = "mediatek,mt7620-spi" },
271         { }
272 };
273
274 U_BOOT_DRIVER(mt7620_spi) = {
275         .name = "mt7620_spi",
276         .id = UCLASS_SPI,
277         .of_match = mt7620_spi_ids,
278         .ops = &mt7620_spi_ops,
279         .priv_auto = sizeof(struct mt7620_spi),
280         .probe = mt7620_spi_probe,
281 };