[mirror_ubuntu-bionic-kernel.git] / drivers / net / wan / lmc / lmc_proto.c

 /*
  * Copyright (c) 1997-2000 LAN Media Corporation (LMC)
  * All rights reserved.  www.lanmedia.com
  *
  * This code is written by:
  * Andrew Stanley-Jones (asj@cban.com)
  * Rob Braun (bbraun@vix.com),
  * Michael Graff (explorer@vix.com) and
  * Matt Thomas (matt@3am-software.com).
  *
  * With Help By:
  * David Boggs
  * Ron Crane
  * Allan Cox
  *
  * This software may be used and distributed according to the terms
  * of the GNU General Public License version 2, incorporated herein by reference.
  *
  * Driver for the LanMedia LMC5200, LMC5245, LMC1000, LMC1200 cards.
  */

#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/ptrace.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/in.h>
#include <linux/if_arp.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/inet.h>
#include <linux/workqueue.h>
#include <linux/proc_fs.h>
#include <linux/bitops.h>
#include <asm/processor.h>             /* Processor type for cache alignment. */
#include <asm/io.h>
#include <asm/dma.h>
#include <linux/smp.h>

#include "lmc.h"
#include "lmc_var.h"
#include "lmc_debug.h"
#include "lmc_ioctl.h"
#include "lmc_proto.h"

// attach
void lmc_proto_attach(lmc_softc_t *sc) /*FOLD00*/
{
    lmc_trace(sc->lmc_device, "lmc_proto_attach in");
    if (sc->if_type == LMC_NET) {
            struct net_device *dev = sc->lmc_device;
            /*
	     * They set a few basics because they don't use HDLC
             */
            dev->flags |= IFF_POINTOPOINT;
            dev->hard_header_len = 0;
            dev->addr_len = 0;
        }
    lmc_trace(sc->lmc_device, "lmc_proto_attach out");
}

int lmc_proto_ioctl(lmc_softc_t *sc, struct ifreq *ifr, int cmd)
{
	lmc_trace(sc->lmc_device, "lmc_proto_ioctl");
	if (sc->if_type == LMC_PPP)
		return hdlc_ioctl(sc->lmc_device, ifr, cmd);
	return -EOPNOTSUPP;
}

int lmc_proto_open(lmc_softc_t *sc)
{
	int ret = 0;

	lmc_trace(sc->lmc_device, "lmc_proto_open in");

	if (sc->if_type == LMC_PPP) {
		ret = hdlc_open(sc->lmc_device);
		if (ret < 0)
			printk(KERN_WARNING "%s: HDLC open failed: %d\n",
			       sc->name, ret);
	}

	lmc_trace(sc->lmc_device, "lmc_proto_open out");
	return ret;
}

void lmc_proto_close(lmc_softc_t *sc)
{
	lmc_trace(sc->lmc_device, "lmc_proto_close in");

	if (sc->if_type == LMC_PPP)
		hdlc_close(sc->lmc_device);

	lmc_trace(sc->lmc_device, "lmc_proto_close out");
}

__be16 lmc_proto_type(lmc_softc_t *sc, struct sk_buff *skb) /*FOLD00*/
{
    lmc_trace(sc->lmc_device, "lmc_proto_type in");
    switch(sc->if_type){
    case LMC_PPP:
	    return hdlc_type_trans(skb, sc->lmc_device);
	    break;
    case LMC_NET:
        return htons(ETH_P_802_2);
        break;
    case LMC_RAW: /* Packet type for skbuff kind of useless */
        return htons(ETH_P_802_2);
        break;
    default:
        printk(KERN_WARNING "%s: No protocol set for this interface, assuming 802.2 (which is wrong!!)\n", sc->name);
        return htons(ETH_P_802_2);
        break;
    }
    lmc_trace(sc->lmc_device, "lmc_proto_tye out");

}

void lmc_proto_netif(lmc_softc_t *sc, struct sk_buff *skb) /*FOLD00*/
{
    lmc_trace(sc->lmc_device, "lmc_proto_netif in");
    switch(sc->if_type){
    case LMC_PPP:
    case LMC_NET:
    default:
        netif_rx(skb);
        break;
    case LMC_RAW:
        break;
    }
    lmc_trace(sc->lmc_device, "lmc_proto_netif out");
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (c) 1997-2000 LAN Media Corporation (LMC)
	3	* All rights reserved. www.lanmedia.com
	4	*
	5	* This code is written by:
	6	* Andrew Stanley-Jones (asj@cban.com)
	7	* Rob Braun (bbraun@vix.com),
	8	* Michael Graff (explorer@vix.com) and
	9	* Matt Thomas (matt@3am-software.com).
	10	*
	11	* With Help By:
	12	* David Boggs
	13	* Ron Crane
	14	* Allan Cox
	15	*
	16	* This software may be used and distributed according to the terms
	17	* of the GNU General Public License version 2, incorporated herein by reference.
	18	*
	19	* Driver for the LanMedia LMC5200, LMC5245, LMC1000, LMC1200 cards.
	20	*/
	21
	22	#include <linux/kernel.h>
	23	#include <linux/string.h>
	24	#include <linux/timer.h>
	25	#include <linux/ptrace.h>
	26	#include <linux/errno.h>
	27	#include <linux/ioport.h>
	28	#include <linux/slab.h>
	29	#include <linux/interrupt.h>
1da177e4 LT	30	#include <linux/in.h>
	31	#include <linux/if_arp.h>
	32	#include <linux/netdevice.h>
	33	#include <linux/etherdevice.h>
	34	#include <linux/skbuff.h>
	35	#include <linux/inet.h>
	36	#include <linux/workqueue.h>
	37	#include <linux/proc_fs.h>
	38	#include <linux/bitops.h>
1da177e4 LT	39	#include <asm/processor.h> /* Processor type for cache alignment. */
	40	#include <asm/io.h>
	41	#include <asm/dma.h>
	42	#include <linux/smp.h>
	43
	44	#include "lmc.h"
	45	#include "lmc_var.h"
	46	#include "lmc_debug.h"
	47	#include "lmc_ioctl.h"
	48	#include "lmc_proto.h"
	49
1da177e4 LT	50	// attach
	51	void lmc_proto_attach(lmc_softc_t sc) /FOLD00*/
	52	{
	53	lmc_trace(sc->lmc_device, "lmc_proto_attach in");
991990a1	54	if (sc->if_type == LMC_NET) {
1da177e4 LT	55	struct net_device *dev = sc->lmc_device;
1da177e4 LT	56	/*
64bef763	57	* They set a few basics because they don't use HDLC
1da177e4 LT	58	*/
1da177e4 LT	59	dev->flags \|= IFF_POINTOPOINT;
1da177e4 LT	60	dev->hard_header_len = 0;
	61	dev->addr_len = 0;
	62	}
1da177e4 LT	63	lmc_trace(sc->lmc_device, "lmc_proto_attach out");
	64	}
	65
64bef763	66	int lmc_proto_ioctl(lmc_softc_t sc, struct ifreq ifr, int cmd)
1da177e4	67	{
64bef763 KH	68	lmc_trace(sc->lmc_device, "lmc_proto_ioctl");
	69	if (sc->if_type == LMC_PPP)
	70	return hdlc_ioctl(sc->lmc_device, ifr, cmd);
	71	return -EOPNOTSUPP;
1da177e4 LT	72	}
1da177e4 LT	73
64bef763	74	int lmc_proto_open(lmc_softc_t *sc)
1da177e4	75	{
64bef763	76	int ret = 0;
1da177e4	77
64bef763	78	lmc_trace(sc->lmc_device, "lmc_proto_open in");
1da177e4	79
64bef763 KH	80	if (sc->if_type == LMC_PPP) {
	81	ret = hdlc_open(sc->lmc_device);
	82	if (ret < 0)
	83	printk(KERN_WARNING "%s: HDLC open failed: %d\n",
	84	sc->name, ret);
	85	}
	86
	87	lmc_trace(sc->lmc_device, "lmc_proto_open out");
	88	return ret;
1da177e4 LT	89	}
1da177e4 LT	90
64bef763	91	void lmc_proto_close(lmc_softc_t *sc)
1da177e4	92	{
64bef763	93	lmc_trace(sc->lmc_device, "lmc_proto_close in");
1da177e4	94
64bef763 KH	95	if (sc->if_type == LMC_PPP)
64bef763 KH	96	hdlc_close(sc->lmc_device);
1da177e4	97
64bef763	98	lmc_trace(sc->lmc_device, "lmc_proto_close out");
1da177e4 LT	99	}
1da177e4 LT	100
90458401	101	__be16 lmc_proto_type(lmc_softc_t sc, struct sk_buff skb) /FOLD00/
1da177e4 LT	102	{
	103	lmc_trace(sc->lmc_device, "lmc_proto_type in");
	104	switch(sc->if_type){
	105	case LMC_PPP:
64bef763 KH	106	return hdlc_type_trans(skb, sc->lmc_device);
64bef763 KH	107	break;
1da177e4 LT	108	case LMC_NET:
	109	return htons(ETH_P_802_2);
	110	break;
	111	case LMC_RAW: /* Packet type for skbuff kind of useless */
	112	return htons(ETH_P_802_2);
	113	break;
	114	default:
	115	printk(KERN_WARNING "%s: No protocol set for this interface, assuming 802.2 (which is wrong!!)\n", sc->name);
	116	return htons(ETH_P_802_2);
	117	break;
	118	}
	119	lmc_trace(sc->lmc_device, "lmc_proto_tye out");
	120
	121	}
	122
	123	void lmc_proto_netif(lmc_softc_t sc, struct sk_buff skb) /FOLD00/
	124	{
	125	lmc_trace(sc->lmc_device, "lmc_proto_netif in");
	126	switch(sc->if_type){
	127	case LMC_PPP:
	128	case LMC_NET:
	129	default:
1da177e4 LT	130	netif_rx(skb);
	131	break;
	132	case LMC_RAW:
	133	break;
	134	}
	135	lmc_trace(sc->lmc_device, "lmc_proto_netif out");
	136	}