xref: /openbmc/linux/drivers/net/arcnet/com90io.c (revision a266ef69)
1 /*
2  * Linux ARCnet driver - COM90xx chipset (IO-mapped buffers)
3  *
4  * Written 1997 by David Woodhouse.
5  * Written 1994-1999 by Avery Pennarun.
6  * Written 1999-2000 by Martin Mares <mj@ucw.cz>.
7  * Derived from skeleton.c by Donald Becker.
8  *
9  * Special thanks to Contemporary Controls, Inc. (www.ccontrols.com)
10  *  for sponsoring the further development of this driver.
11  *
12  * **********************
13  *
14  * The original copyright of skeleton.c was as follows:
15  *
16  * skeleton.c Written 1993 by Donald Becker.
17  * Copyright 1993 United States Government as represented by the
18  * Director, National Security Agency.  This software may only be used
19  * and distributed according to the terms of the GNU General Public License as
20  * modified by SRC, incorporated herein by reference.
21  *
22  * **********************
23  *
24  * For more details, see drivers/net/arcnet.c
25  *
26  * **********************
27  */
28 
29 #define pr_fmt(fmt) "arcnet:" KBUILD_MODNAME ": " fmt
30 
31 #include <linux/kernel.h>
32 #include <linux/module.h>
33 #include <linux/moduleparam.h>
34 #include <linux/ioport.h>
35 #include <linux/delay.h>
36 #include <linux/netdevice.h>
37 #include <linux/memblock.h>
38 #include <linux/init.h>
39 #include <linux/interrupt.h>
40 #include <linux/io.h>
41 
42 #include "arcdevice.h"
43 #include "com9026.h"
44 
45 /* Internal function declarations */
46 
47 static int com90io_found(struct net_device *dev);
48 static void com90io_command(struct net_device *dev, int command);
49 static int com90io_status(struct net_device *dev);
50 static void com90io_setmask(struct net_device *dev, int mask);
51 static int com90io_reset(struct net_device *dev, int really_reset);
52 static void com90io_copy_to_card(struct net_device *dev, int bufnum, int offset,
53 				 void *buf, int count);
54 static void com90io_copy_from_card(struct net_device *dev, int bufnum,
55 				   int offset, void *buf, int count);
56 
57 /* Handy defines for ARCnet specific stuff */
58 
59 /* The number of low I/O ports used by the card. */
60 #define ARCNET_TOTAL_SIZE 16
61 
62 /****************************************************************************
63  *                                                                          *
64  * IO-mapped operation routines                                             *
65  *                                                                          *
66  ****************************************************************************/
67 
68 #undef ONE_AT_A_TIME_TX
69 #undef ONE_AT_A_TIME_RX
70 
71 static u_char get_buffer_byte(struct net_device *dev, unsigned offset)
72 {
73 	int ioaddr = dev->base_addr;
74 
75 	arcnet_outb(offset >> 8, ioaddr, COM9026_REG_W_ADDR_HI);
76 	arcnet_outb(offset & 0xff, ioaddr, COM9026_REG_W_ADDR_LO);
77 
78 	return arcnet_inb(ioaddr, COM9026_REG_RW_MEMDATA);
79 }
80 
81 #ifdef ONE_AT_A_TIME_TX
82 static void put_buffer_byte(struct net_device *dev, unsigned offset,
83 			    u_char datum)
84 {
85 	int ioaddr = dev->base_addr;
86 
87 	arcnet_outb(offset >> 8, ioaddr, COM9026_REG_W_ADDR_HI);
88 	arcnet_outb(offset & 0xff, ioaddr, COM9026_REG_W_ADDR_LO);
89 
90 	arcnet_outb(datum, ioaddr, COM9026_REG_RW_MEMDATA);
91 }
92 
93 #endif
94 
95 static void get_whole_buffer(struct net_device *dev, unsigned offset,
96 			     unsigned length, char *dest)
97 {
98 	int ioaddr = dev->base_addr;
99 
100 	arcnet_outb((offset >> 8) | AUTOINCflag, ioaddr, COM9026_REG_W_ADDR_HI);
101 	arcnet_outb(offset & 0xff, ioaddr, COM9026_REG_W_ADDR_LO);
102 
103 	while (length--)
104 #ifdef ONE_AT_A_TIME_RX
105 		*(dest++) = get_buffer_byte(dev, offset++);
106 #else
107 		*(dest++) = arcnet_inb(ioaddr, COM9026_REG_RW_MEMDATA);
108 #endif
109 }
110 
111 static void put_whole_buffer(struct net_device *dev, unsigned offset,
112 			     unsigned length, char *dest)
113 {
114 	int ioaddr = dev->base_addr;
115 
116 	arcnet_outb((offset >> 8) | AUTOINCflag, ioaddr, COM9026_REG_W_ADDR_HI);
117 	arcnet_outb(offset & 0xff, ioaddr,COM9026_REG_W_ADDR_LO);
118 
119 	while (length--)
120 #ifdef ONE_AT_A_TIME_TX
121 		put_buffer_byte(dev, offset++, *(dest++));
122 #else
123 		arcnet_outb(*(dest++), ioaddr, COM9026_REG_RW_MEMDATA);
124 #endif
125 }
126 
127 /* We cannot probe for an IO mapped card either, although we can check that
128  * it's where we were told it was, and even autoirq
129  */
130 static int __init com90io_probe(struct net_device *dev)
131 {
132 	int ioaddr = dev->base_addr, status;
133 	unsigned long airqmask;
134 
135 	if (BUGLVL(D_NORMAL)) {
136 		pr_info("%s\n", "COM90xx IO-mapped mode support (by David Woodhouse et el.)");
137 		pr_info("E-mail me if you actually test this driver, please!\n");
138 	}
139 
140 	if (!ioaddr) {
141 		arc_printk(D_NORMAL, dev, "No autoprobe for IO mapped cards; you must specify the base address!\n");
142 		return -ENODEV;
143 	}
144 	if (!request_region(ioaddr, ARCNET_TOTAL_SIZE, "com90io probe")) {
145 		arc_printk(D_INIT_REASONS, dev, "IO request_region %x-%x failed\n",
146 			   ioaddr, ioaddr + ARCNET_TOTAL_SIZE - 1);
147 		return -ENXIO;
148 	}
149 	if (arcnet_inb(ioaddr, COM9026_REG_R_STATUS) == 0xFF) {
150 		arc_printk(D_INIT_REASONS, dev, "IO address %x empty\n",
151 			   ioaddr);
152 		goto err_out;
153 	}
154 	arcnet_inb(ioaddr, COM9026_REG_R_RESET);
155 	mdelay(RESETtime);
156 
157 	status = arcnet_inb(ioaddr, COM9026_REG_R_STATUS);
158 
159 	if ((status & 0x9D) != (NORXflag | RECONflag | TXFREEflag | RESETflag)) {
160 		arc_printk(D_INIT_REASONS, dev, "Status invalid (%Xh)\n",
161 			   status);
162 		goto err_out;
163 	}
164 	arc_printk(D_INIT_REASONS, dev, "Status after reset: %X\n", status);
165 
166 	arcnet_outb(CFLAGScmd | RESETclear | CONFIGclear,
167 		    ioaddr, COM9026_REG_W_COMMAND);
168 
169 	arc_printk(D_INIT_REASONS, dev, "Status after reset acknowledged: %X\n",
170 		   status);
171 
172 	status = arcnet_inb(ioaddr, COM9026_REG_R_STATUS);
173 
174 	if (status & RESETflag) {
175 		arc_printk(D_INIT_REASONS, dev, "Eternal reset (status=%Xh)\n",
176 			   status);
177 		goto err_out;
178 	}
179 	arcnet_outb((0x16 | IOMAPflag) & ~ENABLE16flag,
180 		    ioaddr, COM9026_REG_RW_CONFIG);
181 
182 	/* Read first loc'n of memory */
183 
184 	arcnet_outb(AUTOINCflag, ioaddr, COM9026_REG_W_ADDR_HI);
185 	arcnet_outb(0, ioaddr,  COM9026_REG_W_ADDR_LO);
186 
187 	status = arcnet_inb(ioaddr, COM9026_REG_RW_MEMDATA);
188 	if (status != 0xd1) {
189 		arc_printk(D_INIT_REASONS, dev, "Signature byte not found (%Xh instead).\n",
190 			   status);
191 		goto err_out;
192 	}
193 	if (!dev->irq) {
194 		/* if we do this, we're sure to get an IRQ since the
195 		 * card has just reset and the NORXflag is on until
196 		 * we tell it to start receiving.
197 		 */
198 
199 		airqmask = probe_irq_on();
200 		arcnet_outb(NORXflag, ioaddr, COM9026_REG_W_INTMASK);
201 		udelay(1);
202 		arcnet_outb(0, ioaddr, COM9026_REG_W_INTMASK);
203 		dev->irq = probe_irq_off(airqmask);
204 
205 		if ((int)dev->irq <= 0) {
206 			arc_printk(D_INIT_REASONS, dev, "Autoprobe IRQ failed\n");
207 			goto err_out;
208 		}
209 	}
210 	release_region(ioaddr, ARCNET_TOTAL_SIZE); /* end of probing */
211 	return com90io_found(dev);
212 
213 err_out:
214 	release_region(ioaddr, ARCNET_TOTAL_SIZE);
215 	return -ENODEV;
216 }
217 
218 /* Set up the struct net_device associated with this card.  Called after
219  * probing succeeds.
220  */
221 static int __init com90io_found(struct net_device *dev)
222 {
223 	struct arcnet_local *lp;
224 	int ioaddr = dev->base_addr;
225 	int err;
226 
227 	/* Reserve the irq */
228 	if (request_irq(dev->irq, arcnet_interrupt, 0,
229 			"arcnet (COM90xx-IO)", dev)) {
230 		arc_printk(D_NORMAL, dev, "Can't get IRQ %d!\n", dev->irq);
231 		return -ENODEV;
232 	}
233 	/* Reserve the I/O region */
234 	if (!request_region(dev->base_addr, ARCNET_TOTAL_SIZE,
235 			    "arcnet (COM90xx-IO)")) {
236 		free_irq(dev->irq, dev);
237 		return -EBUSY;
238 	}
239 
240 	lp = netdev_priv(dev);
241 	lp->card_name = "COM90xx I/O";
242 	lp->hw.command = com90io_command;
243 	lp->hw.status = com90io_status;
244 	lp->hw.intmask = com90io_setmask;
245 	lp->hw.reset = com90io_reset;
246 	lp->hw.owner = THIS_MODULE;
247 	lp->hw.copy_to_card = com90io_copy_to_card;
248 	lp->hw.copy_from_card = com90io_copy_from_card;
249 
250 	lp->config = (0x16 | IOMAPflag) & ~ENABLE16flag;
251 	arcnet_outb(lp->config, ioaddr, COM9026_REG_RW_CONFIG);
252 
253 	/* get and check the station ID from offset 1 in shmem */
254 
255 	arcnet_set_addr(dev, get_buffer_byte(dev, 1));
256 
257 	err = register_netdev(dev);
258 	if (err) {
259 		arcnet_outb(arcnet_inb(ioaddr, COM9026_REG_RW_CONFIG) & ~IOMAPflag,
260 			    ioaddr, COM9026_REG_RW_CONFIG);
261 		free_irq(dev->irq, dev);
262 		release_region(dev->base_addr, ARCNET_TOTAL_SIZE);
263 		return err;
264 	}
265 
266 	arc_printk(D_NORMAL, dev, "COM90IO: station %02Xh found at %03lXh, IRQ %d.\n",
267 		   dev->dev_addr[0], dev->base_addr, dev->irq);
268 
269 	return 0;
270 }
271 
272 /* Do a hardware reset on the card, and set up necessary registers.
273  *
274  * This should be called as little as possible, because it disrupts the
275  * token on the network (causes a RECON) and requires a significant delay.
276  *
277  * However, it does make sure the card is in a defined state.
278  */
279 static int com90io_reset(struct net_device *dev, int really_reset)
280 {
281 	struct arcnet_local *lp = netdev_priv(dev);
282 	short ioaddr = dev->base_addr;
283 
284 	arc_printk(D_INIT, dev, "Resetting %s (status=%02Xh)\n",
285 		   dev->name, arcnet_inb(ioaddr, COM9026_REG_R_STATUS));
286 
287 	if (really_reset) {
288 		/* reset the card */
289 		arcnet_inb(ioaddr, COM9026_REG_R_RESET);
290 		mdelay(RESETtime);
291 	}
292 	/* Set the thing to IO-mapped, 8-bit  mode */
293 	lp->config = (0x1C | IOMAPflag) & ~ENABLE16flag;
294 	arcnet_outb(lp->config, ioaddr, COM9026_REG_RW_CONFIG);
295 
296 	arcnet_outb(CFLAGScmd | RESETclear, ioaddr, COM9026_REG_W_COMMAND);
297 					/* clear flags & end reset */
298 	arcnet_outb(CFLAGScmd | CONFIGclear, ioaddr, COM9026_REG_W_COMMAND);
299 
300 	/* verify that the ARCnet signature byte is present */
301 	if (get_buffer_byte(dev, 0) != TESTvalue) {
302 		arc_printk(D_NORMAL, dev, "reset failed: TESTvalue not present.\n");
303 		return 1;
304 	}
305 	/* enable extended (512-byte) packets */
306 	arcnet_outb(CONFIGcmd | EXTconf, ioaddr, COM9026_REG_W_COMMAND);
307 	/* done!  return success. */
308 	return 0;
309 }
310 
311 static void com90io_command(struct net_device *dev, int cmd)
312 {
313 	short ioaddr = dev->base_addr;
314 
315 	arcnet_outb(cmd, ioaddr, COM9026_REG_W_COMMAND);
316 }
317 
318 static int com90io_status(struct net_device *dev)
319 {
320 	short ioaddr = dev->base_addr;
321 
322 	return arcnet_inb(ioaddr, COM9026_REG_R_STATUS);
323 }
324 
325 static void com90io_setmask(struct net_device *dev, int mask)
326 {
327 	short ioaddr = dev->base_addr;
328 
329 	arcnet_outb(mask, ioaddr, COM9026_REG_W_INTMASK);
330 }
331 
332 static void com90io_copy_to_card(struct net_device *dev, int bufnum,
333 				 int offset, void *buf, int count)
334 {
335 	TIME(dev, "put_whole_buffer", count,
336 	     put_whole_buffer(dev, bufnum * 512 + offset, count, buf));
337 }
338 
339 static void com90io_copy_from_card(struct net_device *dev, int bufnum,
340 				   int offset, void *buf, int count)
341 {
342 	TIME(dev, "get_whole_buffer", count,
343 	     get_whole_buffer(dev, bufnum * 512 + offset, count, buf));
344 }
345 
346 static int io;			/* use the insmod io= irq= shmem= options */
347 static int irq;
348 static char device[9];		/* use eg. device=arc1 to change name */
349 
350 module_param_hw(io, int, ioport, 0);
351 module_param_hw(irq, int, irq, 0);
352 module_param_string(device, device, sizeof(device), 0);
353 MODULE_LICENSE("GPL");
354 
355 #ifndef MODULE
356 static int __init com90io_setup(char *s)
357 {
358 	int ints[4];
359 
360 	s = get_options(s, 4, ints);
361 	if (!ints[0])
362 		return 0;
363 	switch (ints[0]) {
364 	default:		/* ERROR */
365 		pr_err("Too many arguments\n");
366 		fallthrough;
367 	case 2:		/* IRQ */
368 		irq = ints[2];
369 		fallthrough;
370 	case 1:		/* IO address */
371 		io = ints[1];
372 	}
373 	if (*s)
374 		snprintf(device, sizeof(device), "%s", s);
375 	return 1;
376 }
377 __setup("com90io=", com90io_setup);
378 #endif
379 
380 static struct net_device *my_dev;
381 
382 static int __init com90io_init(void)
383 {
384 	struct net_device *dev;
385 	int err;
386 
387 	dev = alloc_arcdev(device);
388 	if (!dev)
389 		return -ENOMEM;
390 
391 	dev->base_addr = io;
392 	dev->irq = irq;
393 	if (dev->irq == 2)
394 		dev->irq = 9;
395 
396 	err = com90io_probe(dev);
397 
398 	if (err) {
399 		free_arcdev(dev);
400 		return err;
401 	}
402 
403 	my_dev = dev;
404 	return 0;
405 }
406 
407 static void __exit com90io_exit(void)
408 {
409 	struct net_device *dev = my_dev;
410 	int ioaddr = dev->base_addr;
411 
412 	unregister_netdev(dev);
413 
414 	/* In case the old driver is loaded later,
415 	 * set the thing back to MMAP mode
416 	 */
417 	arcnet_outb(arcnet_inb(ioaddr, COM9026_REG_RW_CONFIG) & ~IOMAPflag,
418 		    ioaddr, COM9026_REG_RW_CONFIG);
419 
420 	free_irq(dev->irq, dev);
421 	release_region(dev->base_addr, ARCNET_TOTAL_SIZE);
422 	free_arcdev(dev);
423 }
424 
425 module_init(com90io_init)
426 module_exit(com90io_exit)
427