OpenWrt – Blame information for rev 4

Subversion Repositories:
Rev:
Rev Author Line No. Line
4 office 1 /*
2 * B53 register access through memory mapped registers
3 *
4 * Copyright (C) 2012-2013 Jonas Gorski <jogo@openwrt.org>
5 *
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18  
19 #include <linux/kernel.h>
20 #include <linux/module.h>
21 #include <linux/platform_device.h>
22 #include <linux/platform_data/b53.h>
23  
24 #include "b53_priv.h"
25  
26 static int b53_mmap_read8(struct b53_device *dev, u8 page, u8 reg, u8 *val)
27 {
28 u8 __iomem *regs = dev->priv;
29  
30 *val = readb(regs + (page << 8) + reg);
31  
32 return 0;
33 }
34  
35 static int b53_mmap_read16(struct b53_device *dev, u8 page, u8 reg, u16 *val)
36 {
37 u8 __iomem *regs = dev->priv;
38  
39 if (WARN_ON(reg % 2))
40 return -EINVAL;
41  
42 if (dev->pdata && dev->pdata->big_endian)
43 *val = readw_be(regs + (page << 8) + reg);
44 else
45 *val = readw(regs + (page << 8) + reg);
46  
47 return 0;
48 }
49  
50 static int b53_mmap_read32(struct b53_device *dev, u8 page, u8 reg, u32 *val)
51 {
52 u8 __iomem *regs = dev->priv;
53  
54 if (WARN_ON(reg % 4))
55 return -EINVAL;
56  
57 if (dev->pdata && dev->pdata->big_endian)
58 *val = readl_be(regs + (page << 8) + reg);
59 else
60 *val = readl(regs + (page << 8) + reg);
61  
62 return 0;
63 }
64  
65 static int b53_mmap_read48(struct b53_device *dev, u8 page, u8 reg, u64 *val)
66 {
67 if (WARN_ON(reg % 2))
68 return -EINVAL;
69  
70 if (reg % 4) {
71 u16 lo;
72 u32 hi;
73  
74 b53_mmap_read16(dev, page, reg, &lo);
75 b53_mmap_read32(dev, page, reg + 2, &hi);
76  
77 *val = ((u64)hi << 16) | lo;
78 } else {
79 u32 lo;
80 u16 hi;
81  
82 b53_mmap_read32(dev, page, reg, &lo);
83 b53_mmap_read16(dev, page, reg + 4, &hi);
84  
85 *val = ((u64)hi << 32) | lo;
86 }
87  
88 return 0;
89 }
90  
91 static int b53_mmap_read64(struct b53_device *dev, u8 page, u8 reg, u64 *val)
92 {
93 u32 hi, lo;
94  
95 if (WARN_ON(reg % 4))
96 return -EINVAL;
97  
98 b53_mmap_read32(dev, page, reg, &lo);
99 b53_mmap_read32(dev, page, reg + 4, &hi);
100  
101 *val = ((u64)hi << 32) | lo;
102  
103 return 0;
104 }
105  
106 static int b53_mmap_write8(struct b53_device *dev, u8 page, u8 reg, u8 value)
107 {
108 u8 __iomem *regs = dev->priv;
109  
110 writeb(value, regs + (page << 8) + reg);
111  
112 return 0;
113 }
114  
115 static int b53_mmap_write16(struct b53_device *dev, u8 page, u8 reg,
116 u16 value)
117 {
118 u8 __iomem *regs = dev->priv;
119  
120 if (WARN_ON(reg % 2))
121 return -EINVAL;
122  
123 if (dev->pdata && dev->pdata->big_endian)
124 writew_be(value, regs + (page << 8) + reg);
125 else
126 writew(value, regs + (page << 8) + reg);
127  
128 return 0;
129 }
130  
131 static int b53_mmap_write32(struct b53_device *dev, u8 page, u8 reg,
132 u32 value)
133 {
134 u8 __iomem *regs = dev->priv;
135  
136 if (WARN_ON(reg % 4))
137 return -EINVAL;
138  
139 if (dev->pdata && dev->pdata->big_endian)
140 writel_be(value, regs + (page << 8) + reg);
141 else
142 writel(value, regs + (page << 8) + reg);
143  
144 return 0;
145 }
146  
147 static int b53_mmap_write48(struct b53_device *dev, u8 page, u8 reg,
148 u64 value)
149 {
150 if (WARN_ON(reg % 2))
151 return -EINVAL;
152  
153 if (reg % 4) {
154 u32 hi = (u32)(value >> 16);
155 u16 lo = (u16)value;
156  
157 b53_mmap_write16(dev, page, reg, lo);
158 b53_mmap_write32(dev, page, reg + 2, hi);
159 } else {
160 u16 hi = (u16)(value >> 32);
161 u32 lo = (u32)value;
162  
163 b53_mmap_write32(dev, page, reg, lo);
164 b53_mmap_write16(dev, page, reg + 4, hi);
165 }
166  
167 return 0;
168 }
169  
170 static int b53_mmap_write64(struct b53_device *dev, u8 page, u8 reg,
171 u64 value)
172 {
173 u32 hi, lo;
174  
175 hi = (u32)(value >> 32);
176 lo = (u32)value;
177  
178 if (WARN_ON(reg % 4))
179 return -EINVAL;
180  
181 b53_mmap_write32(dev, page, reg, lo);
182 b53_mmap_write32(dev, page, reg + 4, hi);
183  
184 return 0;
185 }
186  
187 static struct b53_io_ops b53_mmap_ops = {
188 .read8 = b53_mmap_read8,
189 .read16 = b53_mmap_read16,
190 .read32 = b53_mmap_read32,
191 .read48 = b53_mmap_read48,
192 .read64 = b53_mmap_read64,
193 .write8 = b53_mmap_write8,
194 .write16 = b53_mmap_write16,
195 .write32 = b53_mmap_write32,
196 .write48 = b53_mmap_write48,
197 .write64 = b53_mmap_write64,
198 };
199  
200 static int b53_mmap_probe(struct platform_device *pdev)
201 {
202 struct b53_platform_data *pdata = pdev->dev.platform_data;
203 struct b53_device *dev;
204  
205 if (!pdata)
206 return -EINVAL;
207  
208 dev = b53_switch_alloc(&pdev->dev, &b53_mmap_ops, pdata->regs);
209 if (!dev)
210 return -ENOMEM;
211  
212 if (pdata)
213 dev->pdata = pdata;
214  
215 platform_set_drvdata(pdev, dev);
216  
217 return b53_switch_register(dev);
218 }
219  
220 static int b53_mmap_remove(struct platform_device *pdev)
221 {
222 struct b53_device *dev = platform_get_drvdata(pdev);
223  
224 if (dev)
225 b53_switch_remove(dev);
226  
227 return 0;
228 }
229  
230 static struct platform_driver b53_mmap_driver = {
231 .probe = b53_mmap_probe,
232 .remove = b53_mmap_remove,
233 .driver = {
234 .name = "b53-switch",
235 },
236 };
237  
238 module_platform_driver(b53_mmap_driver);
239 MODULE_AUTHOR("Jonas Gorski <jogo@openwrt.org>");
240 MODULE_DESCRIPTION("B53 MMAP access driver");
241 MODULE_LICENSE("Dual BSD/GPL");