xref: /linux/drivers/net/ethernet/8390/xsurf100.c (revision 762f99f4f3cb41a775b5157dd761217beba65873)
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 
is_xsurf100_network_irq(struct platform_device * pdev)56 static int is_xsurf100_network_irq(struct platform_device *pdev)
57 {
58 	struct xsurf100_ax_plat_data *xs100 = dev_get_platdata(&pdev->dev);
59 
60 	return (readw(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  */
z_memcpy_fromio32(void * dst,const void __iomem * src,size_t bytes)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 
z_memcpy_toio32(void __iomem * dst,const void * src,size_t bytes)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 
xs100_write(struct net_device * dev,const void * src,unsigned int count)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(&pdev->dev);
101 
102 	/* copy whole blocks */
103 	while (count > XS100_8390_DATA_AREA_SIZE) {
104 		z_memcpy_toio32(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(xs100->data_area + XS100_8390_DATA_WRITE32_BASE,
112 			src, 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 
xs100_read(struct net_device * dev,void * dst,unsigned int count)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(&pdev->dev);
127 
128 	/* copy whole blocks */
129 	while (count > XS100_8390_DATA_AREA_SIZE) {
130 		z_memcpy_fromio32(dst, 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, xs100->data_area + XS100_8390_DATA_READ32_BASE,
138 			  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  */
xs100_block_input(struct net_device * dev,int count,struct sk_buff * skb,int ring_offset)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 			   "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, buf, count);
179 
180 	ei_local->dmaing &= ~1;
181 }
182 
xs100_block_output(struct net_device * dev,int count,const unsigned char * buf,const int start_page)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 			   "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, 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, "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 
xsurf100_probe(struct zorro_dev * zdev,const struct zorro_device_id * ent)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(zdev->resource.start, 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(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(&zdev->dev, "ax88796",
314 						 zdev->slotaddr, res, 2,
315 						 &ax88796_data,
316 						 sizeof(ax88796_data));
317 
318 	if (IS_ERR(pdev)) {
319 		dev_err(&zdev->dev, "cannot register platform device\n");
320 		ret = -ENXIO;
321 		goto exit_mem2;
322 	}
323 
324 	zorro_set_drvdata(zdev, pdev);
325 
326 	if (!ret)
327 		return 0;
328 
329  exit_mem2:
330 	iounmap(ax88796_data.data_area);
331 
332  exit_mem:
333 	iounmap(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 
xsurf100_remove(struct zorro_dev * zdev)345 static void xsurf100_remove(struct zorro_dev *zdev)
346 {
347 	struct platform_device *pdev = zorro_get_drvdata(zdev);
348 	struct xsurf100_ax_plat_data *xs100 = dev_get_platdata(&pdev->dev);
349 
350 	platform_device_unregister(pdev);
351 
352 	iounmap(xs100->base_regs);
353 	release_mem_region(zdev->resource.start, 0x100);
354 	iounmap(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