Merge branch 'worklym' into jh7110_dev_5.15
[platform/kernel/linux-starfive.git] / drivers / ssb / host_soc.c
1 /*
2  * Sonics Silicon Backplane SoC host related functions.
3  * Subsystem core
4  *
5  * Copyright 2005, Broadcom Corporation
6  * Copyright 2006, 2007, Michael Buesch <m@bues.ch>
7  *
8  * Licensed under the GNU/GPL. See COPYING for details.
9  */
10
11 #include "ssb_private.h"
12
13 #include <linux/bcm47xx_nvram.h>
14 #include <linux/ssb/ssb.h>
15
16 static u8 ssb_host_soc_read8(struct ssb_device *dev, u16 offset)
17 {
18         struct ssb_bus *bus = dev->bus;
19
20         offset += dev->core_index * SSB_CORE_SIZE;
21         return readb(bus->mmio + offset);
22 }
23
24 static u16 ssb_host_soc_read16(struct ssb_device *dev, u16 offset)
25 {
26         struct ssb_bus *bus = dev->bus;
27
28         offset += dev->core_index * SSB_CORE_SIZE;
29         return readw(bus->mmio + offset);
30 }
31
32 static u32 ssb_host_soc_read32(struct ssb_device *dev, u16 offset)
33 {
34         struct ssb_bus *bus = dev->bus;
35
36         offset += dev->core_index * SSB_CORE_SIZE;
37         return readl(bus->mmio + offset);
38 }
39
40 #ifdef CONFIG_SSB_BLOCKIO
41 static void ssb_host_soc_block_read(struct ssb_device *dev, void *buffer,
42                                     size_t count, u16 offset, u8 reg_width)
43 {
44         struct ssb_bus *bus = dev->bus;
45         void __iomem *addr;
46
47         offset += dev->core_index * SSB_CORE_SIZE;
48         addr = bus->mmio + offset;
49
50         switch (reg_width) {
51         case sizeof(u8): {
52                 u8 *buf = buffer;
53
54                 while (count) {
55                         *buf = __raw_readb(addr);
56                         buf++;
57                         count--;
58                 }
59                 break;
60         }
61         case sizeof(u16): {
62                 __le16 *buf = buffer;
63
64                 WARN_ON(count & 1);
65                 while (count) {
66                         *buf = (__force __le16)__raw_readw(addr);
67                         buf++;
68                         count -= 2;
69                 }
70                 break;
71         }
72         case sizeof(u32): {
73                 __le32 *buf = buffer;
74
75                 WARN_ON(count & 3);
76                 while (count) {
77                         *buf = (__force __le32)__raw_readl(addr);
78                         buf++;
79                         count -= 4;
80                 }
81                 break;
82         }
83         default:
84                 WARN_ON(1);
85         }
86 }
87 #endif /* CONFIG_SSB_BLOCKIO */
88
89 static void ssb_host_soc_write8(struct ssb_device *dev, u16 offset, u8 value)
90 {
91         struct ssb_bus *bus = dev->bus;
92
93         offset += dev->core_index * SSB_CORE_SIZE;
94         writeb(value, bus->mmio + offset);
95 }
96
97 static void ssb_host_soc_write16(struct ssb_device *dev, u16 offset, u16 value)
98 {
99         struct ssb_bus *bus = dev->bus;
100
101         offset += dev->core_index * SSB_CORE_SIZE;
102         writew(value, bus->mmio + offset);
103 }
104
105 static void ssb_host_soc_write32(struct ssb_device *dev, u16 offset, u32 value)
106 {
107         struct ssb_bus *bus = dev->bus;
108
109         offset += dev->core_index * SSB_CORE_SIZE;
110         writel(value, bus->mmio + offset);
111 }
112
113 #ifdef CONFIG_SSB_BLOCKIO
114 static void ssb_host_soc_block_write(struct ssb_device *dev, const void *buffer,
115                                      size_t count, u16 offset, u8 reg_width)
116 {
117         struct ssb_bus *bus = dev->bus;
118         void __iomem *addr;
119
120         offset += dev->core_index * SSB_CORE_SIZE;
121         addr = bus->mmio + offset;
122
123         switch (reg_width) {
124         case sizeof(u8): {
125                 const u8 *buf = buffer;
126
127                 while (count) {
128                         __raw_writeb(*buf, addr);
129                         buf++;
130                         count--;
131                 }
132                 break;
133         }
134         case sizeof(u16): {
135                 const __le16 *buf = buffer;
136
137                 WARN_ON(count & 1);
138                 while (count) {
139                         __raw_writew((__force u16)(*buf), addr);
140                         buf++;
141                         count -= 2;
142                 }
143                 break;
144         }
145         case sizeof(u32): {
146                 const __le32 *buf = buffer;
147
148                 WARN_ON(count & 3);
149                 while (count) {
150                         __raw_writel((__force u32)(*buf), addr);
151                         buf++;
152                         count -= 4;
153                 }
154                 break;
155         }
156         default:
157                 WARN_ON(1);
158         }
159 }
160 #endif /* CONFIG_SSB_BLOCKIO */
161
162 /* Ops for the plain SSB bus without a host-device (no PCI or PCMCIA). */
163 const struct ssb_bus_ops ssb_host_soc_ops = {
164         .read8          = ssb_host_soc_read8,
165         .read16         = ssb_host_soc_read16,
166         .read32         = ssb_host_soc_read32,
167         .write8         = ssb_host_soc_write8,
168         .write16        = ssb_host_soc_write16,
169         .write32        = ssb_host_soc_write32,
170 #ifdef CONFIG_SSB_BLOCKIO
171         .block_read     = ssb_host_soc_block_read,
172         .block_write    = ssb_host_soc_block_write,
173 #endif
174 };
175
176 int ssb_host_soc_get_invariants(struct ssb_bus *bus,
177                                 struct ssb_init_invariants *iv)
178 {
179         char buf[20];
180         int len, err;
181
182         /* Fill boardinfo structure */
183         memset(&iv->boardinfo, 0, sizeof(struct ssb_boardinfo));
184
185         len = bcm47xx_nvram_getenv("boardvendor", buf, sizeof(buf));
186         if (len > 0) {
187                 err = kstrtou16(strim(buf), 0, &iv->boardinfo.vendor);
188                 if (err)
189                         pr_warn("Couldn't parse nvram board vendor entry with value \"%s\"\n",
190                                 buf);
191         }
192         if (!iv->boardinfo.vendor)
193                 iv->boardinfo.vendor = SSB_BOARDVENDOR_BCM;
194
195         len = bcm47xx_nvram_getenv("boardtype", buf, sizeof(buf));
196         if (len > 0) {
197                 err = kstrtou16(strim(buf), 0, &iv->boardinfo.type);
198                 if (err)
199                         pr_warn("Couldn't parse nvram board type entry with value \"%s\"\n",
200                                 buf);
201         }
202
203         memset(&iv->sprom, 0, sizeof(struct ssb_sprom));
204         ssb_fill_sprom_with_fallback(bus, &iv->sprom);
205
206         if (bcm47xx_nvram_getenv("cardbus", buf, sizeof(buf)) >= 0)
207                 iv->has_cardbus_slot = !!simple_strtoul(buf, NULL, 10);
208
209         return 0;
210 }