bcma: connect the bcma bus suspend/resume to the bcma driver suspend/resume
[linux-3.10.git] / drivers / bcma / host_soc.c
1 /*
2  * Broadcom specific AMBA
3  * System on Chip (SoC) Host
4  *
5  * Licensed under the GNU/GPL. See COPYING for details.
6  */
7
8 #include "bcma_private.h"
9 #include "scan.h"
10 #include <linux/bcma/bcma.h>
11 #include <linux/bcma/bcma_soc.h>
12
13 static u8 bcma_host_soc_read8(struct bcma_device *core, u16 offset)
14 {
15         return readb(core->io_addr + offset);
16 }
17
18 static u16 bcma_host_soc_read16(struct bcma_device *core, u16 offset)
19 {
20         return readw(core->io_addr + offset);
21 }
22
23 static u32 bcma_host_soc_read32(struct bcma_device *core, u16 offset)
24 {
25         return readl(core->io_addr + offset);
26 }
27
28 static void bcma_host_soc_write8(struct bcma_device *core, u16 offset,
29                                  u8 value)
30 {
31         writeb(value, core->io_addr + offset);
32 }
33
34 static void bcma_host_soc_write16(struct bcma_device *core, u16 offset,
35                                  u16 value)
36 {
37         writew(value, core->io_addr + offset);
38 }
39
40 static void bcma_host_soc_write32(struct bcma_device *core, u16 offset,
41                                  u32 value)
42 {
43         writel(value, core->io_addr + offset);
44 }
45
46 #ifdef CONFIG_BCMA_BLOCKIO
47 static void bcma_host_soc_block_read(struct bcma_device *core, void *buffer,
48                                      size_t count, u16 offset, u8 reg_width)
49 {
50         void __iomem *addr = core->io_addr + offset;
51
52         switch (reg_width) {
53         case sizeof(u8): {
54                 u8 *buf = buffer;
55
56                 while (count) {
57                         *buf = __raw_readb(addr);
58                         buf++;
59                         count--;
60                 }
61                 break;
62         }
63         case sizeof(u16): {
64                 __le16 *buf = buffer;
65
66                 WARN_ON(count & 1);
67                 while (count) {
68                         *buf = (__force __le16)__raw_readw(addr);
69                         buf++;
70                         count -= 2;
71                 }
72                 break;
73         }
74         case sizeof(u32): {
75                 __le32 *buf = buffer;
76
77                 WARN_ON(count & 3);
78                 while (count) {
79                         *buf = (__force __le32)__raw_readl(addr);
80                         buf++;
81                         count -= 4;
82                 }
83                 break;
84         }
85         default:
86                 WARN_ON(1);
87         }
88 }
89
90 static void bcma_host_soc_block_write(struct bcma_device *core,
91                                       const void *buffer,
92                                       size_t count, u16 offset, u8 reg_width)
93 {
94         void __iomem *addr = core->io_addr + offset;
95
96         switch (reg_width) {
97         case sizeof(u8): {
98                 const u8 *buf = buffer;
99
100                 while (count) {
101                         __raw_writeb(*buf, addr);
102                         buf++;
103                         count--;
104                 }
105                 break;
106         }
107         case sizeof(u16): {
108                 const __le16 *buf = buffer;
109
110                 WARN_ON(count & 1);
111                 while (count) {
112                         __raw_writew((__force u16)(*buf), addr);
113                         buf++;
114                         count -= 2;
115                 }
116                 break;
117         }
118         case sizeof(u32): {
119                 const __le32 *buf = buffer;
120
121                 WARN_ON(count & 3);
122                 while (count) {
123                         __raw_writel((__force u32)(*buf), addr);
124                         buf++;
125                         count -= 4;
126                 }
127                 break;
128         }
129         default:
130                 WARN_ON(1);
131         }
132 }
133 #endif /* CONFIG_BCMA_BLOCKIO */
134
135 static u32 bcma_host_soc_aread32(struct bcma_device *core, u16 offset)
136 {
137         return readl(core->io_wrap + offset);
138 }
139
140 static void bcma_host_soc_awrite32(struct bcma_device *core, u16 offset,
141                                   u32 value)
142 {
143         writel(value, core->io_wrap + offset);
144 }
145
146 const struct bcma_host_ops bcma_host_soc_ops = {
147         .read8          = bcma_host_soc_read8,
148         .read16         = bcma_host_soc_read16,
149         .read32         = bcma_host_soc_read32,
150         .write8         = bcma_host_soc_write8,
151         .write16        = bcma_host_soc_write16,
152         .write32        = bcma_host_soc_write32,
153 #ifdef CONFIG_BCMA_BLOCKIO
154         .block_read     = bcma_host_soc_block_read,
155         .block_write    = bcma_host_soc_block_write,
156 #endif
157         .aread32        = bcma_host_soc_aread32,
158         .awrite32       = bcma_host_soc_awrite32,
159 };
160
161 int __init bcma_host_soc_register(struct bcma_soc *soc)
162 {
163         struct bcma_bus *bus = &soc->bus;
164         int err;
165
166         /* iomap only first core. We have to read some register on this core
167          * to scan the bus.
168          */
169         bus->mmio = ioremap_nocache(BCMA_ADDR_BASE, BCMA_CORE_SIZE * 1);
170         if (!bus->mmio)
171                 return -ENOMEM;
172
173         /* Host specific */
174         bus->hosttype = BCMA_HOSTTYPE_SOC;
175         bus->ops = &bcma_host_soc_ops;
176
177         /* Register */
178         err = bcma_bus_early_register(bus, &soc->core_cc, &soc->core_mips);
179         if (err)
180                 iounmap(bus->mmio);
181
182         return err;
183 }