firewire: nosy: misc cleanups

Extend copyright note to 2007, c.f. Kristian's git log.

Includes:
  - replace some <asm/*.h> by <linux/*.h>
  - add required indirectly included <linux/spinlock.h>
  - order alphabetically

Coding style related changes:
  - change to utf8
  - normalize whitespace
  - normalize comment style
  - remove usages of __FUNCTION__
  - remove an unnecessary cast from void *

Const and static declarations:
  - driver_name is not const in pci_driver.name, drop const qualifier
  - driver_name can be taken from KBUILD_MODNAME
  - the global variable minors[] can and should be static
  - constify struct file_operations instance

Data types:
  - Remove unused struct member struct packet.code.  struct packet is
    only used for driver-internal bookkeeping; it does not appear on the
    wire or in DMA programs or the userspace ABI.  Hence the unused
    member .code can be removed without worries.

Preprocessor macros:
  - unroll a preprocessor macro that containd a return
  - use list_for_each_entry

Printk:
  - add missing terminating \n in some format strings
Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>

drivers/firewire/nosy-user.h

 #ifndef __nosy_user_h
 #define __nosy_user_h
 
-#include <asm/ioctl.h>
-#include <asm/types.h>
+#include <linux/ioctl.h>
+#include <linux/types.h>
 
 #define NOSY_IOC_GET_STATS _IOR('&', 0, struct nosy_stats)
 #define NOSY_IOC_START     _IO('&', 1)

drivers/firewire/nosy.c

-/* -*- c-file-style: "linux" -*-
- *
- * nosy.c - Snoop mode driver for TI pcilynx 1394 controllers
- * Copyright (C) 2002 Kristian Hgsberg
+/*
+ * nosy - Snoop mode driver for TI PCILynx 1394 controllers
+ * Copyright (C) 2002-2007 Kristian Høgsberg
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,23 +17,25 @@
  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/interrupt.h>
-#include <linux/sched.h> /* required for linux/wait.h */
-#include <linux/wait.h>
 #include <linux/errno.h>
-#include <linux/module.h>
+#include <linux/fs.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
 #include <linux/pci.h>
-#include <linux/fs.h>
 #include <linux/poll.h>
-#include <linux/miscdevice.h>
-#include <asm/byteorder.h>
+#include <linux/sched.h> /* required for linux/wait.h */
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/timex.h>
+#include <linux/uaccess.h>
+#include <linux/wait.h>
+
 #include <asm/atomic.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
-#include <asm/timex.h>
+#include <asm/byteorder.h>
 
 #include "nosy.h"
 #include "nosy-user.h"
@@ -46,7 +47,7 @@
 #define error(s, args...) printk(KERN_ERR s, ## args)
 #define debug(s, args...) printk(KERN_DEBUG s, ## args)
 
-static const char driver_name[] = "nosy";
+static char driver_name[] = KBUILD_MODNAME;
 
 struct pcl_status {
 	unsigned int transfer_count : 13;
@@ -77,8 +78,7 @@ struct pcl {
 } __attribute__ ((packed));
 
 struct packet {
-	unsigned int length : 16;
-	unsigned int code : 16;
+	unsigned int length;
 	char data[0];
 };
 
@@ -106,7 +106,6 @@ struct pcilynx {
 	struct miscdevice misc;
 };
 
-
 struct client {
 	struct pcilynx *lynx;
 	unsigned long tcode_mask;
@@ -115,7 +114,7 @@ struct client {
 };
 
 #define MAX_MINORS 64
-struct pcilynx *minors[MAX_MINORS];
+static struct pcilynx *minors[MAX_MINORS];
 
 static int
 packet_buffer_init(struct packet_buffer *buffer, size_t capacity)
@@ -158,8 +157,7 @@ packet_buffer_get(struct packet_buffer *buffer, void *data, size_t user_length)
 		if (copy_to_user(data, buffer->head->data, length))
 			return -EFAULT;
 		buffer->head = (struct packet *) &buffer->head->data[length];
-	}
-	else {
+	} else {
 		size_t split = end - buffer->head->data;
 
 		if (copy_to_user(data, buffer->head->data, split))
@@ -169,11 +167,12 @@ packet_buffer_get(struct packet_buffer *buffer, void *data, size_t user_length)
 		buffer->head = (struct packet *) &buffer->data[length - split];
 	}
 
-	/* Decrease buffer->size as the last thing, since this is what
+	/*
+	 * Decrease buffer->size as the last thing, since this is what
 	 * keeps the interrupt from overwriting the packet we are
-	 * retrieving from the buffer.  */
-
-	atomic_sub(sizeof (struct packet) + length, &buffer->size);
+	 * retrieving from the buffer.
+	 */
+	atomic_sub(sizeof(struct packet) + length, &buffer->size);
 
 	return length;
 }
@@ -186,7 +185,7 @@ packet_buffer_put(struct packet_buffer *buffer, void *data, size_t length)
 	buffer->total_packet_count++;
 
 	if (buffer->capacity <
-	    atomic_read(&buffer->size) + sizeof (struct packet) + length) {
+	    atomic_read(&buffer->size) + sizeof(struct packet) + length) {
 		buffer->lost_packet_count++;
 		return;
 	}
@@ -197,8 +196,7 @@ packet_buffer_put(struct packet_buffer *buffer, void *data, size_t length)
 	if (&buffer->tail->data[length] < end) {
 		memcpy(buffer->tail->data, data, length);
 		buffer->tail = (struct packet *) &buffer->tail->data[length];
-	}
-	else {
+	} else {
 		size_t split = end - buffer->tail->data;
 
 		memcpy(buffer->tail->data, data, split);
@@ -208,7 +206,7 @@ packet_buffer_put(struct packet_buffer *buffer, void *data, size_t length)
 
 	/* Finally, adjust buffer size and wake up userspace reader. */
 
-	atomic_add(sizeof (struct packet) + length, &buffer->size);
+	atomic_add(sizeof(struct packet) + length, &buffer->size);
 	wake_up_interruptible(&buffer->wait);
 }
 
@@ -230,11 +228,13 @@ reg_set_bits(struct pcilynx *lynx, int offset, u32 mask)
 	reg_write(lynx, offset, (reg_read(lynx, offset) | mask));
 }
 
-/* Maybe the pcl programs could be setup to just append data instead
- * of using a whole packet. */
-
+/*
+ * Maybe the pcl programs could be set up to just append data instead
+ * of using a whole packet.
+ */
 static inline void
-run_pcl(struct pcilynx *lynx, dma_addr_t pcl_bus, int dmachan)
+run_pcl(struct pcilynx *lynx, dma_addr_t pcl_bus,
+			   int dmachan)
 {
 	reg_write(lynx, DMA0_CURRENT_PCL + dmachan * 0x20, pcl_bus);
 	reg_write(lynx, DMA0_CHAN_CTRL + dmachan * 0x20,
@@ -245,14 +245,12 @@ static int
 set_phy_reg(struct pcilynx *lynx, int addr, int val)
 {
 	if (addr > 15) {
-                debug("%s: PHY register address %d out of range",
-		      __FUNCTION__, addr);
+		debug("PHY register address %d out of range\n", addr);
 		return -1;
 	}
 
 	if (val > 0xff) {
-                debug("%s: PHY register value %d out of range",
-		      __FUNCTION__, val);
+		debug("PHY register value %d out of range\n", val);
 		return -1;
 	}
 
@@ -358,18 +356,16 @@ nosy_ioctl(struct inode *inode, struct file *file,
 	   unsigned int cmd, unsigned long arg)
 {
 	struct client *client = file->private_data;
-
-	switch (cmd) {
-	case NOSY_IOC_GET_STATS: {
 	struct nosy_stats stats;
 
+	switch (cmd) {
+	case NOSY_IOC_GET_STATS:
 		stats.total_packet_count = client->buffer.total_packet_count;
 		stats.lost_packet_count = client->buffer.lost_packet_count;
 		if (copy_to_user((void *) arg, &stats, sizeof stats))
 			return -EFAULT;
 		else
 			return 0;
-	}
 
 	case NOSY_IOC_START:
 		nosy_start_snoop(client);
@@ -389,7 +385,7 @@ nosy_ioctl(struct inode *inode, struct file *file,
 	}
 }
 
-static struct file_operations nosy_ops = {
+static const struct file_operations nosy_ops = {
 	.owner =	THIS_MODULE,
 	.read =		nosy_read,
 	.ioctl =	nosy_ioctl,
@@ -412,7 +408,6 @@ static void
 packet_handler(struct pcilynx *lynx)
 {
 	unsigned long flags;
-	struct list_head *pos;
 	struct client *client;
 	unsigned long tcode_mask;
 	size_t length;
@@ -434,12 +429,10 @@ packet_handler(struct pcilynx *lynx)
 
 	spin_lock_irqsave(&lynx->client_list_lock, flags);
 
-	list_for_each(pos, &lynx->client_list) {
-		client = list_entry(pos, struct client, link);
+	list_for_each_entry(client, &lynx->client_list, link)
 		if (client->tcode_mask & tcode_mask)
 			packet_buffer_put(&client->buffer,
 					  lynx->rcv_buffer, length + 4);
-	}
 
 	spin_unlock_irqrestore(&lynx->client_list_lock, flags);
 }
@@ -448,7 +441,6 @@ static void
 bus_reset_handler(struct pcilynx *lynx)
 {
 	unsigned long flags;
-	struct list_head *pos;
 	struct client *client;
 	struct timeval tv;
 
@@ -456,20 +448,16 @@ bus_reset_handler(struct pcilynx *lynx)
 
 	spin_lock_irqsave(&lynx->client_list_lock, flags);
 
-	list_for_each(pos, &lynx->client_list) {
-		client = list_entry(pos, struct client, link);
+	list_for_each_entry(client, &lynx->client_list, link)
 		packet_buffer_put(&client->buffer, &tv.tv_usec, 4);
-	}
 
 	spin_unlock_irqrestore(&lynx->client_list_lock, flags);
 }
 
-
-
 static irqreturn_t
 irq_handler(int irq, void *device)
 {
-	struct pcilynx *lynx = (struct pcilynx *) device;
+	struct pcilynx *lynx = device;
 	u32 pci_int_status;
 
 	pci_int_status = reg_read(lynx, PCI_INT_STATUS);
@@ -515,9 +503,9 @@ remove_card(struct pci_dev *dev)
 	reg_write(lynx, PCI_INT_ENABLE, 0);
 	free_irq(lynx->pci_device->irq, lynx);
 
-	pci_free_consistent(lynx->pci_device, sizeof (struct pcl), 
+	pci_free_consistent(lynx->pci_device, sizeof(struct pcl),
 			    lynx->rcv_start_pcl, lynx->rcv_start_pcl_bus);
-	pci_free_consistent(lynx->pci_device, sizeof (struct pcl), 
+	pci_free_consistent(lynx->pci_device, sizeof(struct pcl),
 			    lynx->rcv_pcl, lynx->rcv_pcl_bus);
 	pci_free_consistent(lynx->pci_device, PAGE_SIZE,
 			    lynx->rcv_buffer, lynx->rcv_buffer_bus);
@@ -532,34 +520,29 @@ remove_card(struct pci_dev *dev)
 
 #define RCV_BUFFER_SIZE (16 * 1024)
 
-#define FAIL(s, args...)			\
-	do {					\
-		error(s, ## args);		\
-		return err;			\
-	} while (0)
-
 static int __devinit
 add_card(struct pci_dev *dev, const struct pci_device_id *unused)
 {
 	struct pcilynx *lynx;
 	u32 p, end;
-	int err, i;
-
-        err = -ENXIO;
+	int i;
 
-        if (pci_set_dma_mask(dev, 0xffffffff))
-                FAIL("DMA address limits not supported "
-		     "for PCILynx hardware.\n");
-        if (pci_enable_device(dev))
-                FAIL("Failed to enable PCILynx hardware.\n");
+	if (pci_set_dma_mask(dev, 0xffffffff)) {
+		error("DMA address limits not supported "
+		      "for PCILynx hardware\n");
+		return -ENXIO;
+	}
+	if (pci_enable_device(dev)) {
+		error("Failed to enable PCILynx hardware\n");
+		return -ENXIO;
+	}
 	pci_set_master(dev);
 
-        err = -ENOMEM;
-
 	lynx = kzalloc(sizeof *lynx, GFP_KERNEL);
-        if (lynx == NULL)
-		FAIL("Failed to allocate control structure memory.\n");
-
+	if (lynx == NULL) {
+		error("Failed to allocate control structure memory\n");
+		return -ENOMEM;
+	}
 	lynx->pci_device = dev;
 	pci_set_drvdata(dev, lynx);
 
@@ -570,19 +553,18 @@ add_card(struct pci_dev *dev, const struct pci_device_id *unused)
 					  PCILYNX_MAX_REGISTER);
 
 	lynx->rcv_start_pcl = pci_alloc_consistent(lynx->pci_device,
-						   sizeof(struct pcl),
-						   &lynx->rcv_start_pcl_bus);
+				sizeof(struct pcl), &lynx->rcv_start_pcl_bus);
 	lynx->rcv_pcl = pci_alloc_consistent(lynx->pci_device,
-					     sizeof(struct pcl),
-					     &lynx->rcv_pcl_bus);
-        lynx->rcv_buffer = pci_alloc_consistent(lynx->pci_device, RCV_BUFFER_SIZE,
-						&lynx->rcv_buffer_bus);
+				sizeof(struct pcl), &lynx->rcv_pcl_bus);
+	lynx->rcv_buffer = pci_alloc_consistent(lynx->pci_device,
+				RCV_BUFFER_SIZE, &lynx->rcv_buffer_bus);
 	if (lynx->rcv_start_pcl == NULL ||
 	    lynx->rcv_pcl == NULL ||
-	    lynx->rcv_buffer == NULL)
+	    lynx->rcv_buffer == NULL) {
 		/* FIXME: do proper error handling. */
-                FAIL("Failed to allocate receive buffer.\n");
-
+		error("Failed to allocate receive buffer\n");
+		return -ENOMEM;
+	}
 	lynx->rcv_start_pcl->next = lynx->rcv_pcl_bus;
 	lynx->rcv_pcl->next = PCL_NEXT_INVALID;
 	lynx->rcv_pcl->async_error_next = PCL_NEXT_INVALID;
@@ -638,15 +620,20 @@ add_card(struct pci_dev *dev, const struct pci_device_id *unused)
 
 	run_pcl(lynx, lynx->rcv_start_pcl_bus, 0);
 
-        if (request_irq(dev->irq, irq_handler, IRQF_SHARED, driver_name, lynx))
-		FAIL("Failed to allocate shared interrupt %d.", dev->irq);
+	if (request_irq(dev->irq, irq_handler, IRQF_SHARED,
+			driver_name, lynx)) {
+		error("Failed to allocate shared interrupt %d\n", dev->irq);
+		return -EIO;
+	}
 
 	lynx->misc.parent = &dev->dev;
 	lynx->misc.minor = MISC_DYNAMIC_MINOR;
 	lynx->misc.name = "nosy";
 	lynx->misc.fops = &nosy_ops;
-	if (misc_register(&lynx->misc))
-                FAIL("Failed to register misc char device.");
+	if (misc_register(&lynx->misc)) {
+		error("Failed to register misc char device\n");
+		return -ENOMEM;
+	}
 	minors[lynx->misc.minor] = lynx;
 
 	notify("Initialized PCILynx IEEE1394 card, irq=%d\n", dev->irq);
@@ -665,21 +652,19 @@ static struct pci_device_id pci_table[] __devinitdata = {
 };
 
 static struct pci_driver lynx_pci_driver = {
-	.name =		(char *) driver_name,
+	.name =		driver_name,
 	.id_table =	pci_table,
 	.probe =	add_card,
-	.remove =	__devexit_p(remove_card),
+	.remove =	remove_card,
 };
 
-MODULE_AUTHOR("Kristian Hgsberg");
+MODULE_AUTHOR("Kristian Hoegsberg");
 MODULE_DESCRIPTION("Snoop mode driver for TI pcilynx 1394 controllers");
 MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, pci_table);
 
 static int __init nosy_init(void)
 {
- 	/* notify("Loaded %s version %s.\n", driver_name, VERSION); */
-
 	return pci_register_driver(&lynx_pci_driver);
 }
 
@@ -690,6 +675,5 @@ static void __exit nosy_cleanup(void)
 	notify("Unloaded %s.\n", driver_name);
 }
 
-
 module_init(nosy_init);
 module_exit(nosy_cleanup);

drivers/firewire/nosy.h

-/* Chip register definitions for PCILynx chipset.  Based on pcilynx.h
+/*
+ * Chip register definitions for PCILynx chipset.  Based on pcilynx.h
  * from the Linux 1394 drivers, but modified a bit so the names here
  * match the specification exactly (even though they have weird names,
  * like xxx_OVER_FLOW, or arbitrary abbreviations like SNTRJ for "sent
@@ -118,7 +119,6 @@
 #define DMA_CHAN_STAT_PKTCMPL             (1<<27)
 #define DMA_CHAN_STAT_SPECIALACK          (1<<14)
 
-
 #define DMA0_CHAN_CTRL                    0x110
 #define DMA1_CHAN_CTRL                    0x130
 #define DMA2_CHAN_CTRL                    0x150
@@ -160,7 +160,7 @@
 #define DMA2_WORD0_CMP_ENABLE             0xb24
 #define DMA3_WORD0_CMP_ENABLE             0xb34
 #define DMA4_WORD0_CMP_ENABLE             0xb44
-#define DMA_WORD0_CMP_ENABLE(chan)        (DMA_SREG(DMA0_WORD0_CMP_ENABLE,chan))
+#define DMA_WORD0_CMP_ENABLE(chan)	(DMA_SREG(DMA0_WORD0_CMP_ENABLE, chan))
 
 #define DMA0_WORD1_CMP_VALUE              0xb08
 #define DMA1_WORD1_CMP_VALUE              0xb18
@@ -174,7 +174,7 @@
 #define DMA2_WORD1_CMP_ENABLE             0xb2c
 #define DMA3_WORD1_CMP_ENABLE             0xb3c
 #define DMA4_WORD1_CMP_ENABLE             0xb4c
-#define DMA_WORD1_CMP_ENABLE(chan)        (DMA_SREG(DMA0_WORD1_CMP_ENABLE,chan))
+#define DMA_WORD1_CMP_ENABLE(chan)	(DMA_SREG(DMA0_WORD1_CMP_ENABLE, chan))
 /* word 1 compare enable flags */
 #define DMA_WORD1_CMP_MATCH_OTHERBUS      (1<<15)
 #define DMA_WORD1_CMP_MATCH_BROADCAST     (1<<14)
@@ -211,7 +211,6 @@
 #define LINK_PHY_WDATA(data)              (data<<16)
 #define LINK_PHY_RADDR(addr)              (addr<<8)
 
-
 #define LINK_INT_STATUS                   0xf14
 #define LINK_INT_ENABLE                   0xf18
 /* status and enable have identical bit numbers */