2 * Freescale eSPI controller driver.
4 * Copyright 2010 Freescale Semiconductor, Inc.
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.
11 #include <linux/delay.h>
12 #include <linux/err.h>
13 #include <linux/fsl_devices.h>
14 #include <linux/interrupt.h>
15 #include <linux/module.h>
18 #include <linux/of_address.h>
19 #include <linux/of_irq.h>
20 #include <linux/of_platform.h>
21 #include <linux/platform_device.h>
22 #include <linux/spi/spi.h>
23 #include <linux/pm_runtime.h>
24 #include <sysdev/fsl_soc.h>
26 #include "spi-fsl-lib.h"
28 /* eSPI Controller registers */
30 __be32 mode
; /* 0x000 - eSPI mode register */
31 __be32 event
; /* 0x004 - eSPI event register */
32 __be32 mask
; /* 0x008 - eSPI mask register */
33 __be32 command
; /* 0x00c - eSPI command register */
34 __be32 transmit
; /* 0x010 - eSPI transmit FIFO access register*/
35 __be32 receive
; /* 0x014 - eSPI receive FIFO access register*/
36 u8 res
[8]; /* 0x018 - 0x01c reserved */
37 __be32 csmode
[4]; /* 0x020 - 0x02c eSPI cs mode register */
40 /* eSPI Controller mode register definitions */
41 #define SPMODE_ENABLE (1 << 31)
42 #define SPMODE_LOOP (1 << 30)
43 #define SPMODE_TXTHR(x) ((x) << 8)
44 #define SPMODE_RXTHR(x) ((x) << 0)
46 /* eSPI Controller CS mode register definitions */
47 #define CSMODE_CI_INACTIVEHIGH (1 << 31)
48 #define CSMODE_CP_BEGIN_EDGECLK (1 << 30)
49 #define CSMODE_REV (1 << 29)
50 #define CSMODE_DIV16 (1 << 28)
51 #define CSMODE_PM(x) ((x) << 24)
52 #define CSMODE_POL_1 (1 << 20)
53 #define CSMODE_LEN(x) ((x) << 16)
54 #define CSMODE_BEF(x) ((x) << 12)
55 #define CSMODE_AFT(x) ((x) << 8)
56 #define CSMODE_CG(x) ((x) << 3)
58 /* Default mode/csmode for eSPI controller */
59 #define SPMODE_INIT_VAL (SPMODE_TXTHR(4) | SPMODE_RXTHR(3))
60 #define CSMODE_INIT_VAL (CSMODE_POL_1 | CSMODE_BEF(0) \
61 | CSMODE_AFT(0) | CSMODE_CG(1))
63 /* SPIE register values */
64 #define SPIE_NE 0x00000200 /* Not empty */
65 #define SPIE_NF 0x00000100 /* Not full */
67 /* SPIM register values */
68 #define SPIM_NE 0x00000200 /* Not empty */
69 #define SPIM_NF 0x00000100 /* Not full */
70 #define SPIE_RXCNT(reg) ((reg >> 24) & 0x3F)
71 #define SPIE_TXCNT(reg) ((reg >> 16) & 0x3F)
73 /* SPCOM register values */
74 #define SPCOM_CS(x) ((x) << 30)
75 #define SPCOM_TRANLEN(x) ((x) << 0)
76 #define SPCOM_TRANLEN_MAX 0x10000 /* Max transaction length */
78 #define AUTOSUSPEND_TIMEOUT 2000
80 static void fsl_espi_copy_to_buf(struct spi_message
*m
,
81 struct mpc8xxx_spi
*mspi
)
83 struct spi_transfer
*t
;
84 u8
*buf
= mspi
->local_buf
;
86 list_for_each_entry(t
, &m
->transfers
, transfer_list
) {
88 memcpy(buf
, t
->tx_buf
, t
->len
);
90 memset(buf
, 0, t
->len
);
95 static void fsl_espi_copy_from_buf(struct spi_message
*m
,
96 struct mpc8xxx_spi
*mspi
)
98 struct spi_transfer
*t
;
99 u8
*buf
= mspi
->local_buf
;
101 list_for_each_entry(t
, &m
->transfers
, transfer_list
) {
103 memcpy(t
->rx_buf
, buf
, t
->len
);
108 static int fsl_espi_check_message(struct spi_message
*m
)
110 struct mpc8xxx_spi
*mspi
= spi_master_get_devdata(m
->spi
->master
);
111 struct spi_transfer
*t
, *first
;
113 if (m
->frame_length
> SPCOM_TRANLEN_MAX
) {
114 dev_err(mspi
->dev
, "message too long, size is %u bytes\n",
119 first
= list_first_entry(&m
->transfers
, struct spi_transfer
,
121 list_for_each_entry(t
, &m
->transfers
, transfer_list
) {
122 if (first
->bits_per_word
!= t
->bits_per_word
||
123 first
->speed_hz
!= t
->speed_hz
) {
124 dev_err(mspi
->dev
, "bits_per_word/speed_hz should be the same for all transfers\n");
132 static void fsl_espi_change_mode(struct spi_device
*spi
)
134 struct mpc8xxx_spi
*mspi
= spi_master_get_devdata(spi
->master
);
135 struct spi_mpc8xxx_cs
*cs
= spi
->controller_state
;
136 struct fsl_espi_reg
*reg_base
= mspi
->reg_base
;
137 __be32 __iomem
*mode
= ®_base
->csmode
[spi
->chip_select
];
138 __be32 __iomem
*espi_mode
= ®_base
->mode
;
142 /* Turn off IRQs locally to minimize time that SPI is disabled. */
143 local_irq_save(flags
);
145 /* Turn off SPI unit prior changing mode */
146 tmp
= mpc8xxx_spi_read_reg(espi_mode
);
147 mpc8xxx_spi_write_reg(espi_mode
, tmp
& ~SPMODE_ENABLE
);
148 mpc8xxx_spi_write_reg(mode
, cs
->hw_mode
);
149 mpc8xxx_spi_write_reg(espi_mode
, tmp
);
151 local_irq_restore(flags
);
154 static u32
fsl_espi_tx_buf_lsb(struct mpc8xxx_spi
*mpc8xxx_spi
)
159 const u32
*tx
= mpc8xxx_spi
->tx
;
164 data
= *tx
++ << mpc8xxx_spi
->tx_shift
;
165 data_l
= data
& 0xffff;
166 data_h
= (data
>> 16) & 0xffff;
169 data
= data_h
| data_l
;
171 mpc8xxx_spi
->tx
= tx
;
175 static void fsl_espi_setup_transfer(struct spi_device
*spi
,
176 struct spi_transfer
*t
)
178 struct mpc8xxx_spi
*mpc8xxx_spi
= spi_master_get_devdata(spi
->master
);
179 int bits_per_word
= 0;
182 struct spi_mpc8xxx_cs
*cs
= spi
->controller_state
;
185 bits_per_word
= t
->bits_per_word
;
189 /* spi_transfer level calls that work per-word */
191 bits_per_word
= spi
->bits_per_word
;
194 hz
= spi
->max_speed_hz
;
198 cs
->get_rx
= mpc8xxx_spi_rx_buf_u32
;
199 cs
->get_tx
= mpc8xxx_spi_tx_buf_u32
;
200 if (bits_per_word
<= 8) {
201 cs
->rx_shift
= 8 - bits_per_word
;
203 cs
->rx_shift
= 16 - bits_per_word
;
204 if (spi
->mode
& SPI_LSB_FIRST
)
205 cs
->get_tx
= fsl_espi_tx_buf_lsb
;
208 mpc8xxx_spi
->rx_shift
= cs
->rx_shift
;
209 mpc8xxx_spi
->tx_shift
= cs
->tx_shift
;
210 mpc8xxx_spi
->get_rx
= cs
->get_rx
;
211 mpc8xxx_spi
->get_tx
= cs
->get_tx
;
213 /* mask out bits we are going to set */
214 cs
->hw_mode
&= ~(CSMODE_LEN(0xF) | CSMODE_DIV16
| CSMODE_PM(0xF));
216 cs
->hw_mode
|= CSMODE_LEN(bits_per_word
- 1);
218 if ((mpc8xxx_spi
->spibrg
/ hz
) > 64) {
219 cs
->hw_mode
|= CSMODE_DIV16
;
220 pm
= DIV_ROUND_UP(mpc8xxx_spi
->spibrg
, hz
* 16 * 4);
222 WARN_ONCE(pm
> 33, "%s: Requested speed is too low: %d Hz. "
223 "Will use %d Hz instead.\n", dev_name(&spi
->dev
),
224 hz
, mpc8xxx_spi
->spibrg
/ (4 * 16 * (32 + 1)));
228 pm
= DIV_ROUND_UP(mpc8xxx_spi
->spibrg
, hz
* 4);
235 cs
->hw_mode
|= CSMODE_PM(pm
);
237 fsl_espi_change_mode(spi
);
240 static int fsl_espi_bufs(struct spi_device
*spi
, struct spi_transfer
*t
)
242 struct mpc8xxx_spi
*mpc8xxx_spi
= spi_master_get_devdata(spi
->master
);
243 struct fsl_espi_reg
*reg_base
= mpc8xxx_spi
->reg_base
;
247 mpc8xxx_spi
->len
= t
->len
;
248 mpc8xxx_spi
->count
= roundup(t
->len
, 4) / 4;
250 mpc8xxx_spi
->tx
= t
->tx_buf
;
251 mpc8xxx_spi
->rx
= t
->rx_buf
;
253 reinit_completion(&mpc8xxx_spi
->done
);
255 /* Set SPCOM[CS] and SPCOM[TRANLEN] field */
256 mpc8xxx_spi_write_reg(®_base
->command
,
257 (SPCOM_CS(spi
->chip_select
) | SPCOM_TRANLEN(t
->len
- 1)));
260 mpc8xxx_spi_write_reg(®_base
->mask
, SPIM_NE
);
263 word
= mpc8xxx_spi
->get_tx(mpc8xxx_spi
);
264 mpc8xxx_spi_write_reg(®_base
->transmit
, word
);
266 /* Won't hang up forever, SPI bus sometimes got lost interrupts... */
267 ret
= wait_for_completion_timeout(&mpc8xxx_spi
->done
, 2 * HZ
);
269 dev_err(mpc8xxx_spi
->dev
,
270 "Transaction hanging up (left %d bytes)\n",
273 /* disable rx ints */
274 mpc8xxx_spi_write_reg(®_base
->mask
, 0);
276 return mpc8xxx_spi
->count
> 0 ? -EMSGSIZE
: 0;
279 static int fsl_espi_trans(struct spi_message
*m
, struct spi_transfer
*trans
)
281 struct mpc8xxx_spi
*mspi
= spi_master_get_devdata(m
->spi
->master
);
282 struct spi_device
*spi
= m
->spi
;
285 fsl_espi_copy_to_buf(m
, mspi
);
286 fsl_espi_setup_transfer(spi
, trans
);
288 ret
= fsl_espi_bufs(spi
, trans
);
290 if (trans
->delay_usecs
)
291 udelay(trans
->delay_usecs
);
293 fsl_espi_setup_transfer(spi
, NULL
);
296 fsl_espi_copy_from_buf(m
, mspi
);
301 static int fsl_espi_do_one_msg(struct spi_master
*master
,
302 struct spi_message
*m
)
304 struct mpc8xxx_spi
*mspi
= spi_master_get_devdata(m
->spi
->master
);
305 unsigned int delay_usecs
= 0;
306 struct spi_transfer
*t
, trans
= {};
309 ret
= fsl_espi_check_message(m
);
313 list_for_each_entry(t
, &m
->transfers
, transfer_list
) {
314 if (t
->delay_usecs
> delay_usecs
)
315 delay_usecs
= t
->delay_usecs
;
318 t
= list_first_entry(&m
->transfers
, struct spi_transfer
,
321 trans
.len
= m
->frame_length
;
322 trans
.speed_hz
= t
->speed_hz
;
323 trans
.bits_per_word
= t
->bits_per_word
;
324 trans
.delay_usecs
= delay_usecs
;
325 trans
.tx_buf
= mspi
->local_buf
;
326 trans
.rx_buf
= mspi
->local_buf
;
329 ret
= fsl_espi_trans(m
, &trans
);
331 m
->actual_length
= ret
? 0 : trans
.len
;
333 if (m
->status
== -EINPROGRESS
)
336 spi_finalize_current_message(master
);
341 static int fsl_espi_setup(struct spi_device
*spi
)
343 struct mpc8xxx_spi
*mpc8xxx_spi
;
344 struct fsl_espi_reg
*reg_base
;
347 struct spi_mpc8xxx_cs
*cs
= spi_get_ctldata(spi
);
349 if (!spi
->max_speed_hz
)
353 cs
= kzalloc(sizeof(*cs
), GFP_KERNEL
);
356 spi_set_ctldata(spi
, cs
);
359 mpc8xxx_spi
= spi_master_get_devdata(spi
->master
);
360 reg_base
= mpc8xxx_spi
->reg_base
;
362 pm_runtime_get_sync(mpc8xxx_spi
->dev
);
364 hw_mode
= cs
->hw_mode
; /* Save original settings */
365 cs
->hw_mode
= mpc8xxx_spi_read_reg(
366 ®_base
->csmode
[spi
->chip_select
]);
367 /* mask out bits we are going to set */
368 cs
->hw_mode
&= ~(CSMODE_CP_BEGIN_EDGECLK
| CSMODE_CI_INACTIVEHIGH
371 if (spi
->mode
& SPI_CPHA
)
372 cs
->hw_mode
|= CSMODE_CP_BEGIN_EDGECLK
;
373 if (spi
->mode
& SPI_CPOL
)
374 cs
->hw_mode
|= CSMODE_CI_INACTIVEHIGH
;
375 if (!(spi
->mode
& SPI_LSB_FIRST
))
376 cs
->hw_mode
|= CSMODE_REV
;
378 /* Handle the loop mode */
379 loop_mode
= mpc8xxx_spi_read_reg(®_base
->mode
);
380 loop_mode
&= ~SPMODE_LOOP
;
381 if (spi
->mode
& SPI_LOOP
)
382 loop_mode
|= SPMODE_LOOP
;
383 mpc8xxx_spi_write_reg(®_base
->mode
, loop_mode
);
385 fsl_espi_setup_transfer(spi
, NULL
);
387 pm_runtime_mark_last_busy(mpc8xxx_spi
->dev
);
388 pm_runtime_put_autosuspend(mpc8xxx_spi
->dev
);
393 static void fsl_espi_cleanup(struct spi_device
*spi
)
395 struct spi_mpc8xxx_cs
*cs
= spi_get_ctldata(spi
);
398 spi_set_ctldata(spi
, NULL
);
401 static void fsl_espi_cpu_irq(struct mpc8xxx_spi
*mspi
, u32 events
)
403 struct fsl_espi_reg
*reg_base
= mspi
->reg_base
;
405 /* We need handle RX first */
406 if (events
& SPIE_NE
) {
412 /* Spin until RX is done */
413 if (SPIE_RXCNT(events
) < min(4, mspi
->len
)) {
414 ret
= spin_event_timeout(
415 !(SPIE_RXCNT(events
=
416 mpc8xxx_spi_read_reg(®_base
->event
)) <
418 10000, 0); /* 10 msec */
421 "tired waiting for SPIE_RXCNT\n");
424 if (mspi
->len
>= 4) {
425 rx_data
= mpc8xxx_spi_read_reg(®_base
->receive
);
426 } else if (mspi
->len
<= 0) {
428 "unexpected RX(SPIE_NE) interrupt occurred,\n"
429 "(local rxlen %d bytes, reg rxlen %d bytes)\n",
430 min(4, mspi
->len
), SPIE_RXCNT(events
));
433 rx_nr_bytes
= mspi
->len
;
437 rx_data_8
= in_8((u8
*)®_base
->receive
);
438 rx_data
|= (rx_data_8
<< (tmp
* 8));
441 rx_data
<<= (4 - mspi
->len
) * 8;
444 mspi
->len
-= rx_nr_bytes
;
447 mspi
->get_rx(rx_data
, mspi
);
450 if (!(events
& SPIE_NF
)) {
453 /* spin until TX is done */
454 ret
= spin_event_timeout(((events
= mpc8xxx_spi_read_reg(
455 ®_base
->event
)) & SPIE_NF
), 1000, 0);
457 dev_err(mspi
->dev
, "tired waiting for SPIE_NF\n");
459 /* Clear the SPIE bits */
460 mpc8xxx_spi_write_reg(®_base
->event
, events
);
461 complete(&mspi
->done
);
466 /* Clear the events */
467 mpc8xxx_spi_write_reg(®_base
->event
, events
);
471 u32 word
= mspi
->get_tx(mspi
);
473 mpc8xxx_spi_write_reg(®_base
->transmit
, word
);
475 complete(&mspi
->done
);
479 static irqreturn_t
fsl_espi_irq(s32 irq
, void *context_data
)
481 struct mpc8xxx_spi
*mspi
= context_data
;
482 struct fsl_espi_reg
*reg_base
= mspi
->reg_base
;
483 irqreturn_t ret
= IRQ_NONE
;
486 /* Get interrupt events(tx/rx) */
487 events
= mpc8xxx_spi_read_reg(®_base
->event
);
491 dev_vdbg(mspi
->dev
, "%s: events %x\n", __func__
, events
);
493 fsl_espi_cpu_irq(mspi
, events
);
499 static int fsl_espi_runtime_suspend(struct device
*dev
)
501 struct spi_master
*master
= dev_get_drvdata(dev
);
502 struct mpc8xxx_spi
*mpc8xxx_spi
= spi_master_get_devdata(master
);
503 struct fsl_espi_reg
*reg_base
= mpc8xxx_spi
->reg_base
;
506 regval
= mpc8xxx_spi_read_reg(®_base
->mode
);
507 regval
&= ~SPMODE_ENABLE
;
508 mpc8xxx_spi_write_reg(®_base
->mode
, regval
);
513 static int fsl_espi_runtime_resume(struct device
*dev
)
515 struct spi_master
*master
= dev_get_drvdata(dev
);
516 struct mpc8xxx_spi
*mpc8xxx_spi
= spi_master_get_devdata(master
);
517 struct fsl_espi_reg
*reg_base
= mpc8xxx_spi
->reg_base
;
520 regval
= mpc8xxx_spi_read_reg(®_base
->mode
);
521 regval
|= SPMODE_ENABLE
;
522 mpc8xxx_spi_write_reg(®_base
->mode
, regval
);
528 static size_t fsl_espi_max_message_size(struct spi_device
*spi
)
530 return SPCOM_TRANLEN_MAX
;
533 static struct spi_master
* fsl_espi_probe(struct device
*dev
,
534 struct resource
*mem
, unsigned int irq
)
536 struct fsl_spi_platform_data
*pdata
= dev_get_platdata(dev
);
537 struct spi_master
*master
;
538 struct mpc8xxx_spi
*mpc8xxx_spi
;
539 struct fsl_espi_reg
*reg_base
;
540 struct device_node
*nc
;
545 master
= spi_alloc_master(dev
, sizeof(struct mpc8xxx_spi
));
551 dev_set_drvdata(dev
, master
);
553 mpc8xxx_spi_probe(dev
, mem
, irq
);
555 master
->bits_per_word_mask
= SPI_BPW_RANGE_MASK(4, 16);
556 master
->setup
= fsl_espi_setup
;
557 master
->cleanup
= fsl_espi_cleanup
;
558 master
->transfer_one_message
= fsl_espi_do_one_msg
;
559 master
->auto_runtime_pm
= true;
560 master
->max_message_size
= fsl_espi_max_message_size
;
562 mpc8xxx_spi
= spi_master_get_devdata(master
);
564 mpc8xxx_spi
->local_buf
=
565 devm_kmalloc(dev
, SPCOM_TRANLEN_MAX
, GFP_KERNEL
);
566 if (!mpc8xxx_spi
->local_buf
) {
571 mpc8xxx_spi
->reg_base
= devm_ioremap_resource(dev
, mem
);
572 if (IS_ERR(mpc8xxx_spi
->reg_base
)) {
573 ret
= PTR_ERR(mpc8xxx_spi
->reg_base
);
577 reg_base
= mpc8xxx_spi
->reg_base
;
579 /* Register for SPI Interrupt */
580 ret
= devm_request_irq(dev
, mpc8xxx_spi
->irq
, fsl_espi_irq
,
581 0, "fsl_espi", mpc8xxx_spi
);
585 if (mpc8xxx_spi
->flags
& SPI_QE_CPU_MODE
) {
586 mpc8xxx_spi
->rx_shift
= 16;
587 mpc8xxx_spi
->tx_shift
= 24;
590 /* SPI controller initializations */
591 mpc8xxx_spi_write_reg(®_base
->mode
, 0);
592 mpc8xxx_spi_write_reg(®_base
->mask
, 0);
593 mpc8xxx_spi_write_reg(®_base
->command
, 0);
594 mpc8xxx_spi_write_reg(®_base
->event
, 0xffffffff);
596 /* Init eSPI CS mode register */
597 for_each_available_child_of_node(master
->dev
.of_node
, nc
) {
598 /* get chip select */
599 prop
= of_get_property(nc
, "reg", &len
);
600 if (!prop
|| len
< sizeof(*prop
))
602 i
= be32_to_cpup(prop
);
603 if (i
< 0 || i
>= pdata
->max_chipselect
)
606 csmode
= CSMODE_INIT_VAL
;
607 /* check if CSBEF is set in device tree */
608 prop
= of_get_property(nc
, "fsl,csbef", &len
);
609 if (prop
&& len
>= sizeof(*prop
)) {
610 csmode
&= ~(CSMODE_BEF(0xf));
611 csmode
|= CSMODE_BEF(be32_to_cpup(prop
));
613 /* check if CSAFT is set in device tree */
614 prop
= of_get_property(nc
, "fsl,csaft", &len
);
615 if (prop
&& len
>= sizeof(*prop
)) {
616 csmode
&= ~(CSMODE_AFT(0xf));
617 csmode
|= CSMODE_AFT(be32_to_cpup(prop
));
619 mpc8xxx_spi_write_reg(®_base
->csmode
[i
], csmode
);
621 dev_info(dev
, "cs=%d, init_csmode=0x%x\n", i
, csmode
);
624 /* Enable SPI interface */
625 regval
= pdata
->initial_spmode
| SPMODE_INIT_VAL
| SPMODE_ENABLE
;
627 mpc8xxx_spi_write_reg(®_base
->mode
, regval
);
629 pm_runtime_set_autosuspend_delay(dev
, AUTOSUSPEND_TIMEOUT
);
630 pm_runtime_use_autosuspend(dev
);
631 pm_runtime_set_active(dev
);
632 pm_runtime_enable(dev
);
633 pm_runtime_get_sync(dev
);
635 ret
= devm_spi_register_master(dev
, master
);
639 dev_info(dev
, "at 0x%p (irq = %d)\n", reg_base
, mpc8xxx_spi
->irq
);
641 pm_runtime_mark_last_busy(dev
);
642 pm_runtime_put_autosuspend(dev
);
647 pm_runtime_put_noidle(dev
);
648 pm_runtime_disable(dev
);
649 pm_runtime_set_suspended(dev
);
651 spi_master_put(master
);
656 static int of_fsl_espi_get_chipselects(struct device
*dev
)
658 struct device_node
*np
= dev
->of_node
;
659 struct fsl_spi_platform_data
*pdata
= dev_get_platdata(dev
);
663 prop
= of_get_property(np
, "fsl,espi-num-chipselects", &len
);
664 if (!prop
|| len
< sizeof(*prop
)) {
665 dev_err(dev
, "No 'fsl,espi-num-chipselects' property\n");
669 pdata
->max_chipselect
= *prop
;
670 pdata
->cs_control
= NULL
;
675 static int of_fsl_espi_probe(struct platform_device
*ofdev
)
677 struct device
*dev
= &ofdev
->dev
;
678 struct device_node
*np
= ofdev
->dev
.of_node
;
679 struct spi_master
*master
;
684 ret
= of_mpc8xxx_spi_probe(ofdev
);
688 ret
= of_fsl_espi_get_chipselects(dev
);
692 ret
= of_address_to_resource(np
, 0, &mem
);
696 irq
= irq_of_parse_and_map(np
, 0);
702 master
= fsl_espi_probe(dev
, &mem
, irq
);
703 if (IS_ERR(master
)) {
704 ret
= PTR_ERR(master
);
714 static int of_fsl_espi_remove(struct platform_device
*dev
)
716 pm_runtime_disable(&dev
->dev
);
721 #ifdef CONFIG_PM_SLEEP
722 static int of_fsl_espi_suspend(struct device
*dev
)
724 struct spi_master
*master
= dev_get_drvdata(dev
);
727 ret
= spi_master_suspend(master
);
729 dev_warn(dev
, "cannot suspend master\n");
733 ret
= pm_runtime_force_suspend(dev
);
740 static int of_fsl_espi_resume(struct device
*dev
)
742 struct fsl_spi_platform_data
*pdata
= dev_get_platdata(dev
);
743 struct spi_master
*master
= dev_get_drvdata(dev
);
744 struct mpc8xxx_spi
*mpc8xxx_spi
;
745 struct fsl_espi_reg
*reg_base
;
749 mpc8xxx_spi
= spi_master_get_devdata(master
);
750 reg_base
= mpc8xxx_spi
->reg_base
;
752 /* SPI controller initializations */
753 mpc8xxx_spi_write_reg(®_base
->mode
, 0);
754 mpc8xxx_spi_write_reg(®_base
->mask
, 0);
755 mpc8xxx_spi_write_reg(®_base
->command
, 0);
756 mpc8xxx_spi_write_reg(®_base
->event
, 0xffffffff);
758 /* Init eSPI CS mode register */
759 for (i
= 0; i
< pdata
->max_chipselect
; i
++)
760 mpc8xxx_spi_write_reg(®_base
->csmode
[i
], CSMODE_INIT_VAL
);
762 /* Enable SPI interface */
763 regval
= pdata
->initial_spmode
| SPMODE_INIT_VAL
| SPMODE_ENABLE
;
765 mpc8xxx_spi_write_reg(®_base
->mode
, regval
);
767 ret
= pm_runtime_force_resume(dev
);
771 return spi_master_resume(master
);
773 #endif /* CONFIG_PM_SLEEP */
775 static const struct dev_pm_ops espi_pm
= {
776 SET_RUNTIME_PM_OPS(fsl_espi_runtime_suspend
,
777 fsl_espi_runtime_resume
, NULL
)
778 SET_SYSTEM_SLEEP_PM_OPS(of_fsl_espi_suspend
, of_fsl_espi_resume
)
781 static const struct of_device_id of_fsl_espi_match
[] = {
782 { .compatible
= "fsl,mpc8536-espi" },
785 MODULE_DEVICE_TABLE(of
, of_fsl_espi_match
);
787 static struct platform_driver fsl_espi_driver
= {
790 .of_match_table
= of_fsl_espi_match
,
793 .probe
= of_fsl_espi_probe
,
794 .remove
= of_fsl_espi_remove
,
796 module_platform_driver(fsl_espi_driver
);
798 MODULE_AUTHOR("Mingkai Hu");
799 MODULE_DESCRIPTION("Enhanced Freescale SPI Driver");
800 MODULE_LICENSE("GPL");