]> git.sur5r.net Git - u-boot/blob - drivers/spi/fdt_spi.c
Merge branch 'u-boot-imx/master' into 'u-boot-arm/master'
[u-boot] / drivers / spi / fdt_spi.c
1 /*
2  * Common fdt based SPI driver front end
3  *
4  * Copyright (c) 2013 NVIDIA Corporation
5  *
6  * See file CREDITS for list of people who contributed to this
7  * project.
8  *
9  * This software is licensed under the terms of the GNU General Public
10  * License version 2, as published by the Free Software Foundation, and
11  * may be copied, distributed, and modified under those terms.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  */
23
24 #include <common.h>
25 #include <malloc.h>
26 #include <asm/io.h>
27 #include <asm/gpio.h>
28 #include <asm/arch/clock.h>
29 #include <asm/arch-tegra/clk_rst.h>
30 #include <asm/arch-tegra20/tegra20_sflash.h>
31 #include <asm/arch-tegra20/tegra20_slink.h>
32 #include <asm/arch-tegra114/tegra114_spi.h>
33 #include <spi.h>
34 #include <fdtdec.h>
35
36 DECLARE_GLOBAL_DATA_PTR;
37
38 struct fdt_spi_driver {
39         int compat;
40         int max_ctrls;
41         int (*init)(int *node_list, int count);
42         int (*claim_bus)(struct spi_slave *slave);
43         int (*release_bus)(struct spi_slave *slave);
44         int (*cs_is_valid)(unsigned int bus, unsigned int cs);
45         struct spi_slave *(*setup_slave)(unsigned int bus, unsigned int cs,
46                                         unsigned int max_hz, unsigned int mode);
47         void (*free_slave)(struct spi_slave *slave);
48         void (*cs_activate)(struct spi_slave *slave);
49         void (*cs_deactivate)(struct spi_slave *slave);
50         int (*xfer)(struct spi_slave *slave, unsigned int bitlen,
51                     const void *data_out, void *data_in, unsigned long flags);
52 };
53
54 static struct fdt_spi_driver fdt_spi_drivers[] = {
55 #ifdef CONFIG_TEGRA20_SFLASH
56         {
57                 .compat         = COMPAT_NVIDIA_TEGRA20_SFLASH,
58                 .max_ctrls      = 1,
59                 .init           = tegra20_spi_init,
60                 .claim_bus      = tegra20_spi_claim_bus,
61                 .cs_is_valid    = tegra20_spi_cs_is_valid,
62                 .setup_slave    = tegra20_spi_setup_slave,
63                 .free_slave     = tegra20_spi_free_slave,
64                 .cs_activate    = tegra20_spi_cs_activate,
65                 .cs_deactivate  = tegra20_spi_cs_deactivate,
66                 .xfer           = tegra20_spi_xfer,
67         },
68 #endif
69 #ifdef CONFIG_TEGRA20_SLINK
70         {
71                 .compat         = COMPAT_NVIDIA_TEGRA20_SLINK,
72                 .max_ctrls      = CONFIG_TEGRA_SLINK_CTRLS,
73                 .init           = tegra30_spi_init,
74                 .claim_bus      = tegra30_spi_claim_bus,
75                 .cs_is_valid    = tegra30_spi_cs_is_valid,
76                 .setup_slave    = tegra30_spi_setup_slave,
77                 .free_slave     = tegra30_spi_free_slave,
78                 .cs_activate    = tegra30_spi_cs_activate,
79                 .cs_deactivate  = tegra30_spi_cs_deactivate,
80                 .xfer           = tegra30_spi_xfer,
81         },
82 #endif
83 #ifdef CONFIG_TEGRA114_SPI
84         {
85                 .compat         = COMPAT_NVIDIA_TEGRA114_SPI,
86                 .max_ctrls      = CONFIG_TEGRA114_SPI_CTRLS,
87                 .init           = tegra114_spi_init,
88                 .claim_bus      = tegra114_spi_claim_bus,
89                 .cs_is_valid    = tegra114_spi_cs_is_valid,
90                 .setup_slave    = tegra114_spi_setup_slave,
91                 .free_slave     = tegra114_spi_free_slave,
92                 .cs_activate    = tegra114_spi_cs_activate,
93                 .cs_deactivate  = tegra114_spi_cs_deactivate,
94                 .xfer           = tegra114_spi_xfer,
95         },
96 #endif
97 };
98
99 static struct fdt_spi_driver *driver;
100
101 int spi_cs_is_valid(unsigned int bus, unsigned int cs)
102 {
103         if (!driver)
104                 return 0;
105         else if (!driver->cs_is_valid)
106                 return 1;
107         else
108                 return driver->cs_is_valid(bus, cs);
109 }
110
111 struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
112                 unsigned int max_hz, unsigned int mode)
113 {
114         if (!driver || !driver->setup_slave)
115                 return NULL;
116
117         return driver->setup_slave(bus, cs, max_hz, mode);
118 }
119
120 void spi_free_slave(struct spi_slave *slave)
121 {
122         if (driver && driver->free_slave)
123                 return driver->free_slave(slave);
124 }
125
126 static int spi_init_driver(struct fdt_spi_driver *driver)
127 {
128         int count;
129         int node_list[driver->max_ctrls];
130
131         count = fdtdec_find_aliases_for_id(gd->fdt_blob, "spi",
132                                            driver->compat,
133                                            node_list,
134                                            driver->max_ctrls);
135         return driver->init(node_list, count);
136 }
137
138 void spi_init(void)
139 {
140         int i;
141
142         for (i = 0; i < ARRAY_SIZE(fdt_spi_drivers); i++) {
143                 driver = &fdt_spi_drivers[i];
144                 if (!spi_init_driver(driver))
145                         break;
146         }
147         if (i == ARRAY_SIZE(fdt_spi_drivers))
148                 driver = NULL;
149 }
150
151 int spi_claim_bus(struct spi_slave *slave)
152 {
153         if (!driver)
154                 return 1;
155         if (!driver->claim_bus)
156                 return 0;
157
158         return driver->claim_bus(slave);
159 }
160
161 void spi_release_bus(struct spi_slave *slave)
162 {
163         if (driver && driver->release_bus)
164                 driver->release_bus(slave);
165 }
166
167 void spi_cs_activate(struct spi_slave *slave)
168 {
169         if (driver && driver->cs_activate)
170                 driver->cs_activate(slave);
171 }
172
173 void spi_cs_deactivate(struct spi_slave *slave)
174 {
175         if (driver && driver->cs_deactivate)
176                 driver->cs_deactivate(slave);
177 }
178
179 int spi_xfer(struct spi_slave *slave, unsigned int bitlen,
180              const void *data_out, void *data_in, unsigned long flags)
181 {
182         if (!driver || !driver->xfer)
183                 return -1;
184
185         return driver->xfer(slave, bitlen, data_out, data_in, flags);
186 }