blob: 8d85a3c343dab635811cf4b6a871a841977fa09f [file] [log] [blame]
Mingkai Hu8b60d6c2010-10-12 18:18:32 +08001/*
2 * Freescale eSPI controller driver.
3 *
4 * Copyright 2010 Freescale Semiconductor, Inc.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or (at your
9 * option) any later version.
10 */
Mingkai Hu8b60d6c2010-10-12 18:18:32 +080011#include <linux/delay.h>
Xiubo Lia3108362014-09-29 10:57:06 +080012#include <linux/err.h>
Mingkai Hu8b60d6c2010-10-12 18:18:32 +080013#include <linux/fsl_devices.h>
Xiubo Lia3108362014-09-29 10:57:06 +080014#include <linux/interrupt.h>
15#include <linux/irq.h>
16#include <linux/module.h>
Mingkai Hu8b60d6c2010-10-12 18:18:32 +080017#include <linux/mm.h>
18#include <linux/of.h>
Rob Herring5af50732013-09-17 14:28:33 -050019#include <linux/of_address.h>
20#include <linux/of_irq.h>
Mingkai Hu8b60d6c2010-10-12 18:18:32 +080021#include <linux/of_platform.h>
Xiubo Lia3108362014-09-29 10:57:06 +080022#include <linux/platform_device.h>
23#include <linux/spi/spi.h>
Heiner Kallweite9abb4d2015-08-26 21:21:55 +020024#include <linux/pm_runtime.h>
Mingkai Hu8b60d6c2010-10-12 18:18:32 +080025#include <sysdev/fsl_soc.h>
26
Grant Likelyca632f52011-06-06 01:16:30 -060027#include "spi-fsl-lib.h"
Mingkai Hu8b60d6c2010-10-12 18:18:32 +080028
29/* eSPI Controller registers */
30struct fsl_espi_reg {
31 __be32 mode; /* 0x000 - eSPI mode register */
32 __be32 event; /* 0x004 - eSPI event register */
33 __be32 mask; /* 0x008 - eSPI mask register */
34 __be32 command; /* 0x00c - eSPI command register */
35 __be32 transmit; /* 0x010 - eSPI transmit FIFO access register*/
36 __be32 receive; /* 0x014 - eSPI receive FIFO access register*/
37 u8 res[8]; /* 0x018 - 0x01c reserved */
38 __be32 csmode[4]; /* 0x020 - 0x02c eSPI cs mode register */
39};
40
41struct fsl_espi_transfer {
42 const void *tx_buf;
43 void *rx_buf;
44 unsigned len;
45 unsigned n_tx;
46 unsigned n_rx;
47 unsigned actual_length;
48 int status;
49};
50
51/* eSPI Controller mode register definitions */
52#define SPMODE_ENABLE (1 << 31)
53#define SPMODE_LOOP (1 << 30)
54#define SPMODE_TXTHR(x) ((x) << 8)
55#define SPMODE_RXTHR(x) ((x) << 0)
56
57/* eSPI Controller CS mode register definitions */
58#define CSMODE_CI_INACTIVEHIGH (1 << 31)
59#define CSMODE_CP_BEGIN_EDGECLK (1 << 30)
60#define CSMODE_REV (1 << 29)
61#define CSMODE_DIV16 (1 << 28)
62#define CSMODE_PM(x) ((x) << 24)
63#define CSMODE_POL_1 (1 << 20)
64#define CSMODE_LEN(x) ((x) << 16)
65#define CSMODE_BEF(x) ((x) << 12)
66#define CSMODE_AFT(x) ((x) << 8)
67#define CSMODE_CG(x) ((x) << 3)
68
69/* Default mode/csmode for eSPI controller */
70#define SPMODE_INIT_VAL (SPMODE_TXTHR(4) | SPMODE_RXTHR(3))
71#define CSMODE_INIT_VAL (CSMODE_POL_1 | CSMODE_BEF(0) \
72 | CSMODE_AFT(0) | CSMODE_CG(1))
73
74/* SPIE register values */
75#define SPIE_NE 0x00000200 /* Not empty */
76#define SPIE_NF 0x00000100 /* Not full */
77
78/* SPIM register values */
79#define SPIM_NE 0x00000200 /* Not empty */
80#define SPIM_NF 0x00000100 /* Not full */
81#define SPIE_RXCNT(reg) ((reg >> 24) & 0x3F)
82#define SPIE_TXCNT(reg) ((reg >> 16) & 0x3F)
83
84/* SPCOM register values */
85#define SPCOM_CS(x) ((x) << 30)
86#define SPCOM_TRANLEN(x) ((x) << 0)
Hou Zhiqiang5cfa1e42016-01-22 18:58:26 +080087#define SPCOM_TRANLEN_MAX 0x10000 /* Max transaction length */
Mingkai Hu8b60d6c2010-10-12 18:18:32 +080088
Heiner Kallweite9abb4d2015-08-26 21:21:55 +020089#define AUTOSUSPEND_TIMEOUT 2000
90
Mingkai Hu8b60d6c2010-10-12 18:18:32 +080091static void fsl_espi_change_mode(struct spi_device *spi)
92{
93 struct mpc8xxx_spi *mspi = spi_master_get_devdata(spi->master);
94 struct spi_mpc8xxx_cs *cs = spi->controller_state;
95 struct fsl_espi_reg *reg_base = mspi->reg_base;
96 __be32 __iomem *mode = &reg_base->csmode[spi->chip_select];
97 __be32 __iomem *espi_mode = &reg_base->mode;
98 u32 tmp;
99 unsigned long flags;
100
101 /* Turn off IRQs locally to minimize time that SPI is disabled. */
102 local_irq_save(flags);
103
104 /* Turn off SPI unit prior changing mode */
105 tmp = mpc8xxx_spi_read_reg(espi_mode);
106 mpc8xxx_spi_write_reg(espi_mode, tmp & ~SPMODE_ENABLE);
107 mpc8xxx_spi_write_reg(mode, cs->hw_mode);
108 mpc8xxx_spi_write_reg(espi_mode, tmp);
109
110 local_irq_restore(flags);
111}
112
113static u32 fsl_espi_tx_buf_lsb(struct mpc8xxx_spi *mpc8xxx_spi)
114{
115 u32 data;
116 u16 data_h;
117 u16 data_l;
118 const u32 *tx = mpc8xxx_spi->tx;
119
120 if (!tx)
121 return 0;
122
123 data = *tx++ << mpc8xxx_spi->tx_shift;
124 data_l = data & 0xffff;
125 data_h = (data >> 16) & 0xffff;
126 swab16s(&data_l);
127 swab16s(&data_h);
128 data = data_h | data_l;
129
130 mpc8xxx_spi->tx = tx;
131 return data;
132}
133
134static int fsl_espi_setup_transfer(struct spi_device *spi,
135 struct spi_transfer *t)
136{
137 struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
138 int bits_per_word = 0;
139 u8 pm;
140 u32 hz = 0;
141 struct spi_mpc8xxx_cs *cs = spi->controller_state;
142
143 if (t) {
144 bits_per_word = t->bits_per_word;
145 hz = t->speed_hz;
146 }
147
148 /* spi_transfer level calls that work per-word */
149 if (!bits_per_word)
150 bits_per_word = spi->bits_per_word;
151
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800152 if (!hz)
153 hz = spi->max_speed_hz;
154
155 cs->rx_shift = 0;
156 cs->tx_shift = 0;
157 cs->get_rx = mpc8xxx_spi_rx_buf_u32;
158 cs->get_tx = mpc8xxx_spi_tx_buf_u32;
159 if (bits_per_word <= 8) {
160 cs->rx_shift = 8 - bits_per_word;
Stephen Warren51faed62013-05-30 09:59:41 -0600161 } else {
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800162 cs->rx_shift = 16 - bits_per_word;
163 if (spi->mode & SPI_LSB_FIRST)
164 cs->get_tx = fsl_espi_tx_buf_lsb;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800165 }
166
167 mpc8xxx_spi->rx_shift = cs->rx_shift;
168 mpc8xxx_spi->tx_shift = cs->tx_shift;
169 mpc8xxx_spi->get_rx = cs->get_rx;
170 mpc8xxx_spi->get_tx = cs->get_tx;
171
172 bits_per_word = bits_per_word - 1;
173
174 /* mask out bits we are going to set */
175 cs->hw_mode &= ~(CSMODE_LEN(0xF) | CSMODE_DIV16 | CSMODE_PM(0xF));
176
177 cs->hw_mode |= CSMODE_LEN(bits_per_word);
178
179 if ((mpc8xxx_spi->spibrg / hz) > 64) {
180 cs->hw_mode |= CSMODE_DIV16;
Sebastian Andrzej Siewior35faa552012-03-15 18:42:31 +0100181 pm = DIV_ROUND_UP(mpc8xxx_spi->spibrg, hz * 16 * 4);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800182
Sebastian Andrzej Siewior87bf5ab2012-03-15 18:42:32 +0100183 WARN_ONCE(pm > 33, "%s: Requested speed is too low: %d Hz. "
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800184 "Will use %d Hz instead.\n", dev_name(&spi->dev),
Sebastian Andrzej Siewior87bf5ab2012-03-15 18:42:32 +0100185 hz, mpc8xxx_spi->spibrg / (4 * 16 * (32 + 1)));
186 if (pm > 33)
187 pm = 33;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800188 } else {
Sebastian Andrzej Siewior35faa552012-03-15 18:42:31 +0100189 pm = DIV_ROUND_UP(mpc8xxx_spi->spibrg, hz * 4);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800190 }
191 if (pm)
192 pm--;
Sebastian Andrzej Siewior87bf5ab2012-03-15 18:42:32 +0100193 if (pm < 2)
194 pm = 2;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800195
196 cs->hw_mode |= CSMODE_PM(pm);
197
198 fsl_espi_change_mode(spi);
199 return 0;
200}
201
202static int fsl_espi_cpu_bufs(struct mpc8xxx_spi *mspi, struct spi_transfer *t,
203 unsigned int len)
204{
205 u32 word;
206 struct fsl_espi_reg *reg_base = mspi->reg_base;
207
208 mspi->count = len;
209
210 /* enable rx ints */
211 mpc8xxx_spi_write_reg(&reg_base->mask, SPIM_NE);
212
213 /* transmit word */
214 word = mspi->get_tx(mspi);
215 mpc8xxx_spi_write_reg(&reg_base->transmit, word);
216
217 return 0;
218}
219
220static int fsl_espi_bufs(struct spi_device *spi, struct spi_transfer *t)
221{
222 struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
223 struct fsl_espi_reg *reg_base = mpc8xxx_spi->reg_base;
224 unsigned int len = t->len;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800225 int ret;
226
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800227 mpc8xxx_spi->len = t->len;
228 len = roundup(len, 4) / 4;
229
230 mpc8xxx_spi->tx = t->tx_buf;
231 mpc8xxx_spi->rx = t->rx_buf;
232
Wolfram Sang16735d02013-11-14 14:32:02 -0800233 reinit_completion(&mpc8xxx_spi->done);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800234
235 /* Set SPCOM[CS] and SPCOM[TRANLEN] field */
Hou Zhiqiang5cfa1e42016-01-22 18:58:26 +0800236 if (t->len > SPCOM_TRANLEN_MAX) {
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800237 dev_err(mpc8xxx_spi->dev, "Transaction length (%d)"
238 " beyond the SPCOM[TRANLEN] field\n", t->len);
239 return -EINVAL;
240 }
241 mpc8xxx_spi_write_reg(&reg_base->command,
242 (SPCOM_CS(spi->chip_select) | SPCOM_TRANLEN(t->len - 1)));
243
244 ret = fsl_espi_cpu_bufs(mpc8xxx_spi, t, len);
245 if (ret)
246 return ret;
247
Nobuteru Hayashiaa70e562016-03-18 11:35:21 +0000248 /* Won't hang up forever, SPI bus sometimes got lost interrupts... */
249 ret = wait_for_completion_timeout(&mpc8xxx_spi->done, 2 * HZ);
250 if (ret == 0)
251 dev_err(mpc8xxx_spi->dev,
252 "Transaction hanging up (left %d bytes)\n",
253 mpc8xxx_spi->count);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800254
255 /* disable rx ints */
256 mpc8xxx_spi_write_reg(&reg_base->mask, 0);
257
258 return mpc8xxx_spi->count;
259}
260
Mingkai Hu0dd2c962010-12-21 09:27:02 +0800261static inline void fsl_espi_addr2cmd(unsigned int addr, u8 *cmd)
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800262{
Mingkai Hu0dd2c962010-12-21 09:27:02 +0800263 if (cmd) {
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800264 cmd[1] = (u8)(addr >> 16);
265 cmd[2] = (u8)(addr >> 8);
266 cmd[3] = (u8)(addr >> 0);
267 }
268}
269
Mingkai Hu0dd2c962010-12-21 09:27:02 +0800270static inline unsigned int fsl_espi_cmd2addr(u8 *cmd)
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800271{
Mingkai Hu0dd2c962010-12-21 09:27:02 +0800272 if (cmd)
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800273 return cmd[1] << 16 | cmd[2] << 8 | cmd[3] << 0;
274
275 return 0;
276}
277
278static void fsl_espi_do_trans(struct spi_message *m,
279 struct fsl_espi_transfer *tr)
280{
281 struct spi_device *spi = m->spi;
282 struct mpc8xxx_spi *mspi = spi_master_get_devdata(spi->master);
283 struct fsl_espi_transfer *espi_trans = tr;
284 struct spi_message message;
285 struct spi_transfer *t, *first, trans;
286 int status = 0;
287
288 spi_message_init(&message);
289 memset(&trans, 0, sizeof(trans));
290
291 first = list_first_entry(&m->transfers, struct spi_transfer,
292 transfer_list);
293 list_for_each_entry(t, &m->transfers, transfer_list) {
294 if ((first->bits_per_word != t->bits_per_word) ||
295 (first->speed_hz != t->speed_hz)) {
296 espi_trans->status = -EINVAL;
Jarkko Nikulaf6bd03a2013-10-11 13:54:00 +0300297 dev_err(mspi->dev,
298 "bits_per_word/speed_hz should be same for the same SPI transfer\n");
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800299 return;
300 }
301
302 trans.speed_hz = t->speed_hz;
303 trans.bits_per_word = t->bits_per_word;
304 trans.delay_usecs = max(first->delay_usecs, t->delay_usecs);
305 }
306
307 trans.len = espi_trans->len;
308 trans.tx_buf = espi_trans->tx_buf;
309 trans.rx_buf = espi_trans->rx_buf;
310 spi_message_add_tail(&trans, &message);
311
312 list_for_each_entry(t, &message.transfers, transfer_list) {
313 if (t->bits_per_word || t->speed_hz) {
314 status = -EINVAL;
315
316 status = fsl_espi_setup_transfer(spi, t);
317 if (status < 0)
318 break;
319 }
320
321 if (t->len)
322 status = fsl_espi_bufs(spi, t);
323
324 if (status) {
325 status = -EMSGSIZE;
326 break;
327 }
328
329 if (t->delay_usecs)
330 udelay(t->delay_usecs);
331 }
332
333 espi_trans->status = status;
334 fsl_espi_setup_transfer(spi, NULL);
335}
336
337static void fsl_espi_cmd_trans(struct spi_message *m,
338 struct fsl_espi_transfer *trans, u8 *rx_buff)
339{
340 struct spi_transfer *t;
341 u8 *local_buf;
342 int i = 0;
343 struct fsl_espi_transfer *espi_trans = trans;
344
345 local_buf = kzalloc(SPCOM_TRANLEN_MAX, GFP_KERNEL);
346 if (!local_buf) {
347 espi_trans->status = -ENOMEM;
348 return;
349 }
350
351 list_for_each_entry(t, &m->transfers, transfer_list) {
352 if (t->tx_buf) {
353 memcpy(local_buf + i, t->tx_buf, t->len);
354 i += t->len;
355 }
356 }
357
358 espi_trans->tx_buf = local_buf;
Valentin Longchampa2cb1be2014-05-16 16:46:21 +0200359 espi_trans->rx_buf = local_buf;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800360 fsl_espi_do_trans(m, espi_trans);
361
362 espi_trans->actual_length = espi_trans->len;
363 kfree(local_buf);
364}
365
366static void fsl_espi_rw_trans(struct spi_message *m,
367 struct fsl_espi_transfer *trans, u8 *rx_buff)
368{
369 struct fsl_espi_transfer *espi_trans = trans;
Jonatas Rech20000582015-04-15 12:23:18 -0300370 unsigned int total_len = espi_trans->len;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800371 struct spi_transfer *t;
372 u8 *local_buf;
373 u8 *rx_buf = rx_buff;
374 unsigned int trans_len;
375 unsigned int addr;
Jonatas Rech20000582015-04-15 12:23:18 -0300376 unsigned int tx_only;
377 unsigned int rx_pos = 0;
378 unsigned int pos;
379 int i, loop;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800380
381 local_buf = kzalloc(SPCOM_TRANLEN_MAX, GFP_KERNEL);
382 if (!local_buf) {
383 espi_trans->status = -ENOMEM;
384 return;
385 }
386
Jonatas Rech20000582015-04-15 12:23:18 -0300387 for (pos = 0, loop = 0; pos < total_len; pos += trans_len, loop++) {
388 trans_len = total_len - pos;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800389
390 i = 0;
Jonatas Rech20000582015-04-15 12:23:18 -0300391 tx_only = 0;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800392 list_for_each_entry(t, &m->transfers, transfer_list) {
393 if (t->tx_buf) {
394 memcpy(local_buf + i, t->tx_buf, t->len);
395 i += t->len;
Jonatas Rech20000582015-04-15 12:23:18 -0300396 if (!t->rx_buf)
397 tx_only += t->len;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800398 }
399 }
400
Jonatas Rech20000582015-04-15 12:23:18 -0300401 /* Add additional TX bytes to compensate SPCOM_TRANLEN_MAX */
402 if (loop > 0)
403 trans_len += tx_only;
404
405 if (trans_len > SPCOM_TRANLEN_MAX)
406 trans_len = SPCOM_TRANLEN_MAX;
407
408 /* Update device offset */
Mingkai Hu0dd2c962010-12-21 09:27:02 +0800409 if (pos > 0) {
410 addr = fsl_espi_cmd2addr(local_buf);
Jonatas Rech20000582015-04-15 12:23:18 -0300411 addr += rx_pos;
Mingkai Hu0dd2c962010-12-21 09:27:02 +0800412 fsl_espi_addr2cmd(addr, local_buf);
413 }
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800414
Jonatas Rech20000582015-04-15 12:23:18 -0300415 espi_trans->len = trans_len;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800416 espi_trans->tx_buf = local_buf;
Valentin Longchampa2cb1be2014-05-16 16:46:21 +0200417 espi_trans->rx_buf = local_buf;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800418 fsl_espi_do_trans(m, espi_trans);
419
Jonatas Rech20000582015-04-15 12:23:18 -0300420 /* If there is at least one RX byte then copy it to rx_buf */
421 if (tx_only < SPCOM_TRANLEN_MAX)
422 memcpy(rx_buf + rx_pos, espi_trans->rx_buf + tx_only,
423 trans_len - tx_only);
424
425 rx_pos += trans_len - tx_only;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800426
427 if (loop > 0)
Jonatas Rech20000582015-04-15 12:23:18 -0300428 espi_trans->actual_length += espi_trans->len - tx_only;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800429 else
430 espi_trans->actual_length += espi_trans->len;
431 }
432
433 kfree(local_buf);
434}
435
Heiner Kallweitc592bec2014-12-03 07:56:17 +0100436static int fsl_espi_do_one_msg(struct spi_master *master,
437 struct spi_message *m)
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800438{
439 struct spi_transfer *t;
440 u8 *rx_buf = NULL;
441 unsigned int n_tx = 0;
442 unsigned int n_rx = 0;
Jonatas Rech20000582015-04-15 12:23:18 -0300443 unsigned int xfer_len = 0;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800444 struct fsl_espi_transfer espi_trans;
445
446 list_for_each_entry(t, &m->transfers, transfer_list) {
447 if (t->tx_buf)
448 n_tx += t->len;
449 if (t->rx_buf) {
450 n_rx += t->len;
451 rx_buf = t->rx_buf;
452 }
Jonatas Rech20000582015-04-15 12:23:18 -0300453 if ((t->tx_buf) || (t->rx_buf))
454 xfer_len += t->len;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800455 }
456
457 espi_trans.n_tx = n_tx;
458 espi_trans.n_rx = n_rx;
Jonatas Rech20000582015-04-15 12:23:18 -0300459 espi_trans.len = xfer_len;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800460 espi_trans.actual_length = 0;
461 espi_trans.status = 0;
462
463 if (!rx_buf)
464 fsl_espi_cmd_trans(m, &espi_trans, NULL);
465 else
466 fsl_espi_rw_trans(m, &espi_trans, rx_buf);
467
468 m->actual_length = espi_trans.actual_length;
469 m->status = espi_trans.status;
Heiner Kallweitc592bec2014-12-03 07:56:17 +0100470 spi_finalize_current_message(master);
471 return 0;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800472}
473
474static int fsl_espi_setup(struct spi_device *spi)
475{
476 struct mpc8xxx_spi *mpc8xxx_spi;
477 struct fsl_espi_reg *reg_base;
478 int retval;
479 u32 hw_mode;
480 u32 loop_mode;
Axel Lind9f26742014-08-31 12:44:09 +0800481 struct spi_mpc8xxx_cs *cs = spi_get_ctldata(spi);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800482
483 if (!spi->max_speed_hz)
484 return -EINVAL;
485
486 if (!cs) {
Axel Lind9f26742014-08-31 12:44:09 +0800487 cs = kzalloc(sizeof(*cs), GFP_KERNEL);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800488 if (!cs)
489 return -ENOMEM;
Axel Lind9f26742014-08-31 12:44:09 +0800490 spi_set_ctldata(spi, cs);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800491 }
492
493 mpc8xxx_spi = spi_master_get_devdata(spi->master);
494 reg_base = mpc8xxx_spi->reg_base;
495
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200496 pm_runtime_get_sync(mpc8xxx_spi->dev);
497
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300498 hw_mode = cs->hw_mode; /* Save original settings */
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800499 cs->hw_mode = mpc8xxx_spi_read_reg(
500 &reg_base->csmode[spi->chip_select]);
501 /* mask out bits we are going to set */
502 cs->hw_mode &= ~(CSMODE_CP_BEGIN_EDGECLK | CSMODE_CI_INACTIVEHIGH
503 | CSMODE_REV);
504
505 if (spi->mode & SPI_CPHA)
506 cs->hw_mode |= CSMODE_CP_BEGIN_EDGECLK;
507 if (spi->mode & SPI_CPOL)
508 cs->hw_mode |= CSMODE_CI_INACTIVEHIGH;
509 if (!(spi->mode & SPI_LSB_FIRST))
510 cs->hw_mode |= CSMODE_REV;
511
512 /* Handle the loop mode */
513 loop_mode = mpc8xxx_spi_read_reg(&reg_base->mode);
514 loop_mode &= ~SPMODE_LOOP;
515 if (spi->mode & SPI_LOOP)
516 loop_mode |= SPMODE_LOOP;
517 mpc8xxx_spi_write_reg(&reg_base->mode, loop_mode);
518
519 retval = fsl_espi_setup_transfer(spi, NULL);
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200520
521 pm_runtime_mark_last_busy(mpc8xxx_spi->dev);
522 pm_runtime_put_autosuspend(mpc8xxx_spi->dev);
523
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800524 if (retval < 0) {
525 cs->hw_mode = hw_mode; /* Restore settings */
526 return retval;
527 }
528 return 0;
529}
530
Axel Lind9f26742014-08-31 12:44:09 +0800531static void fsl_espi_cleanup(struct spi_device *spi)
532{
533 struct spi_mpc8xxx_cs *cs = spi_get_ctldata(spi);
534
535 kfree(cs);
536 spi_set_ctldata(spi, NULL);
537}
538
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800539void fsl_espi_cpu_irq(struct mpc8xxx_spi *mspi, u32 events)
540{
541 struct fsl_espi_reg *reg_base = mspi->reg_base;
542
543 /* We need handle RX first */
544 if (events & SPIE_NE) {
Mingkai Hue6289d62010-12-21 09:26:07 +0800545 u32 rx_data, tmp;
546 u8 rx_data_8;
Nobuteru Hayashi6319a682016-03-18 11:35:21 +0000547 int rx_nr_bytes = 4;
Nobuteru Hayashia12ddd62016-03-18 11:35:21 +0000548 int ret;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800549
550 /* Spin until RX is done */
Nobuteru Hayashia12ddd62016-03-18 11:35:21 +0000551 if (SPIE_RXCNT(events) < min(4, mspi->len)) {
552 ret = spin_event_timeout(
553 !(SPIE_RXCNT(events =
554 mpc8xxx_spi_read_reg(&reg_base->event)) <
555 min(4, mspi->len)),
556 10000, 0); /* 10 msec */
557 if (!ret)
558 dev_err(mspi->dev,
559 "tired waiting for SPIE_RXCNT\n");
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800560 }
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800561
Mingkai Hue6289d62010-12-21 09:26:07 +0800562 if (mspi->len >= 4) {
563 rx_data = mpc8xxx_spi_read_reg(&reg_base->receive);
Nobuteru Hayashi6319a682016-03-18 11:35:21 +0000564 } else if (mspi->len <= 0) {
565 dev_err(mspi->dev,
566 "unexpected RX(SPIE_NE) interrupt occurred,\n"
567 "(local rxlen %d bytes, reg rxlen %d bytes)\n",
568 min(4, mspi->len), SPIE_RXCNT(events));
569 rx_nr_bytes = 0;
Mingkai Hue6289d62010-12-21 09:26:07 +0800570 } else {
Nobuteru Hayashi6319a682016-03-18 11:35:21 +0000571 rx_nr_bytes = mspi->len;
Mingkai Hue6289d62010-12-21 09:26:07 +0800572 tmp = mspi->len;
573 rx_data = 0;
574 while (tmp--) {
575 rx_data_8 = in_8((u8 *)&reg_base->receive);
576 rx_data |= (rx_data_8 << (tmp * 8));
577 }
578
579 rx_data <<= (4 - mspi->len) * 8;
580 }
581
Nobuteru Hayashi6319a682016-03-18 11:35:21 +0000582 mspi->len -= rx_nr_bytes;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800583
584 if (mspi->rx)
585 mspi->get_rx(rx_data, mspi);
586 }
587
588 if (!(events & SPIE_NF)) {
589 int ret;
590
591 /* spin until TX is done */
592 ret = spin_event_timeout(((events = mpc8xxx_spi_read_reg(
Jane Wan7a0a1752015-05-01 16:37:42 -0700593 &reg_base->event)) & SPIE_NF), 1000, 0);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800594 if (!ret) {
595 dev_err(mspi->dev, "tired waiting for SPIE_NF\n");
Jane Wan7a0a1752015-05-01 16:37:42 -0700596
597 /* Clear the SPIE bits */
598 mpc8xxx_spi_write_reg(&reg_base->event, events);
599 complete(&mspi->done);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800600 return;
601 }
602 }
603
604 /* Clear the events */
605 mpc8xxx_spi_write_reg(&reg_base->event, events);
606
607 mspi->count -= 1;
608 if (mspi->count) {
609 u32 word = mspi->get_tx(mspi);
610
611 mpc8xxx_spi_write_reg(&reg_base->transmit, word);
612 } else {
613 complete(&mspi->done);
614 }
615}
616
617static irqreturn_t fsl_espi_irq(s32 irq, void *context_data)
618{
619 struct mpc8xxx_spi *mspi = context_data;
620 struct fsl_espi_reg *reg_base = mspi->reg_base;
621 irqreturn_t ret = IRQ_NONE;
622 u32 events;
623
624 /* Get interrupt events(tx/rx) */
625 events = mpc8xxx_spi_read_reg(&reg_base->event);
626 if (events)
627 ret = IRQ_HANDLED;
628
629 dev_vdbg(mspi->dev, "%s: events %x\n", __func__, events);
630
631 fsl_espi_cpu_irq(mspi, events);
632
633 return ret;
634}
635
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200636#ifdef CONFIG_PM
637static int fsl_espi_runtime_suspend(struct device *dev)
Heiner Kallweit75506d02014-12-03 07:56:19 +0100638{
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200639 struct spi_master *master = dev_get_drvdata(dev);
640 struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(master);
641 struct fsl_espi_reg *reg_base = mpc8xxx_spi->reg_base;
Heiner Kallweit75506d02014-12-03 07:56:19 +0100642 u32 regval;
643
Heiner Kallweit75506d02014-12-03 07:56:19 +0100644 regval = mpc8xxx_spi_read_reg(&reg_base->mode);
645 regval &= ~SPMODE_ENABLE;
646 mpc8xxx_spi_write_reg(&reg_base->mode, regval);
647
648 return 0;
649}
650
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200651static int fsl_espi_runtime_resume(struct device *dev)
Heiner Kallweit75506d02014-12-03 07:56:19 +0100652{
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200653 struct spi_master *master = dev_get_drvdata(dev);
654 struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(master);
655 struct fsl_espi_reg *reg_base = mpc8xxx_spi->reg_base;
Heiner Kallweit75506d02014-12-03 07:56:19 +0100656 u32 regval;
657
Heiner Kallweit75506d02014-12-03 07:56:19 +0100658 regval = mpc8xxx_spi_read_reg(&reg_base->mode);
659 regval |= SPMODE_ENABLE;
660 mpc8xxx_spi_write_reg(&reg_base->mode, regval);
661
662 return 0;
663}
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200664#endif
Heiner Kallweit75506d02014-12-03 07:56:19 +0100665
Michal Suchanekb541eef2015-12-02 10:38:21 +0000666static size_t fsl_espi_max_transfer_size(struct spi_device *spi)
667{
668 return SPCOM_TRANLEN_MAX;
669}
670
Grant Likelyfd4a3192012-12-07 16:57:14 +0000671static struct spi_master * fsl_espi_probe(struct device *dev,
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800672 struct resource *mem, unsigned int irq)
673{
Jingoo Han8074cf02013-07-30 16:58:59 +0900674 struct fsl_spi_platform_data *pdata = dev_get_platdata(dev);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800675 struct spi_master *master;
676 struct mpc8xxx_spi *mpc8xxx_spi;
677 struct fsl_espi_reg *reg_base;
Jane Wand0fb47a52014-04-16 13:09:39 -0700678 struct device_node *nc;
679 const __be32 *prop;
680 u32 regval, csmode;
681 int i, len, ret = 0;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800682
683 master = spi_alloc_master(dev, sizeof(struct mpc8xxx_spi));
684 if (!master) {
685 ret = -ENOMEM;
686 goto err;
687 }
688
689 dev_set_drvdata(dev, master);
690
Heiner Kallweitc592bec2014-12-03 07:56:17 +0100691 mpc8xxx_spi_probe(dev, mem, irq);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800692
Stephen Warren24778be2013-05-21 20:36:35 -0600693 master->bits_per_word_mask = SPI_BPW_RANGE_MASK(4, 16);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800694 master->setup = fsl_espi_setup;
Axel Lind9f26742014-08-31 12:44:09 +0800695 master->cleanup = fsl_espi_cleanup;
Heiner Kallweitc592bec2014-12-03 07:56:17 +0100696 master->transfer_one_message = fsl_espi_do_one_msg;
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200697 master->auto_runtime_pm = true;
Michal Suchanekb541eef2015-12-02 10:38:21 +0000698 master->max_transfer_size = fsl_espi_max_transfer_size;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800699
700 mpc8xxx_spi = spi_master_get_devdata(master);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800701
Heiner Kallweit4178b6b2015-08-26 21:21:50 +0200702 mpc8xxx_spi->reg_base = devm_ioremap_resource(dev, mem);
Axel Lin37c5db72015-08-30 18:35:51 +0800703 if (IS_ERR(mpc8xxx_spi->reg_base)) {
704 ret = PTR_ERR(mpc8xxx_spi->reg_base);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800705 goto err_probe;
706 }
707
708 reg_base = mpc8xxx_spi->reg_base;
709
710 /* Register for SPI Interrupt */
Heiner Kallweit4178b6b2015-08-26 21:21:50 +0200711 ret = devm_request_irq(dev, mpc8xxx_spi->irq, fsl_espi_irq,
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800712 0, "fsl_espi", mpc8xxx_spi);
713 if (ret)
Heiner Kallweit4178b6b2015-08-26 21:21:50 +0200714 goto err_probe;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800715
716 if (mpc8xxx_spi->flags & SPI_QE_CPU_MODE) {
717 mpc8xxx_spi->rx_shift = 16;
718 mpc8xxx_spi->tx_shift = 24;
719 }
720
721 /* SPI controller initializations */
722 mpc8xxx_spi_write_reg(&reg_base->mode, 0);
723 mpc8xxx_spi_write_reg(&reg_base->mask, 0);
724 mpc8xxx_spi_write_reg(&reg_base->command, 0);
725 mpc8xxx_spi_write_reg(&reg_base->event, 0xffffffff);
726
727 /* Init eSPI CS mode register */
Jane Wand0fb47a52014-04-16 13:09:39 -0700728 for_each_available_child_of_node(master->dev.of_node, nc) {
729 /* get chip select */
730 prop = of_get_property(nc, "reg", &len);
731 if (!prop || len < sizeof(*prop))
732 continue;
733 i = be32_to_cpup(prop);
734 if (i < 0 || i >= pdata->max_chipselect)
735 continue;
736
737 csmode = CSMODE_INIT_VAL;
738 /* check if CSBEF is set in device tree */
739 prop = of_get_property(nc, "fsl,csbef", &len);
740 if (prop && len >= sizeof(*prop)) {
741 csmode &= ~(CSMODE_BEF(0xf));
742 csmode |= CSMODE_BEF(be32_to_cpup(prop));
743 }
744 /* check if CSAFT is set in device tree */
745 prop = of_get_property(nc, "fsl,csaft", &len);
746 if (prop && len >= sizeof(*prop)) {
747 csmode &= ~(CSMODE_AFT(0xf));
748 csmode |= CSMODE_AFT(be32_to_cpup(prop));
749 }
750 mpc8xxx_spi_write_reg(&reg_base->csmode[i], csmode);
751
752 dev_info(dev, "cs=%d, init_csmode=0x%x\n", i, csmode);
753 }
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800754
755 /* Enable SPI interface */
756 regval = pdata->initial_spmode | SPMODE_INIT_VAL | SPMODE_ENABLE;
757
758 mpc8xxx_spi_write_reg(&reg_base->mode, regval);
759
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200760 pm_runtime_set_autosuspend_delay(dev, AUTOSUSPEND_TIMEOUT);
761 pm_runtime_use_autosuspend(dev);
762 pm_runtime_set_active(dev);
763 pm_runtime_enable(dev);
764 pm_runtime_get_sync(dev);
765
Heiner Kallweit4178b6b2015-08-26 21:21:50 +0200766 ret = devm_spi_register_master(dev, master);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800767 if (ret < 0)
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200768 goto err_pm;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800769
770 dev_info(dev, "at 0x%p (irq = %d)\n", reg_base, mpc8xxx_spi->irq);
771
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200772 pm_runtime_mark_last_busy(dev);
773 pm_runtime_put_autosuspend(dev);
774
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800775 return master;
776
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200777err_pm:
778 pm_runtime_put_noidle(dev);
779 pm_runtime_disable(dev);
780 pm_runtime_set_suspended(dev);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800781err_probe:
782 spi_master_put(master);
783err:
784 return ERR_PTR(ret);
785}
786
787static int of_fsl_espi_get_chipselects(struct device *dev)
788{
789 struct device_node *np = dev->of_node;
Jingoo Han8074cf02013-07-30 16:58:59 +0900790 struct fsl_spi_platform_data *pdata = dev_get_platdata(dev);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800791 const u32 *prop;
792 int len;
793
794 prop = of_get_property(np, "fsl,espi-num-chipselects", &len);
795 if (!prop || len < sizeof(*prop)) {
796 dev_err(dev, "No 'fsl,espi-num-chipselects' property\n");
797 return -EINVAL;
798 }
799
800 pdata->max_chipselect = *prop;
801 pdata->cs_control = NULL;
802
803 return 0;
804}
805
Grant Likelyfd4a3192012-12-07 16:57:14 +0000806static int of_fsl_espi_probe(struct platform_device *ofdev)
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800807{
808 struct device *dev = &ofdev->dev;
809 struct device_node *np = ofdev->dev.of_node;
810 struct spi_master *master;
811 struct resource mem;
Thierry Redingf7578492013-09-18 15:24:44 +0200812 unsigned int irq;
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800813 int ret = -ENOMEM;
814
Grant Likely18d306d2011-02-22 21:02:43 -0700815 ret = of_mpc8xxx_spi_probe(ofdev);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800816 if (ret)
817 return ret;
818
819 ret = of_fsl_espi_get_chipselects(dev);
820 if (ret)
821 goto err;
822
823 ret = of_address_to_resource(np, 0, &mem);
824 if (ret)
825 goto err;
826
Thierry Redingf7578492013-09-18 15:24:44 +0200827 irq = irq_of_parse_and_map(np, 0);
Hou Zhiqiang7227cd12013-12-11 13:09:40 +0800828 if (!irq) {
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800829 ret = -EINVAL;
830 goto err;
831 }
832
Thierry Redingf7578492013-09-18 15:24:44 +0200833 master = fsl_espi_probe(dev, &mem, irq);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800834 if (IS_ERR(master)) {
835 ret = PTR_ERR(master);
836 goto err;
837 }
838
839 return 0;
840
841err:
842 return ret;
843}
844
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200845static int of_fsl_espi_remove(struct platform_device *dev)
846{
847 pm_runtime_disable(&dev->dev);
848
849 return 0;
850}
851
Hou Zhiqiang714bb652013-12-12 12:53:52 +0800852#ifdef CONFIG_PM_SLEEP
853static int of_fsl_espi_suspend(struct device *dev)
854{
855 struct spi_master *master = dev_get_drvdata(dev);
Hou Zhiqiang714bb652013-12-12 12:53:52 +0800856 int ret;
857
Hou Zhiqiang714bb652013-12-12 12:53:52 +0800858 ret = spi_master_suspend(master);
859 if (ret) {
860 dev_warn(dev, "cannot suspend master\n");
861 return ret;
862 }
863
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200864 ret = pm_runtime_force_suspend(dev);
865 if (ret < 0)
866 return ret;
867
868 return 0;
Hou Zhiqiang714bb652013-12-12 12:53:52 +0800869}
870
871static int of_fsl_espi_resume(struct device *dev)
872{
873 struct fsl_spi_platform_data *pdata = dev_get_platdata(dev);
874 struct spi_master *master = dev_get_drvdata(dev);
875 struct mpc8xxx_spi *mpc8xxx_spi;
876 struct fsl_espi_reg *reg_base;
877 u32 regval;
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200878 int i, ret;
Hou Zhiqiang714bb652013-12-12 12:53:52 +0800879
880 mpc8xxx_spi = spi_master_get_devdata(master);
881 reg_base = mpc8xxx_spi->reg_base;
882
883 /* SPI controller initializations */
884 mpc8xxx_spi_write_reg(&reg_base->mode, 0);
885 mpc8xxx_spi_write_reg(&reg_base->mask, 0);
886 mpc8xxx_spi_write_reg(&reg_base->command, 0);
887 mpc8xxx_spi_write_reg(&reg_base->event, 0xffffffff);
888
889 /* Init eSPI CS mode register */
890 for (i = 0; i < pdata->max_chipselect; i++)
891 mpc8xxx_spi_write_reg(&reg_base->csmode[i], CSMODE_INIT_VAL);
892
893 /* Enable SPI interface */
894 regval = pdata->initial_spmode | SPMODE_INIT_VAL | SPMODE_ENABLE;
895
896 mpc8xxx_spi_write_reg(&reg_base->mode, regval);
897
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200898 ret = pm_runtime_force_resume(dev);
899 if (ret < 0)
900 return ret;
901
Hou Zhiqiang714bb652013-12-12 12:53:52 +0800902 return spi_master_resume(master);
903}
904#endif /* CONFIG_PM_SLEEP */
905
906static const struct dev_pm_ops espi_pm = {
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200907 SET_RUNTIME_PM_OPS(fsl_espi_runtime_suspend,
908 fsl_espi_runtime_resume, NULL)
Hou Zhiqiang714bb652013-12-12 12:53:52 +0800909 SET_SYSTEM_SLEEP_PM_OPS(of_fsl_espi_suspend, of_fsl_espi_resume)
910};
911
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800912static const struct of_device_id of_fsl_espi_match[] = {
913 { .compatible = "fsl,mpc8536-espi" },
914 {}
915};
916MODULE_DEVICE_TABLE(of, of_fsl_espi_match);
917
Grant Likely18d306d2011-02-22 21:02:43 -0700918static struct platform_driver fsl_espi_driver = {
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800919 .driver = {
920 .name = "fsl_espi",
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800921 .of_match_table = of_fsl_espi_match,
Hou Zhiqiang714bb652013-12-12 12:53:52 +0800922 .pm = &espi_pm,
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800923 },
924 .probe = of_fsl_espi_probe,
Heiner Kallweite9abb4d2015-08-26 21:21:55 +0200925 .remove = of_fsl_espi_remove,
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800926};
Grant Likely940ab882011-10-05 11:29:49 -0600927module_platform_driver(fsl_espi_driver);
Mingkai Hu8b60d6c2010-10-12 18:18:32 +0800928
929MODULE_AUTHOR("Mingkai Hu");
930MODULE_DESCRIPTION("Enhanced Freescale SPI Driver");
931MODULE_LICENSE("GPL");