1/*
2**
3**  RCpci45.c
4**
5**
6**
7**  ---------------------------------------------------------------------
8**  ---     Copyright (c) 1998, 1999, RedCreek Communications Inc.    ---
9**  ---                   All rights reserved.                        ---
10**  ---------------------------------------------------------------------
11**
12** Written by Pete Popov and Brian Moyle.
13**
14** Known Problems
15**
16** None known at this time.
17**
18**  This program is free software; you can redistribute it and/or modify
19**  it under the terms of the GNU General Public License as published by
20**  the Free Software Foundation; either version 2 of the License, or
21**  (at your option) any later version.
22
23**  This program is distributed in the hope that it will be useful,
24**  but WITHOUT ANY WARRANTY; without even the implied warranty of
25**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26**  GNU General Public License for more details.
27
28**  You should have received a copy of the GNU General Public License
29**  along with this program; if not, write to the Free Software
30**  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31**
32**  Pete Popov, Oct 2001: Fixed a few bugs to make the driver functional
33**  again. Note that this card is not supported or manufactured by
34**  RedCreek anymore.
35**
36**  Rasmus Andersen, December 2000: Converted to new PCI API and general
37**  cleanup.
38**
39**  Pete Popov, January 11,99: Fixed a couple of 2.1.x problems
40**  (virt_to_bus() not called), tested it under 2.2pre5 (as a module), and
41**  added a #define(s) to enable the use of the same file for both, the 2.0.x
42**  kernels as well as the 2.1.x.
43**
44**  Ported to 2.1.x by Alan Cox 1998/12/9.
45**
46**  Sometime in mid 1998, written by Pete Popov and Brian Moyle.
47**
48***************************************************************************/
49
50#include <linux/module.h>
51#include <linux/kernel.h>
52#include <linux/sched.h>
53#include <linux/string.h>
54#include <linux/ptrace.h>
55#include <linux/errno.h>
56#include <linux/in.h>
57#include <linux/init.h>
58#include <linux/ioport.h>
59#include <linux/slab.h>
60#include <linux/interrupt.h>
61#include <linux/pci.h>
62#include <linux/timer.h>
63#include <asm/irq.h>		/* For NR_IRQS only. */
64#include <asm/bitops.h>
65#include <asm/uaccess.h>
66
67static char version[] __initdata =
68    "RedCreek Communications PCI linux driver version 2.20\n";
69
70#define RC_LINUX_MODULE
71#include "rclanmtl.h"
72#include "rcif.h"
73
74#define RUN_AT(x) (jiffies + (x))
75
76#define NEW_MULTICAST
77
78/* PCI/45 Configuration space values */
79#define RC_PCI45_VENDOR_ID  0x4916
80#define RC_PCI45_DEVICE_ID  0x1960
81
82#define MAX_ETHER_SIZE        1520
83#define MAX_NMBR_RCV_BUFFERS    96
84#define RC_POSTED_BUFFERS_LOW_MARK MAX_NMBR_RCV_BUFFERS-16
85#define BD_SIZE 3		/* Bucket Descriptor size */
86#define BD_LEN_OFFSET 2		/* Bucket Descriptor offset to length field */
87
88/* RedCreek LAN device Target ID */
89#define RC_LAN_TARGET_ID  0x10
90/* RedCreek's OSM default LAN receive Initiator */
91#define DEFAULT_RECV_INIT_CONTEXT  0xA17
92
93/* minimum msg buffer size needed by the card
94 * Note that the size of this buffer is hard code in the
95 * ipsec card's firmware. Thus, the size MUST be a minimum
96 * of 16K. Otherwise the card will end up using memory
97 * that does not belong to it.
98 */
99#define MSG_BUF_SIZE  16384
100
101static U32 DriverControlWord;
102
103static void rc_timer (unsigned long);
104
105static int RCopen (struct net_device *);
106static int RC_xmit_packet (struct sk_buff *, struct net_device *);
107static void RCinterrupt (int, void *, struct pt_regs *);
108static int RCclose (struct net_device *dev);
109static struct net_device_stats *RCget_stats (struct net_device *);
110static int RCioctl (struct net_device *, struct ifreq *, int);
111static int RCconfig (struct net_device *, struct ifmap *);
112static void RCxmit_callback (U32, U16, PU32, struct net_device *);
113static void RCrecv_callback (U32, U8, U32, PU32, struct net_device *);
114static void RCreset_callback (U32, U32, U32, struct net_device *);
115static void RCreboot_callback (U32, U32, U32, struct net_device *);
116static int RC_allocate_and_post_buffers (struct net_device *, int);
117
118static struct pci_device_id rcpci45_pci_table[] __devinitdata = {
119	{RC_PCI45_VENDOR_ID, RC_PCI45_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
120	{}
121};
122MODULE_DEVICE_TABLE (pci, rcpci45_pci_table);
123MODULE_LICENSE("GPL");
124
125static void __devexit
126rcpci45_remove_one (struct pci_dev *pdev)
127{
128	struct net_device *dev = pci_get_drvdata (pdev);
129	PDPA pDpa = dev->priv;
130
131	if (!dev) {
132		printk (KERN_ERR "%s: remove non-existent device\n",
133				dev->name);
134		return;
135	}
136
137	RCResetIOP (dev);
138	unregister_netdev (dev);
139	free_irq (dev->irq, dev);
140	iounmap ((void *) dev->base_addr);
141	pci_release_regions (pdev);
142	if (pDpa->msgbuf)
143		kfree (pDpa->msgbuf);
144	if (pDpa->pPab)
145		kfree (pDpa->pPab);
146	kfree (dev);
147	pci_set_drvdata (pdev, NULL);
148}
149
150static int
151rcpci45_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
152{
153	unsigned long *vaddr;
154	PDPA pDpa;
155	int error;
156	static int card_idx = -1;
157	struct net_device *dev;
158	unsigned long pci_start, pci_len;
159
160	card_idx++;
161
162	/*
163	 * Allocate and fill new device structure.
164	 * We need enough for struct net_device plus DPA plus the LAN
165	 * API private area, which requires a minimum of 16KB.  The top
166	 * of the allocated area will be assigned to struct net_device;
167	 * the next chunk will be assigned to DPA; and finally, the rest
168	 * will be assigned to the LAN API layer.
169	 */
170
171	dev = init_etherdev (NULL, sizeof (*pDpa));
172	if (!dev) {
173		printk (KERN_ERR
174			"(rcpci45 driver:) init_etherdev alloc failed\n");
175		error = -ENOMEM;
176		goto err_out;
177	}
178
179	error = pci_enable_device (pdev);
180	if (error) {
181		printk (KERN_ERR
182			"(rcpci45 driver:) %d: pci enable device error\n",
183			card_idx);
184		goto err_out;
185	}
186	error = -ENOMEM;
187	pci_start = pci_resource_start (pdev, 0);
188	pci_len = pci_resource_len (pdev, 0);
189	printk("pci_start %lx pci_len %lx\n", pci_start, pci_len);
190
191	pci_set_drvdata (pdev, dev);
192
193	pDpa = dev->priv;
194	pDpa->id = card_idx;
195	pDpa->pci_addr = pci_start;
196
197	if (!pci_start || !(pci_resource_flags (pdev, 0) & IORESOURCE_MEM)) {
198		printk (KERN_ERR
199			"(rcpci45 driver:) No PCI mem resources! Aborting\n");
200		error = -EBUSY;
201		goto err_out_free_dev;
202	}
203
204	/*
205	 * pDpa->msgbuf is where the card will dma the I2O
206	 * messages. Thus, we need contiguous physical pages of
207	 * memory.
208	 */
209	pDpa->msgbuf = kmalloc (MSG_BUF_SIZE, GFP_DMA|GFP_ATOMIC|GFP_KERNEL);
210	if (!pDpa->msgbuf) {
211		printk (KERN_ERR "(rcpci45 driver:) \
212			Could not allocate %d byte memory for the \
213				private msgbuf!\n", MSG_BUF_SIZE);
214		goto err_out_free_dev;
215	}
216
217	/*
218	 * Save the starting address of the LAN API private area.  We'll
219	 * pass that to RCInitI2OMsgLayer().
220	 *
221	 */
222	pDpa->PLanApiPA = (void *) (((long) pDpa->msgbuf + 0xff) & ~0xff);
223
224	/* The adapter is accessible through memory-access read/write, not
225	 * I/O read/write.  Thus, we need to map it to some virtual address
226	 * area in order to access the registers as normal memory.
227	 */
228	error = pci_request_regions (pdev, dev->name);
229	if (error)
230		goto err_out_free_msgbuf;
231
232	vaddr = (ulong *) ioremap (pci_start, pci_len);
233	if (!vaddr) {
234		printk (KERN_ERR
235			"(rcpci45 driver:) \
236			Unable to remap address range from %lu to %lu\n",
237			pci_start, pci_start + pci_len);
238		goto err_out_free_region;
239	}
240
241	dev->base_addr = (unsigned long) vaddr;
242	dev->irq = pdev->irq;
243	dev->open = &RCopen;
244	dev->hard_start_xmit = &RC_xmit_packet;
245	dev->stop = &RCclose;
246	dev->get_stats = &RCget_stats;
247	dev->do_ioctl = &RCioctl;
248	dev->set_config = &RCconfig;
249
250	return 0;		/* success */
251
252err_out_free_region:
253	pci_release_regions (pdev);
254err_out_free_msgbuf:
255	kfree (pDpa->msgbuf);
256err_out_free_dev:
257	unregister_netdev (dev);
258	kfree (dev);
259err_out:
260	card_idx--;
261	return -ENODEV;
262}
263
264static struct pci_driver rcpci45_driver = {
265	name:		"rcpci45",
266	id_table:	rcpci45_pci_table,
267	probe:		rcpci45_init_one,
268	remove:		__devexit_p(rcpci45_remove_one),
269};
270
271static int __init
272rcpci_init_module (void)
273{
274	int rc = pci_module_init (&rcpci45_driver);
275	if (!rc)
276		printk (KERN_ERR "%s", version);
277	return rc;
278}
279
280static int
281RCopen (struct net_device *dev)
282{
283	int post_buffers = MAX_NMBR_RCV_BUFFERS;
284	PDPA pDpa = dev->priv;
285	int count = 0;
286	int requested = 0;
287	int error;
288
289	MOD_INC_USE_COUNT;
290	if (pDpa->nexus) {
291		/* This is not the first time RCopen is called.  Thus,
292		 * the interface was previously opened and later closed
293		 * by RCclose().  RCclose() does a Shutdown; to wake up
294		 * the adapter, a reset is mandatory before we can post
295		 * receive buffers.  However, if the adapter initiated
296		 * a reboot while the interface was closed -- and interrupts
297		 * were turned off -- we need will need to reinitialize
298		 * the adapter, rather than simply waking it up.
299		 */
300		printk (KERN_INFO "Waking up adapter...\n");
301		RCResetLANCard (dev, 0, 0, 0);
302	} else {
303		pDpa->nexus = 1;
304		/*
305		 * RCInitI2OMsgLayer is done only once, unless the
306		 * adapter was sent a warm reboot
307		 */
308		error = RCInitI2OMsgLayer (dev, (PFNTXCALLBACK) RCxmit_callback,
309					   (PFNRXCALLBACK) RCrecv_callback,
310					   (PFNCALLBACK) RCreboot_callback);
311		if (error) {
312			printk (KERN_ERR "%s: Unable to init msg layer (%x)\n",
313					dev->name, error);
314			goto err_out;
315		}
316		if ((error = RCGetMAC (dev, NULL))) {
317			printk (KERN_ERR "%s: Unable to get adapter MAC\n",
318					dev->name);
319			goto err_out;
320		}
321	}
322
323	/* Request a shared interrupt line. */
324	error = request_irq (dev->irq, RCinterrupt, SA_SHIRQ, dev->name, dev);
325	if (error) {
326		printk (KERN_ERR "%s: unable to get IRQ %d\n",
327				dev->name, dev->irq);
328		goto err_out;
329	}
330
331	DriverControlWord |= WARM_REBOOT_CAPABLE;
332	RCReportDriverCapability (dev, DriverControlWord);
333
334	printk (KERN_INFO "%s: RedCreek Communications IPSEC VPN adapter\n",
335		dev->name);
336
337	RCEnableI2OInterrupts (dev);
338
339	while (post_buffers) {
340		if (post_buffers > MAX_NMBR_POST_BUFFERS_PER_MSG)
341			requested = MAX_NMBR_POST_BUFFERS_PER_MSG;
342		else
343			requested = post_buffers;
344		count = RC_allocate_and_post_buffers (dev, requested);
345
346		if (count < requested) {
347			/*
348			 * Check to see if we were able to post
349			 * any buffers at all.
350			 */
351			if (post_buffers == MAX_NMBR_RCV_BUFFERS) {
352				printk (KERN_ERR "%s: \
353					unable to allocate any buffers\n",
354						dev->name);
355				goto err_out_free_irq;
356			}
357			printk (KERN_WARNING "%s: \
358			unable to allocate all requested buffers\n", dev->name);
359			break;	/* we'll try to post more buffers later */
360		} else
361			post_buffers -= count;
362	}
363	pDpa->numOutRcvBuffers = MAX_NMBR_RCV_BUFFERS - post_buffers;
364	pDpa->shutdown = 0;	/* just in case */
365	netif_start_queue (dev);
366	return 0;
367
368err_out_free_irq:
369	free_irq (dev->irq, dev);
370err_out:
371	MOD_DEC_USE_COUNT;
372	return error;
373}
374
375static int
376RC_xmit_packet (struct sk_buff *skb, struct net_device *dev)
377{
378
379	PDPA pDpa = dev->priv;
380	singleTCB tcb;
381	psingleTCB ptcb = &tcb;
382	RC_RETURN status = 0;
383
384	netif_stop_queue (dev);
385
386	if (pDpa->shutdown || pDpa->reboot) {
387		printk ("RC_xmit_packet: tbusy!\n");
388		return 1;
389	}
390
391	/*
392	 * The user is free to reuse the TCB after RCI2OSendPacket()
393	 * returns, since the function copies the necessary info into its
394	 * own private space.  Thus, our TCB can be a local structure.
395	 * The skb, on the other hand, will be freed up in our interrupt
396	 * handler.
397	 */
398
399	ptcb->bcount = 1;
400
401	/*
402	 * we'll get the context when the adapter interrupts us to tell us that
403	 * the transmission is done. At that time, we can free skb.
404	 */
405	ptcb->b.context = (U32) skb;
406	ptcb->b.scount = 1;
407	ptcb->b.size = skb->len;
408	ptcb->b.addr = virt_to_bus ((void *) skb->data);
409
410	if ((status = RCI2OSendPacket (dev, (U32) NULL, (PRCTCB) ptcb))
411	    != RC_RTN_NO_ERROR) {
412		printk ("%s: send error 0x%x\n", dev->name, (uint) status);
413		return 1;
414	} else {
415		dev->trans_start = jiffies;
416		netif_wake_queue (dev);
417	}
418	/*
419	 * That's it!
420	 */
421	return 0;
422}
423
424/*
425 * RCxmit_callback()
426 *
427 * The transmit callback routine. It's called by RCProcI2OMsgQ()
428 * because the adapter is done with one or more transmit buffers and
429 * it's returning them to us, or we asked the adapter to return the
430 * outstanding transmit buffers by calling RCResetLANCard() with
431 * RC_RESOURCE_RETURN_PEND_TX_BUFFERS flag.
432 * All we need to do is free the buffers.
433 */
434static void
435RCxmit_callback (U32 Status,
436		 U16 PcktCount, PU32 BufferContext, struct net_device *dev)
437{
438	struct sk_buff *skb;
439	PDPA pDpa = dev->priv;
440
441	if (!pDpa) {
442		printk (KERN_ERR "%s: Fatal Error in xmit callback, !pDpa\n",
443				dev->name);
444		return;
445	}
446
447	if (Status != I2O_REPLY_STATUS_SUCCESS)
448		printk (KERN_INFO "%s: xmit_callback: Status = 0x%x\n",
449				dev->name, (uint) Status);
450	if (pDpa->shutdown || pDpa->reboot)
451		printk (KERN_INFO "%s: xmit callback: shutdown||reboot\n",
452				dev->name);
453
454	while (PcktCount--) {
455		skb = (struct sk_buff *) (BufferContext[0]);
456		BufferContext++;
457		dev_kfree_skb_irq (skb);
458	}
459	netif_wake_queue (dev);
460}
461
462static void
463RCreset_callback (U32 Status, U32 p1, U32 p2, struct net_device *dev)
464{
465	PDPA pDpa = dev->priv;
466
467	printk ("RCreset_callback Status 0x%x\n", (uint) Status);
468	/*
469	 * Check to see why we were called.
470	 */
471	if (pDpa->shutdown) {
472		printk (KERN_INFO "%s: shutting down interface\n",
473				dev->name);
474		pDpa->shutdown = 0;
475		pDpa->reboot = 0;
476	} else if (pDpa->reboot) {
477		printk (KERN_INFO "%s: reboot, shutdown adapter\n",
478				dev->name);
479		/*
480		 * We don't set any of the flags in RCShutdownLANCard()
481		 * and we don't pass a callback routine to it.
482		 * The adapter will have already initiated the reboot by
483		 * the time the function returns.
484		 */
485		RCDisableI2OInterrupts (dev);
486		RCShutdownLANCard (dev, 0, 0, 0);
487		printk (KERN_INFO "%s: scheduling timer...\n", dev->name);
488		init_timer (&pDpa->timer);
489		pDpa->timer.expires = RUN_AT ((40 * HZ) / 10);	/* 4 sec. */
490		pDpa->timer.data = (unsigned long) dev;
491		pDpa->timer.function = &rc_timer;	/* timer handler */
492		add_timer (&pDpa->timer);
493	}
494}
495
496static void
497RCreboot_callback (U32 Status, U32 p1, U32 p2, struct net_device *dev)
498{
499	PDPA pDpa = dev->priv;
500
501	printk (KERN_INFO "%s: reboot: rcv buffers outstanding = %d\n",
502		 dev->name, (uint) pDpa->numOutRcvBuffers);
503
504	if (pDpa->shutdown) {
505		printk (KERN_INFO "%s: skip reboot, shutdown initiated\n",
506				dev->name);
507		return;
508	}
509	pDpa->reboot = 1;
510	/*
511	 * OK, we reset the adapter and ask it to return all
512	 * outstanding transmit buffers as well as the posted
513	 * receive buffers.  When the adapter is done returning
514	 * those buffers, it will call our RCreset_callback()
515	 * routine.  In that routine, we'll call RCShutdownLANCard()
516	 * to tell the adapter that it's OK to start the reboot and
517	 * schedule a timer callback routine to execute 3 seconds
518	 * later; this routine will reinitialize the adapter at that time.
519	 */
520	RCResetLANCard (dev, RC_RESOURCE_RETURN_POSTED_RX_BUCKETS |
521			RC_RESOURCE_RETURN_PEND_TX_BUFFERS, 0,
522			(PFNCALLBACK) RCreset_callback);
523}
524
525int
526broadcast_packet (unsigned char *address)
527{
528	int i;
529	for (i = 0; i < 6; i++)
530		if (address[i] != 0xff)
531			return 0;
532
533	return 1;
534}
535
536/*
537 * RCrecv_callback()
538 *
539 * The receive packet callback routine.  This is called by
540 * RCProcI2OMsgQ() after the adapter posts buffers which have been
541 * filled (one ethernet packet per buffer).
542 */
543static void
544RCrecv_callback (U32 Status,
545		 U8 PktCount,
546		 U32 BucketsRemain,
547		 PU32 PacketDescBlock, struct net_device *dev)
548{
549
550	U32 len, count;
551	PDPA pDpa = dev->priv;
552	struct sk_buff *skb;
553	singleTCB tcb;
554	psingleTCB ptcb = &tcb;
555
556	ptcb->bcount = 1;
557
558	if ((pDpa->shutdown || pDpa->reboot) && !Status)
559		printk (KERN_INFO "%s: shutdown||reboot && !Status (%d)\n",
560				dev->name, PktCount);
561
562	if ((Status != I2O_REPLY_STATUS_SUCCESS) || pDpa->shutdown) {
563		/*
564		 * Free whatever buffers the adapter returned, but don't
565		 * pass them to the kernel.
566		 */
567
568		if (!pDpa->shutdown && !pDpa->reboot)
569			printk (KERN_INFO "%s: recv error status = 0x%x\n",
570					dev->name, (uint) Status);
571		else
572			printk (KERN_DEBUG "%s: Returning %d buffs stat 0x%x\n",
573					dev->name, PktCount, (uint) Status);
574		/*
575		 * TO DO: check the nature of the failure and put the
576		 * adapter in failed mode if it's a hard failure.
577		 * Send a reset to the adapter and free all outstanding memory.
578		 */
579		if (PacketDescBlock) {
580			while (PktCount--) {
581				skb = (struct sk_buff *) PacketDescBlock[0];
582				dev_kfree_skb (skb);
583				pDpa->numOutRcvBuffers--;
584				/* point to next context field */
585				PacketDescBlock += BD_SIZE;
586			}
587		}
588		return;
589	} else {
590		while (PktCount--) {
591			skb = (struct sk_buff *) PacketDescBlock[0];
592			len = PacketDescBlock[2];
593			skb->dev = dev;
594			skb_put (skb, len);	/* adjust length and tail */
595			skb->protocol = eth_type_trans (skb, dev);
596			netif_rx (skb);	/* send the packet to the kernel */
597			dev->last_rx = jiffies;
598			pDpa->numOutRcvBuffers--;
599			/* point to next context field */
600			PacketDescBlock += BD_SIZE;
601		}
602	}
603
604	/*
605	 * Replenish the posted receive buffers.
606	 * DO NOT replenish buffers if the driver has already
607	 * initiated a reboot or shutdown!
608	 */
609
610	if (!pDpa->shutdown && !pDpa->reboot) {
611		count = RC_allocate_and_post_buffers (dev,
612						      MAX_NMBR_RCV_BUFFERS -
613						      pDpa->numOutRcvBuffers);
614		pDpa->numOutRcvBuffers += count;
615	}
616
617}
618
619/*
620 * RCinterrupt()
621 *
622 * Interrupt handler.
623 * This routine sets up a couple of pointers and calls
624 * RCProcI2OMsgQ(), which in turn process the message and
625 * calls one of our callback functions.
626 */
627static void
628RCinterrupt (int irq, void *dev_id, struct pt_regs *regs)
629{
630
631	PDPA pDpa;
632	struct net_device *dev = dev_id;
633
634	pDpa = dev->priv;
635
636	if (pDpa->shutdown)
637		printk (KERN_DEBUG "%s: shutdown, service irq\n",
638				dev->name);
639
640	RCProcI2OMsgQ (dev);
641}
642
643#define REBOOT_REINIT_RETRY_LIMIT 4
644static void
645rc_timer (unsigned long data)
646{
647	struct net_device *dev = (struct net_device *) data;
648	PDPA pDpa = dev->priv;
649	int init_status;
650	static int retry;
651	int post_buffers = MAX_NMBR_RCV_BUFFERS;
652	int count = 0;
653	int requested = 0;
654
655	if (pDpa->reboot) {
656		init_status =
657		    RCInitI2OMsgLayer (dev, (PFNTXCALLBACK) RCxmit_callback,
658				       (PFNRXCALLBACK) RCrecv_callback,
659				       (PFNCALLBACK) RCreboot_callback);
660
661		switch (init_status) {
662		case RC_RTN_NO_ERROR:
663
664			pDpa->reboot = 0;
665			pDpa->shutdown = 0;	/* just in case */
666			RCReportDriverCapability (dev, DriverControlWord);
667			RCEnableI2OInterrupts (dev);
668
669
670			if (!(dev->flags & IFF_UP)) {
671				retry = 0;
672				return;
673			}
674			while (post_buffers) {
675				if (post_buffers >
676						MAX_NMBR_POST_BUFFERS_PER_MSG)
677					requested =
678						MAX_NMBR_POST_BUFFERS_PER_MSG;
679				else
680					requested = post_buffers;
681				count =
682				    RC_allocate_and_post_buffers (dev,
683								  requested);
684				post_buffers -= count;
685				if (count < requested)
686					break;
687			}
688			pDpa->numOutRcvBuffers =
689			    MAX_NMBR_RCV_BUFFERS - post_buffers;
690			printk ("Initialization done.\n");
691			netif_wake_queue (dev);
692			retry = 0;
693			return;
694		case RC_RTN_FREE_Q_EMPTY:
695			retry++;
696			printk (KERN_WARNING "%s inbound free q empty\n",
697					dev->name);
698			break;
699		default:
700			retry++;
701			printk (KERN_WARNING "%s bad stat after reboot: %d\n",
702					dev->name, init_status);
703			break;
704		}
705
706		if (retry > REBOOT_REINIT_RETRY_LIMIT) {
707			printk (KERN_WARNING "%s unable to reinitialize adapter after reboot\n", dev->name);
708			printk (KERN_WARNING "%s decrementing driver and closing interface\n", dev->name);
709			RCDisableI2OInterrupts (dev);
710			dev->flags &= ~IFF_UP;
711			MOD_DEC_USE_COUNT;
712		} else {
713			printk (KERN_INFO "%s: rescheduling timer...\n",
714					dev->name);
715			init_timer (&pDpa->timer);
716			pDpa->timer.expires = RUN_AT ((40 * HZ) / 10);
717			pDpa->timer.data = (unsigned long) dev;
718			pDpa->timer.function = &rc_timer;
719			add_timer (&pDpa->timer);
720		}
721	} else
722		printk (KERN_WARNING "%s: unexpected timer irq\n", dev->name);
723}
724
725static int
726RCclose (struct net_device *dev)
727{
728	PDPA pDpa = dev->priv;
729
730	printk("RCclose\n");
731	netif_stop_queue (dev);
732
733	if (pDpa->reboot) {
734		printk (KERN_INFO "%s skipping reset -- adapter already in reboot mode\n", dev->name);
735		dev->flags &= ~IFF_UP;
736		pDpa->shutdown = 1;
737		MOD_DEC_USE_COUNT;
738		return 0;
739	}
740
741	pDpa->shutdown = 1;
742
743	/*
744	 * We can't allow the driver to be unloaded until the adapter returns
745	 * all posted receive buffers.  It doesn't hurt to tell the adapter
746	 * to return all posted receive buffers and outstanding xmit buffers,
747	 * even if there are none.
748	 */
749
750	RCShutdownLANCard (dev, RC_RESOURCE_RETURN_POSTED_RX_BUCKETS |
751			   RC_RESOURCE_RETURN_PEND_TX_BUFFERS, 0,
752			   (PFNCALLBACK) RCreset_callback);
753
754	dev->flags &= ~IFF_UP;
755	MOD_DEC_USE_COUNT;
756	return 0;
757}
758
759static struct net_device_stats *
760RCget_stats (struct net_device *dev)
761{
762	RCLINKSTATS RCstats;
763
764	PDPA pDpa = dev->priv;
765
766	if (!pDpa) {
767		return 0;
768	} else if (!(dev->flags & IFF_UP)) {
769		return 0;
770	}
771
772	memset (&RCstats, 0, sizeof (RCLINKSTATS));
773	if ((RCGetLinkStatistics (dev, &RCstats, (void *) 0)) ==
774	    RC_RTN_NO_ERROR) {
775
776		/* total packets received    */
777		pDpa->stats.rx_packets = RCstats.Rcv_good
778		/* total packets transmitted    */;
779		pDpa->stats.tx_packets = RCstats.TX_good;
780
781		pDpa->stats.rx_errors = RCstats.Rcv_CRCerr +
782			RCstats.Rcv_alignerr + RCstats.Rcv_reserr +
783			RCstats.Rcv_orun + RCstats.Rcv_cdt + RCstats.Rcv_runt;
784
785		pDpa->stats.tx_errors = RCstats.TX_urun + RCstats.TX_crs +
786			RCstats.TX_def + RCstats.TX_totcol;
787
788		/*
789		 * This needs improvement.
790		 */
791		pDpa->stats.rx_dropped = 0; /* no space in linux buffers   */
792		pDpa->stats.tx_dropped = 0; /* no space available in linux */
793		pDpa->stats.multicast = 0;  /* multicast packets received  */
794		pDpa->stats.collisions = RCstats.TX_totcol;
795
796		/* detailed rx_errors: */
797		pDpa->stats.rx_length_errors = 0;
798		pDpa->stats.rx_over_errors = RCstats.Rcv_orun;
799		pDpa->stats.rx_crc_errors = RCstats.Rcv_CRCerr;
800		pDpa->stats.rx_frame_errors = 0;
801		pDpa->stats.rx_fifo_errors = 0;
802		pDpa->stats.rx_missed_errors = 0;
803
804		/* detailed tx_errors */
805		pDpa->stats.tx_aborted_errors = 0;
806		pDpa->stats.tx_carrier_errors = 0;
807		pDpa->stats.tx_fifo_errors = 0;
808		pDpa->stats.tx_heartbeat_errors = 0;
809		pDpa->stats.tx_window_errors = 0;
810
811		return ((struct net_device_stats *) &(pDpa->stats));
812	}
813	return 0;
814}
815
816static int
817RCioctl (struct net_device *dev, struct ifreq *rq, int cmd)
818{
819	RCuser_struct RCuser;
820	PDPA pDpa = dev->priv;
821
822	if (!capable (CAP_NET_ADMIN))
823		return -EPERM;
824
825	switch (cmd) {
826
827	case RCU_PROTOCOL_REV:
828		/*
829		 * Assign user protocol revision, to tell user-level
830		 * controller program whether or not it's in sync.
831		 */
832		rq->ifr_ifru.ifru_data = (caddr_t) USER_PROTOCOL_REV;
833		break;
834
835	case RCU_COMMAND:
836		{
837			if (copy_from_user
838			    (&RCuser, rq->ifr_data, sizeof (RCuser)))
839				return -EFAULT;
840
841			dprintk ("RCioctl: RCuser_cmd = 0x%x\n", RCuser.cmd);
842
843			switch (RCuser.cmd) {
844			case RCUC_GETFWVER:
845				RCUD_GETFWVER = &RCuser.RCUS_GETFWVER;
846				RCGetFirmwareVer (dev,
847						  (PU8) & RCUD_GETFWVER->
848						  FirmString, NULL);
849				break;
850			case RCUC_GETINFO:
851				RCUD_GETINFO = &RCuser.RCUS_GETINFO;
852				RCUD_GETINFO->mem_start = dev->base_addr;
853				RCUD_GETINFO->mem_end =
854				    dev->base_addr + pDpa->pci_addr_len;
855				RCUD_GETINFO->base_addr = pDpa->pci_addr;
856				RCUD_GETINFO->irq = dev->irq;
857				break;
858			case RCUC_GETIPANDMASK:
859				RCUD_GETIPANDMASK = &RCuser.RCUS_GETIPANDMASK;
860				RCGetRavlinIPandMask (dev,
861						      (PU32) &
862						      RCUD_GETIPANDMASK->IpAddr,
863						      (PU32) &
864						      RCUD_GETIPANDMASK->
865						      NetMask, NULL);
866				break;
867			case RCUC_GETLINKSTATISTICS:
868				RCUD_GETLINKSTATISTICS =
869				    &RCuser.RCUS_GETLINKSTATISTICS;
870				RCGetLinkStatistics (dev,
871						     (P_RCLINKSTATS) &
872						     RCUD_GETLINKSTATISTICS->
873						     StatsReturn, NULL);
874				break;
875			case RCUC_GETLINKSTATUS:
876				RCUD_GETLINKSTATUS = &RCuser.RCUS_GETLINKSTATUS;
877				RCGetLinkStatus (dev,
878						 (PU32) & RCUD_GETLINKSTATUS->
879						 ReturnStatus, NULL);
880				break;
881			case RCUC_GETMAC:
882				RCUD_GETMAC = &RCuser.RCUS_GETMAC;
883				RCGetMAC (dev, NULL);
884				memcpy(RCUD_GETMAC, dev->dev_addr, 8);
885				break;
886			case RCUC_GETPROM:
887				RCUD_GETPROM = &RCuser.RCUS_GETPROM;
888				RCGetPromiscuousMode (dev,
889						      (PU32) & RCUD_GETPROM->
890						      PromMode, NULL);
891				break;
892			case RCUC_GETBROADCAST:
893				RCUD_GETBROADCAST = &RCuser.RCUS_GETBROADCAST;
894				RCGetBroadcastMode (dev,
895						    (PU32) & RCUD_GETBROADCAST->
896						    BroadcastMode, NULL);
897				break;
898			case RCUC_GETSPEED:
899				if (!(dev->flags & IFF_UP)) {
900					return -ENODATA;
901				}
902				RCUD_GETSPEED = &RCuser.RCUS_GETSPEED;
903				RCGetLinkSpeed (dev,
904						(PU32) & RCUD_GETSPEED->
905						LinkSpeedCode, NULL);
906				break;
907			case RCUC_SETIPANDMASK:
908				RCUD_SETIPANDMASK = &RCuser.RCUS_SETIPANDMASK;
909				RCSetRavlinIPandMask (dev,
910						      (U32) RCUD_SETIPANDMASK->
911						      IpAddr,
912						      (U32) RCUD_SETIPANDMASK->
913						      NetMask);
914				break;
915			case RCUC_SETMAC:
916				RCSetMAC (dev, (PU8) & RCUD_SETMAC->mac);
917				break;
918			case RCUC_SETSPEED:
919				RCUD_SETSPEED = &RCuser.RCUS_SETSPEED;
920				RCSetLinkSpeed (dev,
921						(U16) RCUD_SETSPEED->
922						LinkSpeedCode);
923				break;
924			case RCUC_SETPROM:
925				RCUD_SETPROM = &RCuser.RCUS_SETPROM;
926				RCSetPromiscuousMode (dev,
927						      (U16) RCUD_SETPROM->
928						      PromMode);
929				break;
930			case RCUC_SETBROADCAST:
931				RCUD_SETBROADCAST = &RCuser.RCUS_SETBROADCAST;
932				RCSetBroadcastMode (dev,
933						    (U16) RCUD_SETBROADCAST->
934						    BroadcastMode);
935				break;
936			default:
937				RCUD_DEFAULT = &RCuser.RCUS_DEFAULT;
938				RCUD_DEFAULT->rc = 0x11223344;
939				break;
940			}
941			if (copy_to_user (rq->ifr_data, &RCuser,
942						sizeof (RCuser)))
943				return -EFAULT;
944			break;
945		}		/* RCU_COMMAND */
946
947	default:
948		rq->ifr_ifru.ifru_data = (caddr_t) 0x12345678;
949		return -EINVAL;
950	}
951	return 0;
952}
953
954static int
955RCconfig (struct net_device *dev, struct ifmap *map)
956{
957	/*
958	 * To be completed ...
959	 */
960	return 0;
961	if (dev->flags & IFF_UP)	/* can't act on a running interface */
962		return -EBUSY;
963
964	/* Don't allow changing the I/O address */
965	if (map->base_addr != dev->base_addr) {
966		printk (KERN_WARNING "%s Change I/O address not implemented\n",
967				dev->name);
968		return -EOPNOTSUPP;
969	}
970	return 0;
971}
972
973static void __exit
974rcpci_cleanup_module (void)
975{
976	pci_unregister_driver (&rcpci45_driver);
977}
978
979module_init (rcpci_init_module);
980module_exit (rcpci_cleanup_module);
981
982static int
983RC_allocate_and_post_buffers (struct net_device *dev, int numBuffers)
984{
985
986	int i;
987	PU32 p;
988	psingleB pB;
989	struct sk_buff *skb;
990	RC_RETURN status;
991	U32 res;
992
993	if (!numBuffers)
994		return 0;
995	else if (numBuffers > MAX_NMBR_POST_BUFFERS_PER_MSG) {
996		printk (KERN_ERR "%s: Too many buffers requested!\n",
997				dev->name);
998		numBuffers = 32;
999	}
1000
1001	p = (PU32) kmalloc (sizeof (U32) + numBuffers * sizeof (singleB),
1002			    GFP_DMA|GFP_ATOMIC|GFP_KERNEL);
1003
1004	if (!p) {
1005		printk (KERN_WARNING "%s unable to allocate TCB\n",
1006				dev->name);
1007		return 0;
1008	}
1009
1010	p[0] = 0;		/* Buffer Count */
1011	pB = (psingleB) ((U32) p + sizeof (U32));/* point to the first buffer */
1012
1013	for (i = 0; i < numBuffers; i++) {
1014		skb = dev_alloc_skb (MAX_ETHER_SIZE + 2);
1015		if (!skb) {
1016			printk (KERN_WARNING
1017					"%s: unable to allocate enough skbs!\n",
1018					dev->name);
1019			if (*p != 0) {	/* did we allocate any buffers */
1020				break;
1021			} else {
1022				kfree (p);	/* Free the TCB */
1023				return 0;
1024			}
1025		}
1026		skb_reserve (skb, 2);	/* Align IP on 16 byte boundaries */
1027		pB->context = (U32) skb;
1028		pB->scount = 1;	/* segment count */
1029		pB->size = MAX_ETHER_SIZE;
1030		pB->addr = virt_to_bus ((void *) skb->data);
1031		p[0]++;
1032		pB++;
1033	}
1034
1035	if ((status = RCPostRecvBuffers (dev, (PRCTCB) p)) != RC_RTN_NO_ERROR) {
1036		printk (KERN_WARNING "%s: Post buffer failed, error 0x%x\n",
1037				dev->name, status);
1038		/* point to the first buffer */
1039		pB = (psingleB) ((U32) p + sizeof (U32));
1040		while (p[0]) {
1041			skb = (struct sk_buff *) pB->context;
1042			dev_kfree_skb (skb);
1043			p[0]--;
1044			pB++;
1045		}
1046	}
1047	res = p[0];
1048	kfree (p);
1049	return (res);		/* return the number of posted buffers */
1050}
1051