Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b5e47729 authored by Stefan Richter's avatar Stefan Richter
Browse files

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: default avatarStefan Richter <stefanr@s5r6.in-berlin.de>
parent 28646821

drivers/firewire/nosy-user.h

+5 −5
Original line number Diff line number Diff line 
#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

+153 −169
Original line number Diff line number Diff line 
/* -*- 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,10 +167,11 @@ 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.  */



	 * retrieving from the buffer.

	 */

	atomic_sub(sizeof(struct packet) + length, &buffer->size);



	return length;
@@ -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);
@@ -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);
@@ -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

+13 −14
Original line number Diff line number Diff line 
/* 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
@@ -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 */