1 | // SPDX-License-Identifier: GPL-2.0 |
2 | #include <linux/module.h> |
3 | #include <linux/netdevice.h> |
4 | #include <linux/platform_device.h> |
5 | #include <linux/zorro.h> |
6 | #include <net/ax88796.h> |
7 | #include <asm/amigaints.h> |
8 | |
9 | #define ZORRO_PROD_INDIVIDUAL_COMPUTERS_X_SURF100 \ |
10 | ZORRO_ID(INDIVIDUAL_COMPUTERS, 0x64, 0) |
11 | |
12 | #define XS100_IRQSTATUS_BASE 0x40 |
13 | #define XS100_8390_BASE 0x800 |
14 | |
15 | /* Longword-access area. Translated to 2 16-bit access cycles by the |
16 | * X-Surf 100 FPGA |
17 | */ |
18 | #define XS100_8390_DATA32_BASE 0x8000 |
19 | #define XS100_8390_DATA32_SIZE 0x2000 |
20 | /* Sub-Areas for fast data register access; addresses relative to area begin */ |
21 | #define XS100_8390_DATA_READ32_BASE 0x0880 |
22 | #define XS100_8390_DATA_WRITE32_BASE 0x0C80 |
23 | #define XS100_8390_DATA_AREA_SIZE 0x80 |
24 | |
25 | /* force unsigned long back to 'void __iomem *' */ |
26 | #define ax_convert_addr(_a) ((void __force __iomem *)(_a)) |
27 | |
28 | #define ei_inb(_a) z_readb(ax_convert_addr(_a)) |
29 | #define ei_outb(_v, _a) z_writeb(_v, ax_convert_addr(_a)) |
30 | |
31 | #define ei_inw(_a) z_readw(ax_convert_addr(_a)) |
32 | #define ei_outw(_v, _a) z_writew(_v, ax_convert_addr(_a)) |
33 | |
34 | #define ei_inb_p(_a) ei_inb(_a) |
35 | #define ei_outb_p(_v, _a) ei_outb(_v, _a) |
36 | |
37 | /* define EI_SHIFT() to take into account our register offsets */ |
38 | #define EI_SHIFT(x) (ei_local->reg_offset[(x)]) |
39 | |
40 | /* Ensure we have our RCR base value */ |
41 | #define AX88796_PLATFORM |
42 | |
43 | #include "8390.h" |
44 | |
45 | /* from ne.c */ |
46 | #define NE_CMD EI_SHIFT(0x00) |
47 | #define NE_RESET EI_SHIFT(0x1f) |
48 | #define NE_DATAPORT EI_SHIFT(0x10) |
49 | |
50 | struct xsurf100_ax_plat_data { |
51 | struct ax_plat_data ax; |
52 | void __iomem *base_regs; |
53 | void __iomem *data_area; |
54 | }; |
55 | |
56 | static int is_xsurf100_network_irq(struct platform_device *pdev) |
57 | { |
58 | struct xsurf100_ax_plat_data *xs100 = dev_get_platdata(dev: &pdev->dev); |
59 | |
60 | return (readw(addr: xs100->base_regs + XS100_IRQSTATUS_BASE) & 0xaaaa) != 0; |
61 | } |
62 | |
63 | /* These functions guarantee that the iomem is accessed with 32 bit |
64 | * cycles only. z_memcpy_fromio / z_memcpy_toio don't |
65 | */ |
66 | static void z_memcpy_fromio32(void *dst, const void __iomem *src, size_t bytes) |
67 | { |
68 | while (bytes > 32) { |
69 | asm __volatile__ |
70 | ("movem.l (%0)+,%%d0-%%d7\n" |
71 | "movem.l %%d0-%%d7,(%1)\n" |
72 | "adda.l #32,%1" : "=a" (src), "=a" (dst) |
73 | : "0" (src), "1" (dst) : "d0" , "d1" , "d2" , "d3" , "d4" , |
74 | "d5" , "d6" , "d7" , "memory" ); |
75 | bytes -= 32; |
76 | } |
77 | while (bytes) { |
78 | *(uint32_t *)dst = z_readl(src); |
79 | src += 4; |
80 | dst += 4; |
81 | bytes -= 4; |
82 | } |
83 | } |
84 | |
85 | static void z_memcpy_toio32(void __iomem *dst, const void *src, size_t bytes) |
86 | { |
87 | while (bytes) { |
88 | z_writel(*(const uint32_t *)src, dst); |
89 | src += 4; |
90 | dst += 4; |
91 | bytes -= 4; |
92 | } |
93 | } |
94 | |
95 | static void xs100_write(struct net_device *dev, const void *src, |
96 | unsigned int count) |
97 | { |
98 | struct ei_device *ei_local = netdev_priv(dev); |
99 | struct platform_device *pdev = to_platform_device(dev->dev.parent); |
100 | struct xsurf100_ax_plat_data *xs100 = dev_get_platdata(dev: &pdev->dev); |
101 | |
102 | /* copy whole blocks */ |
103 | while (count > XS100_8390_DATA_AREA_SIZE) { |
104 | z_memcpy_toio32(dst: xs100->data_area + |
105 | XS100_8390_DATA_WRITE32_BASE, src, |
106 | XS100_8390_DATA_AREA_SIZE); |
107 | src += XS100_8390_DATA_AREA_SIZE; |
108 | count -= XS100_8390_DATA_AREA_SIZE; |
109 | } |
110 | /* copy whole dwords */ |
111 | z_memcpy_toio32(dst: xs100->data_area + XS100_8390_DATA_WRITE32_BASE, |
112 | src, bytes: count & ~3); |
113 | src += count & ~3; |
114 | if (count & 2) { |
115 | ei_outw(*(uint16_t *)src, ei_local->mem + NE_DATAPORT); |
116 | src += 2; |
117 | } |
118 | if (count & 1) |
119 | ei_outb(*(uint8_t *)src, ei_local->mem + NE_DATAPORT); |
120 | } |
121 | |
122 | static void xs100_read(struct net_device *dev, void *dst, unsigned int count) |
123 | { |
124 | struct ei_device *ei_local = netdev_priv(dev); |
125 | struct platform_device *pdev = to_platform_device(dev->dev.parent); |
126 | struct xsurf100_ax_plat_data *xs100 = dev_get_platdata(dev: &pdev->dev); |
127 | |
128 | /* copy whole blocks */ |
129 | while (count > XS100_8390_DATA_AREA_SIZE) { |
130 | z_memcpy_fromio32(dst, src: xs100->data_area + |
131 | XS100_8390_DATA_READ32_BASE, |
132 | XS100_8390_DATA_AREA_SIZE); |
133 | dst += XS100_8390_DATA_AREA_SIZE; |
134 | count -= XS100_8390_DATA_AREA_SIZE; |
135 | } |
136 | /* copy whole dwords */ |
137 | z_memcpy_fromio32(dst, src: xs100->data_area + XS100_8390_DATA_READ32_BASE, |
138 | bytes: count & ~3); |
139 | dst += count & ~3; |
140 | if (count & 2) { |
141 | *(uint16_t *)dst = ei_inw(ei_local->mem + NE_DATAPORT); |
142 | dst += 2; |
143 | } |
144 | if (count & 1) |
145 | *(uint8_t *)dst = ei_inb(ei_local->mem + NE_DATAPORT); |
146 | } |
147 | |
148 | /* Block input and output, similar to the Crynwr packet driver. If |
149 | * you are porting to a new ethercard, look at the packet driver |
150 | * source for hints. The NEx000 doesn't share the on-board packet |
151 | * memory -- you have to put the packet out through the "remote DMA" |
152 | * dataport using ei_outb. |
153 | */ |
154 | static void xs100_block_input(struct net_device *dev, int count, |
155 | struct sk_buff *skb, int ring_offset) |
156 | { |
157 | struct ei_device *ei_local = netdev_priv(dev); |
158 | void __iomem *nic_base = ei_local->mem; |
159 | char *buf = skb->data; |
160 | |
161 | if (ei_local->dmaing) { |
162 | netdev_err(dev, |
163 | format: "DMAing conflict in %s [DMAstat:%d][irqlock:%d]\n" , |
164 | __func__, |
165 | ei_local->dmaing, ei_local->irqlock); |
166 | return; |
167 | } |
168 | |
169 | ei_local->dmaing |= 0x01; |
170 | |
171 | ei_outb(E8390_NODMA + E8390_PAGE0 + E8390_START, nic_base + NE_CMD); |
172 | ei_outb(count & 0xff, nic_base + EN0_RCNTLO); |
173 | ei_outb(count >> 8, nic_base + EN0_RCNTHI); |
174 | ei_outb(ring_offset & 0xff, nic_base + EN0_RSARLO); |
175 | ei_outb(ring_offset >> 8, nic_base + EN0_RSARHI); |
176 | ei_outb(E8390_RREAD + E8390_START, nic_base + NE_CMD); |
177 | |
178 | xs100_read(dev, dst: buf, count); |
179 | |
180 | ei_local->dmaing &= ~1; |
181 | } |
182 | |
183 | static void xs100_block_output(struct net_device *dev, int count, |
184 | const unsigned char *buf, const int start_page) |
185 | { |
186 | struct ei_device *ei_local = netdev_priv(dev); |
187 | void __iomem *nic_base = ei_local->mem; |
188 | unsigned long dma_start; |
189 | |
190 | /* Round the count up for word writes. Do we need to do this? |
191 | * What effect will an odd byte count have on the 8390? I |
192 | * should check someday. |
193 | */ |
194 | if (ei_local->word16 && (count & 0x01)) |
195 | count++; |
196 | |
197 | /* This *shouldn't* happen. If it does, it's the last thing |
198 | * you'll see |
199 | */ |
200 | if (ei_local->dmaing) { |
201 | netdev_err(dev, |
202 | format: "DMAing conflict in %s [DMAstat:%d][irqlock:%d]\n" , |
203 | __func__, |
204 | ei_local->dmaing, ei_local->irqlock); |
205 | return; |
206 | } |
207 | |
208 | ei_local->dmaing |= 0x01; |
209 | /* We should already be in page 0, but to be safe... */ |
210 | ei_outb(E8390_PAGE0 + E8390_START + E8390_NODMA, nic_base + NE_CMD); |
211 | |
212 | ei_outb(ENISR_RDC, nic_base + EN0_ISR); |
213 | |
214 | /* Now the normal output. */ |
215 | ei_outb(count & 0xff, nic_base + EN0_RCNTLO); |
216 | ei_outb(count >> 8, nic_base + EN0_RCNTHI); |
217 | ei_outb(0x00, nic_base + EN0_RSARLO); |
218 | ei_outb(start_page, nic_base + EN0_RSARHI); |
219 | |
220 | ei_outb(E8390_RWRITE + E8390_START, nic_base + NE_CMD); |
221 | |
222 | xs100_write(dev, src: buf, count); |
223 | |
224 | dma_start = jiffies; |
225 | |
226 | while ((ei_inb(nic_base + EN0_ISR) & ENISR_RDC) == 0) { |
227 | if (jiffies - dma_start > 2 * HZ / 100) { /* 20ms */ |
228 | netdev_warn(dev, format: "timeout waiting for Tx RDC.\n" ); |
229 | ei_local->reset_8390(dev); |
230 | ax_NS8390_reinit(dev); |
231 | break; |
232 | } |
233 | } |
234 | |
235 | ei_outb(ENISR_RDC, nic_base + EN0_ISR); /* Ack intr. */ |
236 | ei_local->dmaing &= ~0x01; |
237 | } |
238 | |
239 | static int xsurf100_probe(struct zorro_dev *zdev, |
240 | const struct zorro_device_id *ent) |
241 | { |
242 | struct platform_device *pdev; |
243 | struct xsurf100_ax_plat_data ax88796_data; |
244 | struct resource res[2] = { |
245 | DEFINE_RES_NAMED(IRQ_AMIGA_PORTS, 1, NULL, |
246 | IORESOURCE_IRQ | IORESOURCE_IRQ_SHAREABLE), |
247 | DEFINE_RES_MEM(zdev->resource.start + XS100_8390_BASE, |
248 | 4 * 0x20) |
249 | }; |
250 | int reg; |
251 | /* This table is referenced in the device structure, so it must |
252 | * outlive the scope of xsurf100_probe. |
253 | */ |
254 | static u32 reg_offsets[32]; |
255 | int ret = 0; |
256 | |
257 | /* X-Surf 100 control and 32 bit ring buffer data access areas. |
258 | * These resources are not used by the ax88796 driver, so must |
259 | * be requested here and passed via platform data. |
260 | */ |
261 | |
262 | if (!request_mem_region(zdev->resource.start, 0x100, zdev->name)) { |
263 | dev_err(&zdev->dev, "cannot reserve X-Surf 100 control registers\n" ); |
264 | return -ENXIO; |
265 | } |
266 | |
267 | if (!request_mem_region(zdev->resource.start + |
268 | XS100_8390_DATA32_BASE, |
269 | XS100_8390_DATA32_SIZE, |
270 | "X-Surf 100 32-bit data access" )) { |
271 | dev_err(&zdev->dev, "cannot reserve 32-bit area\n" ); |
272 | ret = -ENXIO; |
273 | goto exit_req; |
274 | } |
275 | |
276 | for (reg = 0; reg < 0x20; reg++) |
277 | reg_offsets[reg] = 4 * reg; |
278 | |
279 | memset(&ax88796_data, 0, sizeof(ax88796_data)); |
280 | ax88796_data.ax.flags = AXFLG_HAS_EEPROM; |
281 | ax88796_data.ax.wordlength = 2; |
282 | ax88796_data.ax.dcr_val = 0x48; |
283 | ax88796_data.ax.rcr_val = 0x40; |
284 | ax88796_data.ax.reg_offsets = reg_offsets; |
285 | ax88796_data.ax.check_irq = is_xsurf100_network_irq; |
286 | ax88796_data.base_regs = ioremap(offset: zdev->resource.start, size: 0x100); |
287 | |
288 | /* error handling for ioremap regs */ |
289 | if (!ax88796_data.base_regs) { |
290 | dev_err(&zdev->dev, "Cannot ioremap area %pR (registers)\n" , |
291 | &zdev->resource); |
292 | |
293 | ret = -ENXIO; |
294 | goto exit_req2; |
295 | } |
296 | |
297 | ax88796_data.data_area = ioremap(offset: zdev->resource.start + |
298 | XS100_8390_DATA32_BASE, XS100_8390_DATA32_SIZE); |
299 | |
300 | /* error handling for ioremap data */ |
301 | if (!ax88796_data.data_area) { |
302 | dev_err(&zdev->dev, |
303 | "Cannot ioremap area %pR offset %x (32-bit access)\n" , |
304 | &zdev->resource, XS100_8390_DATA32_BASE); |
305 | |
306 | ret = -ENXIO; |
307 | goto exit_mem; |
308 | } |
309 | |
310 | ax88796_data.ax.block_output = xs100_block_output; |
311 | ax88796_data.ax.block_input = xs100_block_input; |
312 | |
313 | pdev = platform_device_register_resndata(parent: &zdev->dev, name: "ax88796" , |
314 | id: zdev->slotaddr, res, num: 2, |
315 | data: &ax88796_data, |
316 | size: sizeof(ax88796_data)); |
317 | |
318 | if (IS_ERR(ptr: pdev)) { |
319 | dev_err(&zdev->dev, "cannot register platform device\n" ); |
320 | ret = -ENXIO; |
321 | goto exit_mem2; |
322 | } |
323 | |
324 | zorro_set_drvdata(z: zdev, data: pdev); |
325 | |
326 | if (!ret) |
327 | return 0; |
328 | |
329 | exit_mem2: |
330 | iounmap(addr: ax88796_data.data_area); |
331 | |
332 | exit_mem: |
333 | iounmap(addr: ax88796_data.base_regs); |
334 | |
335 | exit_req2: |
336 | release_mem_region(zdev->resource.start + XS100_8390_DATA32_BASE, |
337 | XS100_8390_DATA32_SIZE); |
338 | |
339 | exit_req: |
340 | release_mem_region(zdev->resource.start, 0x100); |
341 | |
342 | return ret; |
343 | } |
344 | |
345 | static void xsurf100_remove(struct zorro_dev *zdev) |
346 | { |
347 | struct platform_device *pdev = zorro_get_drvdata(z: zdev); |
348 | struct xsurf100_ax_plat_data *xs100 = dev_get_platdata(dev: &pdev->dev); |
349 | |
350 | platform_device_unregister(pdev); |
351 | |
352 | iounmap(addr: xs100->base_regs); |
353 | release_mem_region(zdev->resource.start, 0x100); |
354 | iounmap(addr: xs100->data_area); |
355 | release_mem_region(zdev->resource.start + XS100_8390_DATA32_BASE, |
356 | XS100_8390_DATA32_SIZE); |
357 | } |
358 | |
359 | static const struct zorro_device_id xsurf100_zorro_tbl[] = { |
360 | { ZORRO_PROD_INDIVIDUAL_COMPUTERS_X_SURF100, }, |
361 | { 0 } |
362 | }; |
363 | |
364 | MODULE_DEVICE_TABLE(zorro, xsurf100_zorro_tbl); |
365 | |
366 | static struct zorro_driver xsurf100_driver = { |
367 | .name = "xsurf100" , |
368 | .id_table = xsurf100_zorro_tbl, |
369 | .probe = xsurf100_probe, |
370 | .remove = xsurf100_remove, |
371 | }; |
372 | |
373 | module_driver(xsurf100_driver, zorro_register_driver, zorro_unregister_driver); |
374 | |
375 | MODULE_DESCRIPTION("X-Surf 100 driver" ); |
376 | MODULE_AUTHOR("Michael Karcher <kernel@mkarcher.dialup.fu-berlin.de>" ); |
377 | MODULE_LICENSE("GPL v2" ); |
378 | |