ieee1394: eth1394: coding style

/*

 * eth1394.c -- Ethernet driver for Linux IEEE-1394 Subsystem

 * eth1394.c -- IPv4 driver for Linux IEEE-1394 Subsystem

 *

 * Copyright (C) 2001-2003 Ben Collins <bcollins@debian.org>

 *               2000 Bonin Franck <boninf@free.fr>

 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 */

/* This driver intends to support RFC 2734, which describes a method for

 * transporting IPv4 datagrams over IEEE-1394 serial busses. This driver

 * will ultimately support that method, but currently falls short in

 * several areas.

/*

 * This driver intends to support RFC 2734, which describes a method for

 * transporting IPv4 datagrams over IEEE-1394 serial busses.

 *

 * TODO:

 * RFC 2734 related:

 * - Consider garbage collecting old partial datagrams after X amount of time

 */

#include <linux/module.h>

#include <linux/kernel.h>

#define ETH1394_PRINT(level, dev_name, fmt, args...) \

	printk(level "%s: %s: " fmt, driver_name, dev_name, ## args)

#define DEBUG(fmt, args...) \

	printk(KERN_ERR "%s:%s[%d]: " fmt "\n", driver_name, __FUNCTION__, __LINE__, ## args)

#define TRACE() printk(KERN_ERR "%s:%s[%d] ---- TRACE\n", driver_name, __FUNCTION__, __LINE__)

struct fragment_info {

	struct list_head list;

	int offset;

};

struct eth1394_node_info {

	u16 maxpayload;			/* Max payload			*/

	u8 sspd;			/* Max speed			*/

	u16 maxpayload;		/* max payload			*/

	u8 sspd;		/* max speed			*/

	u64 fifo;		/* FIFO address			*/

	struct pdg_list pdg;	/* partial RX datagram lists	*/

	int dgl;			/* Outgoing datagram label	*/

	int dgl;		/* outgoing datagram label	*/

};

/* Our ieee1394 highlevel driver */

#define ETH1394_DRIVER_NAME "eth1394"

static const char driver_name[] = ETH1394_DRIVER_NAME;

static const char driver_name[] = "eth1394";

static struct kmem_cache *packet_task_cache;

	sizeof(struct eth1394_sf_hdr)

};

/* Change this to IEEE1394_SPEED_S100 to make testing easier */

#define ETH1394_SPEED_DEF	IEEE1394_SPEED_MAX

/* For now, this needs to be 1500, so that XP works with us */

#define ETH1394_DATA_LEN	ETH_DATA_LEN

MODULE_DESCRIPTION("IEEE 1394 IPv4 Driver (IPv4-over-1394 as per RFC 2734)");

MODULE_LICENSE("GPL");

/* The max_partial_datagrams parameter is the maximum number of fragmented

/*

 * The max_partial_datagrams parameter is the maximum number of fragmented

 * datagrams per node that eth1394 will keep in memory.  Providing an upper

 * bound allows us to limit the amount of memory that partial datagrams

 * consume in the event that some partial datagrams are never completed.

					  unsigned char *haddr);

static int ether1394_mac_addr(struct net_device *dev, void *p);

static void purge_partial_datagram(struct list_head *old);

static int ether1394_tx(struct sk_buff *skb, struct net_device *dev);

static void ether1394_iso(struct hpsb_iso *iso);

	.host_reset =	ether1394_host_reset,

};

static int ether1394_recv_init(struct net_device *dev)

{

	struct eth1394_priv *priv = netdev_priv(dev);

	unsigned int iso_buf_size;

	/* FIXME: rawiso limits us to PAGE_SIZE */

	iso_buf_size = min((unsigned int)PAGE_SIZE,

			   2 * (1U << (priv->host->csr.max_rec + 1)));

	priv->iso = hpsb_iso_recv_init(priv->host,

				       ETHER1394_ISO_BUF_SIZE,

				       ETHER1394_GASP_BUFFERS * iso_buf_size,

				       ETHER1394_GASP_BUFFERS,

				       priv->broadcast_channel,

				       HPSB_ISO_DMA_PACKET_PER_BUFFER,

	struct eth1394_priv *priv = netdev_priv(dev);

	int ret;

	/* Something bad happened, don't even try */

	if (priv->bc_state == ETHER1394_BC_ERROR) {

		/* we'll try again */

		ret = ether1394_recv_init(dev);

		if (ret)

			return ret;

	}

	netif_start_queue(dev);

	return 0;

}

	return &(((struct eth1394_priv *)netdev_priv(dev))->stats);

}

/* What to do if we timeout. I think a host reset is probably in order, so

 * that's what we do. Should we increment the stat counters too?  */

/* FIXME: What to do if we timeout? I think a host reset is probably in order,

 * so that's what we do. Should we increment the stat counters too?  */

static void ether1394_tx_timeout(struct net_device *dev)

{

	ETH1394_PRINT (KERN_ERR, dev->name, "Timeout, resetting host %s\n",

		       ((struct eth1394_priv *)netdev_priv(dev))->host->driver->name);

	highlevel_host_reset (((struct eth1394_priv *)netdev_priv(dev))->host);

	struct hpsb_host *host =

			((struct eth1394_priv *)netdev_priv(dev))->host;

	ETH1394_PRINT(KERN_ERR, dev->name, "Timeout, resetting host %s\n",

		      host->driver->name);

	highlevel_host_reset(host);

	netif_wake_queue(dev);

}

static int ether1394_change_mtu(struct net_device *dev, int new_mtu)

{

	struct eth1394_priv *priv = netdev_priv(dev);

	int max_rec =

		((struct eth1394_priv *)netdev_priv(dev))->host->csr.max_rec;

	if ((new_mtu < 68) ||

	    (new_mtu > min(ETH1394_DATA_LEN,

			   (int)((1 << (priv->host->csr.max_rec + 1)) -

				 (sizeof(union eth1394_hdr) +

				  ETHER1394_GASP_OVERHEAD)))))

	if (new_mtu < 68 ||

	    new_mtu > ETH1394_DATA_LEN ||

	    new_mtu > (1 << (max_rec + 1)) - sizeof(union eth1394_hdr) -

		      ETHER1394_GASP_OVERHEAD)

		return -EINVAL;

	dev->mtu = new_mtu;

	return 0;

}

static void purge_partial_datagram(struct list_head *old)

{

	struct partial_datagram *pd = list_entry(old, struct partial_datagram, list);

	struct partial_datagram *pd;

	struct list_head *lh, *n;

	struct fragment_info *fi;

	pd = list_entry(old, struct partial_datagram, list);

	list_for_each_safe(lh, n, &pd->frag_info) {

		struct fragment_info *fi = list_entry(lh, struct fragment_info, list);

		fi = list_entry(lh, struct fragment_info, list);

		list_del(lh);

		kfree(fi);

	}

							 nodeid_t nodeid)

{

	struct eth1394_node_ref *node;

	list_for_each_entry(node, inl, list) {

	list_for_each_entry(node, inl, list)

		if (node->ud->ne->nodeid == nodeid)

			return node;

	}

	return NULL;

}

	priv = netdev_priv(hi->dev);

	old_node = eth1394_find_node(&priv->ip_node_list, ud);

	if (!old_node)

		return 0;

	if (old_node) {

	list_del(&old_node->list);

	kfree(old_node);

	spin_lock_irqsave(&node_info->pdg.lock, flags);

	/* The partial datagram list should be empty, but we'll just

	 * make sure anyway... */

		list_for_each_safe(lh, n, &node_info->pdg.list) {

	list_for_each_safe(lh, n, &node_info->pdg.list)

		purge_partial_datagram(lh);

		}

	spin_unlock_irqrestore(&node_info->pdg.lock, flags);

	kfree(node_info);

	ud->device.driver_data = NULL;

	}

	return 0;

}

	priv = netdev_priv(hi->dev);

	node = eth1394_find_node(&priv->ip_node_list, ud);

	if (node)

		return 0;

	if (!node) {

	node = kmalloc(sizeof(*node),

		       in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);

	if (!node)

	priv = netdev_priv(hi->dev);

	list_add_tail(&node->list, &priv->ip_node_list);

	}

	return 0;

}

static struct ieee1394_device_id eth1394_id_table[] = {

	{

		.match_flags = (IEEE1394_MATCH_SPECIFIER_ID |

MODULE_DEVICE_TABLE(ieee1394, eth1394_id_table);

static struct hpsb_protocol_driver eth1394_proto_driver = {

	.name		= ETH1394_DRIVER_NAME,

	.name		= driver_name,

	.id_table	= eth1394_id_table,

	.update		= eth1394_update,

	.driver		= {

	},

};

static void ether1394_reset_priv(struct net_device *dev, int set_mtu)

{

	unsigned long flags;

	struct eth1394_priv *priv = netdev_priv(dev);

	struct hpsb_host *host = priv->host;

	u64 guid = get_unaligned((u64 *)&(host->csr.rom->bus_info_data[3]));

	u16 maxpayload = 1 << (host->csr.max_rec + 1);

	int max_speed = IEEE1394_SPEED_MAX;

	spin_lock_irqsave(&priv->lock, flags);

			max_speed = host->speed[i];

	priv->bc_sspd = max_speed;

	/* We'll use our maxpayload as the default mtu */

	/* We'll use our maximum payload as the default MTU */

	if (set_mtu) {

		int max_payload = 1 << (host->csr.max_rec + 1);

		dev->mtu = min(ETH1394_DATA_LEN,

			       (int)(maxpayload -

				     (sizeof(union eth1394_hdr) +

				      ETHER1394_GASP_OVERHEAD)));

			       (int)(max_payload - sizeof(union eth1394_hdr) -

				     ETHER1394_GASP_OVERHEAD));

		/* Set our hardware address while we're at it */

		memcpy(dev->dev_addr, &guid, sizeof(u64));

	free_netdev(hi->dev);

}

/* A reset has just arisen */

/* A bus reset happened */

static void ether1394_host_reset(struct hpsb_host *host)

{

	struct eth1394_host_info *hi;

		return;

	dev = hi->dev;

	priv = (struct eth1394_priv *)netdev_priv(dev);

	priv = netdev_priv(dev);

	/* Reset our private host data, but not our mtu */

	/* Reset our private host data, but not our MTU */

	netif_stop_queue(dev);

	ether1394_reset_priv(dev, 0);

	list_for_each_entry(node, &priv->ip_node_list, list) {

		node_info = (struct eth1394_node_info*)node->ud->device.driver_data;

		node_info = node->ud->device.driver_data;

		spin_lock_irqsave(&node_info->pdg.lock, flags);

		list_for_each_safe(lh, n, &node_info->pdg.list) {

		list_for_each_safe(lh, n, &node_info->pdg.list)

			purge_partial_datagram(lh);

		}

		INIT_LIST_HEAD(&(node_info->pdg.list));

		node_info->pdg.sz = 0;

 ******************************************/

/* These functions have been adapted from net/ethernet/eth.c */

/* Create a fake MAC header for an arbitrary protocol layer.

 * saddr=NULL means use device source address

 * daddr=NULL means leave destination address (eg unresolved arp). */

			    unsigned short type, void *daddr, void *saddr,

			    unsigned len)

{

	struct eth1394hdr *eth = (struct eth1394hdr *)skb_push(skb, ETH1394_HLEN);

	struct eth1394hdr *eth =

			(struct eth1394hdr *)skb_push(skb, ETH1394_HLEN);

	eth->h_proto = htons(type);

	if (dev->flags & (IFF_LOOPBACK | IFF_NOARP)) {

		memset(eth->h_dest, 0, dev->addr_len);

		return(dev->hard_header_len);

		return dev->hard_header_len;

	}

	if (daddr) {

	}

	return -dev->hard_header_len;

}

/* Rebuild the faked MAC header. This is called after an ARP

 * (or in future other address resolution) has completed on this

 * sk_buff. We now let ARP fill in the other fields.

static int ether1394_header_parse(struct sk_buff *skb, unsigned char *haddr)

{

	struct net_device *dev = skb->dev;

	memcpy(haddr, dev->dev_addr, ETH1394_ALEN);

	return ETH1394_ALEN;

}

static int ether1394_header_cache(struct neighbour *neigh, struct hh_cache *hh)

{

	unsigned short type = hh->hh_type;

	struct eth1394hdr *eth = (struct eth1394hdr*)(((u8*)hh->hh_data) +

						      (16 - ETH1394_HLEN));

	struct net_device *dev = neigh->dev;

	struct eth1394hdr *eth =

		(struct eth1394hdr *)((u8 *)hh->hh_data + 16 - ETH1394_HLEN);

	if (type == htons(ETH_P_802_3))

		return -1;

					  struct net_device *dev,

					  unsigned char * haddr)

{

	memcpy(((u8*)hh->hh_data) + (16 - ETH1394_HLEN), haddr, dev->addr_len);

	memcpy((u8 *)hh->hh_data + 16 - ETH1394_HLEN, haddr, dev->addr_len);

}

static int ether1394_mac_addr(struct net_device *dev, void *p)

	 return -EINVAL;

}

/******************************************

 * Datagram reception code

 ******************************************/

	u64 dest_hw;

	unsigned short ret = 0;

	/* Setup our hw addresses. We use these to build the

	 * ethernet header.  */

	/* Setup our hw addresses. We use these to build the ethernet header. */

	if (destid == (LOCAL_BUS | ALL_NODES))

		dest_hw = ~0ULL;  /* broadcast */

	else

		dest_hw = cpu_to_be64((((u64)priv->host->csr.guid_hi) << 32) |

		dest_hw = cpu_to_be64((u64)priv->host->csr.guid_hi << 32 |

				      priv->host->csr.guid_lo);

	/* If this is an ARP packet, convert it. First, we want to make

		if (sspd > 5 || sspd < 0)

			sspd = 0;

		maxpayload = min(eth1394_speedto_maxpayload[sspd], (u16)(1 << (max_rec + 1)));

		maxpayload = min(eth1394_speedto_maxpayload[sspd],

				 (u16)(1 << (max_rec + 1)));

		guid = get_unaligned(&arp1394->s_uniq_id);

		node = eth1394_find_node_guid(&priv->ip_node_list,

					      be64_to_cpu(guid));

		if (!node) {

		if (!node)

			return 0;

		}

		node_info = (struct eth1394_node_info*)node->ud->device.driver_data;

		node_info =

		    (struct eth1394_node_info *)node->ud->device.driver_data;

		/* Update our speed/payload/fifo_offset table */

		node_info->maxpayload =	maxpayload;

{

	struct partial_datagram *pd;

	list_for_each_entry(pd, pdgl, list) {

	list_for_each_entry(pd, pdgl, list)

		if (pd->dgl == dgl)

			return &pd->list;

	}

	return NULL;

}

	list_for_each(lh, frag_info) {

		fi = list_entry(lh, struct fragment_info, list);

		if ((fi->offset + fi->len) == offset) {

		if (fi->offset + fi->len == offset) {

			/* The new fragment can be tacked on to the end */

			fi->len += len;

			/* Did the new fragment plug a hole? */

			fi2 = list_entry(lh->next, struct fragment_info, list);

			if ((fi->offset + fi->len) == fi2->offset) {

			if (fi->offset + fi->len == fi2->offset) {

				/* glue fragments together */

				fi->len += fi2->len;

				list_del(lh->next);

				kfree(fi2);

			}

			return 0;

		} else if ((offset + len) == fi->offset) {

		} else if (offset + len == fi->offset) {

			/* The new fragment can be tacked on to the beginning */

			fi->offset = offset;

			fi->len += len;

			/* Did the new fragment plug a hole? */

			fi2 = list_entry(lh->prev, struct fragment_info, list);

			if ((fi2->offset + fi2->len) == fi->offset) {

			if (fi2->offset + fi2->len == fi->offset) {

				/* glue fragments together */

				fi2->len += fi->len;

				list_del(lh);

				kfree(fi);

			}

			return 0;

		} else if (offset > (fi->offset + fi->len)) {

		} else if (offset > fi->offset + fi->len) {

			break;

		} else if ((offset + len) < fi->offset) {

		} else if (offset + len < fi->offset) {

			lh = lh->prev;

			break;

		}

	new->len = len;

	list_add(&new->list, lh);

	return 0;

}

	memcpy(new->pbuf + frag_off, frag_buf, frag_len);

	list_add(&new->list, pdgl);

	return 0;

}

static int update_partial_datagram(struct list_head *pdgl, struct list_head *lh,

				   char *frag_buf, int frag_off, int frag_len)

{

	struct partial_datagram *pd = list_entry(lh, struct partial_datagram, list);

	struct partial_datagram *pd =

			list_entry(lh, struct partial_datagram, list);

	if (new_fragment(&pd->frag_info, frag_off, frag_len) < 0) {

	if (new_fragment(&pd->frag_info, frag_off, frag_len) < 0)

		return -ENOMEM;

	}

	memcpy(pd->pbuf + frag_off, frag_buf, frag_len);

	/* Move list entry to beginnig of list so that oldest partial

	 * datagrams percolate to the end of the list */

	list_move(lh, pdgl);

	return 0;

}

			return -1;

		}

		skb_reserve(skb, (dev->hard_header_len + 15) & ~15);

		memcpy(skb_put(skb, len - hdr_len), buf + hdr_len, len - hdr_len);

		memcpy(skb_put(skb, len - hdr_len), buf + hdr_len,

		       len - hdr_len);

		ether_type = hdr->uf.ether_type;

	} else {

		/* A datagram fragment has been received, now the fun begins. */

		pd = list_entry(lh, struct partial_datagram, list);

		if (hdr->common.lf == ETH1394_HDR_LF_FF) {

		if (hdr->common.lf == ETH1394_HDR_LF_FF)

			pd->ether_type = ether_type;

		}

		if (is_datagram_complete(lh, dg_size)) {

			ether_type = pd->ether_type;

	skb->protocol = ether1394_parse_encap(skb, dev, srcid, destid,

					      ether_type);

	spin_lock_irqsave(&priv->lock, flags);

	if (!skb->protocol) {

		priv->stats.rx_errors++;

		priv->stats.rx_dropped++;

		buf = (char *)data + 8;

		len = info->len - 8;

		specifier_id = (((be32_to_cpu(data[0]) & 0xffff) << 8) |

				((be32_to_cpu(data[1]) & 0xff000000) >> 24));

		specifier_id = (be32_to_cpu(data[0]) & 0xffff) << 8 |

			       (be32_to_cpu(data[1]) & 0xff000000) >> 24;

		source_id = be32_to_cpu(data[0]) >> 16;

		priv = netdev_priv(dev);

		if (info->channel != (iso->host->csr.broadcast_channel & 0x3f) ||

		   specifier_id != ETHER1394_GASP_SPECIFIER_ID) {

		if (info->channel != (iso->host->csr.broadcast_channel & 0x3f)

		    || specifier_id != ETHER1394_GASP_SPECIFIER_ID) {

			/* This packet is not for us */

			continue;

		}

				     struct net_device *dev)

{

	struct eth1394_priv *priv = netdev_priv(dev);

	struct arphdr *arp = (struct arphdr *)skb->data;

	unsigned char *arp_ptr = (unsigned char *)(arp + 1);

	struct eth1394_arp *arp1394 = (struct eth1394_arp *)skb->data;

	/* Believe it or not, all that need to happen is sender IP get moved

	 * and set hw_addr_len, max_rec, sspd, fifo_hi and fifo_lo.  */

	arp1394->hw_addr_len	= 16;

	arp1394->sip		= *(u32*)(arp_ptr + ETH1394_ALEN);

	arp1394->max_rec	= priv->host->csr.max_rec;

	arp1394->sspd		= priv->host->csr.lnk_spd;

	arp1394->fifo_hi	= htons(priv->local_fifo >> 32);

	arp1394->fifo_lo	= htonl(priv->local_fifo & ~0x0);

	return;

}

/* We need to encapsulate the standard header with our own. We use the

					       union eth1394_hdr *hdr,

					       u16 dg_size, u16 dgl)

{

	unsigned int adj_max_payload = max_payload - hdr_type_len[ETH1394_HDR_LF_UF];

	unsigned int adj_max_payload =

				max_payload - hdr_type_len[ETH1394_HDR_LF_UF];

	/* Does it all fit in one packet? */

	if (dg_size <= adj_max_payload) {

		hdr->ff.dgl = dgl;

		adj_max_payload = max_payload - hdr_type_len[ETH1394_HDR_LF_FF];

	}

	return((dg_size + (adj_max_payload - 1)) / adj_max_payload);

	return (dg_size + adj_max_payload - 1) / adj_max_payload;

}

static unsigned int ether1394_encapsulate(struct sk_buff *skb,