/* src/zd1205_proc.c
*
*
*
* Copyright (C) 2004 ZyDAS Inc.  All Rights Reserved.
* --------------------------------------------------------------------
*
*
*
*   The contents of this file are subject to the Mozilla Public
*   License Version 1.1 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.mozilla.org/MPL/
*
*   Software distributed under the License is distributed on an "AS
*   IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
*   implied. See the License for the specific language governing
*   rights and limitations under the License.
*
*   Alternatively, the contents of this file may be used under the
*   terms of the GNU Public License version 2 (the "GPL"), in which
*   case the provisions of the GPL are applicable instead of the
*   above.  If you wish to allow the use of your version of this file
*   only under the terms of the GPL and not to allow others to use
*   your version of this file under the MPL, indicate your decision
*   by deleting the provisions above and replace them with the notice
*   and other provisions required by the GPL.  If you do not delete
*   the provisions above, a recipient may use your version of this
*   file under either the MPL or the GPL.
*
* -------------------------------------------------------------------- */

#include <linux/config.h>

#ifdef CONFIG_PROC_FS
#include "zd1205.h"

/***************************************************************************/
/*       /proc File System Interaface Support Functions                    */
/***************************************************************************/

static struct proc_dir_entry *adapters_proc_dir = 0;

/* externs from zd1205.c */
extern char zd1205_short_driver_name[];
extern char zd1205_driver_version[];
extern struct net_device_stats *zd1205_get_stats(struct net_device *dev);


static void zd1205_proc_cleanup(void);
static unsigned char zd1205_init_proc_dir(void);

#define ADAPTERS_PROC_DIR   "zd1205"
#define WRITE_BUF_MAX_LEN   20	
#define READ_BUF_MAX_LEN    256
#define ZD1205_PE_LEN       25

#define bdp_drv_off(off) (unsigned long)(offsetof(struct zd1205_private, drv_stats.off))
#define bdp_prm_off(off) (unsigned long)(offsetof(struct zd1205_private, params.off))

typedef struct _zd1205_proc_entry {
	char *name;
	read_proc_t *read_proc;
	write_proc_t *write_proc;

	unsigned long offset;	/* offset into bdp. ~0 means no value, pass NULL. */
} 	zd1205_proc_entry;


static int
generic_read(char *page, char **start, off_t off, int count, int *eof, int len)
{
	if (len <= off + count)
		*eof = 1;

	*start = page + off;
	len -= off;
	if (len > count)
		len = count;

	if (len < 0)
		len = 0;

	return len;
}

#if 0
static int
read_ulong(char *page, char **start, off_t off,
	   int count, int *eof, unsigned long l)
{
	int len;

	len = sprintf(page, "%lu\n", l);

	return generic_read(page, start, off, count, eof, len);
}

static int
read_gen_ulong(char *page, char **start, off_t off,

	       int count, int *eof, void *data)
{
	unsigned long val = 0;

	if (data)
		val = *((unsigned long *) data);

	return read_ulong(page, start, off, count, eof, val);
}
#endif

static int
read_hwaddr(char *page, char **start, off_t off,
	    int count, int *eof, unsigned char *hwaddr)
{
	int len;

	len = sprintf(page, "%02X:%02X:%02X:%02X:%02X:%02X\n",
		      hwaddr[0], hwaddr[1], hwaddr[2],
		      hwaddr[3], hwaddr[4], hwaddr[5]);

	return generic_read(page, start, off, count, eof, len);
}


static int
read_permanent_hwaddr(char *page, char **start, off_t off,
		      int count, int *eof, void *data)
{
	struct zd1205_private *macp = data;
	unsigned char *hwaddr = macp->macAdr;

	return read_hwaddr(page, start, off, count, eof, hwaddr);
}


static zd1205_proc_entry zd1205_proc_list[] = {
	{"Permanent_HWaddr",      read_permanent_hwaddr, 0, 0},
	{"\n",},
	{"", 0, 0, 0}
};


static int
read_info(char *page, char **start, off_t off, int count, int *eof, void *data)
{

	struct zd1205_private *macp = data;
	zd1205_proc_entry *pe;
	int tmp;
	void *val;
	int len = 0;

	for (pe = zd1205_proc_list; pe->name[0]; pe++) {
		if (pe->name[0] == '\n') {
			len += sprintf(page + len, "\n");
			continue;
		}

		if (pe->read_proc) {
			if ((len + READ_BUF_MAX_LEN + ZD1205_PE_LEN + 1) >=
			    PAGE_SIZE)
				break;

			if (pe->offset != ~0)
				val = ((char *) macp) + pe->offset;
			else
				val = NULL;

			len += sprintf(page + len, "%-"
				       __MODULE_STRING(ZD1205_PE_LEN)
				       "s ", pe->name);
			len += pe->read_proc(page + len, start, 0,
					     READ_BUF_MAX_LEN + 1, &tmp, val);
		}
	}

	return generic_read(page, start, off, count, eof, len);
}


static struct proc_dir_entry *
create_proc_rw(char *name, void *data, struct proc_dir_entry *parent,
	       read_proc_t * read_proc, write_proc_t * write_proc)
{
	struct proc_dir_entry *pdep;
	mode_t mode = S_IFREG;

	if (write_proc) {
		mode |= S_IWUSR;
		if (read_proc) {
			mode |= S_IRUSR;
		}

	} else if (read_proc) {
		mode |= S_IRUGO;
	}

	if (!(pdep = create_proc_entry(name, mode, parent)))
		return NULL;

	pdep->read_proc = read_proc;
	pdep->write_proc = write_proc;
	pdep->data = data;
	return pdep;
}


void
zd1205_remove_proc_subdir(struct zd1205_private *macp, char *name)
{
	zd1205_proc_entry *pe;
	char info[256];
	int len;

	/* If our root /proc dir was not created, there is nothing to remove */
	if (adapters_proc_dir == NULL) {
		return;
	}

	len = strlen(macp->ifname);
	strncpy(info, macp->ifname, sizeof (info));
	strncat(info + len, ".info", sizeof (info) - len);

	if (macp->proc_parent) {
		for (pe = zd1205_proc_list; pe->name[0]; pe++) {
			if (pe->name[0] == '\n')
				continue;

			remove_proc_entry(pe->name, macp->proc_parent);
		}

		remove_proc_entry(macp->ifname, adapters_proc_dir);
		macp->proc_parent = NULL;
	}

	remove_proc_entry(info, adapters_proc_dir);

	/* try to remove the main /proc dir, if it's empty */
	zd1205_proc_cleanup();
}


int
zd1205_create_proc_subdir(struct zd1205_private *macp)
{
	struct proc_dir_entry *dev_dir;
	zd1205_proc_entry *pe;
	char info[256];
	int len;
	void *data;

	/* create the main /proc dir if needed */
	if (!adapters_proc_dir) {
		if (!zd1205_init_proc_dir())
			return -ENOMEM;
	}

	strncpy(info, macp->ifname, sizeof (info));
	len = strlen(info);
	strncat(info + len, ".info", sizeof (info) - len);

	/* info */
	if (!(create_proc_rw(info, macp, adapters_proc_dir, read_info, 0))) {
		zd1205_proc_cleanup();
		return -ENOMEM;
	}

	dev_dir = create_proc_entry(macp->ifname, S_IFDIR,
				    adapters_proc_dir);
	macp->proc_parent = dev_dir;

	if (!dev_dir) {
		zd1205_remove_proc_subdir(macp, macp->ifname);
		return -ENOMEM;
	}

	for (pe = zd1205_proc_list; pe->name[0]; pe++) {
		if (pe->name[0] == '\n')
			continue;

		if (pe->offset != ~0)
			data = ((char *) macp) + pe->offset;
		else
			data = NULL;

		if (!(create_proc_rw(pe->name, data, dev_dir,
				     pe->read_proc, pe->write_proc))) {
			zd1205_remove_proc_subdir(macp, macp->ifname);
			return -ENOMEM;
		}
	}

	return 0;
}

/****************************************************************************
 * Name:          zd1205_init_proc_dir
 *
 * Description:   This routine creates the top-level /proc directory for the
 *                driver in /proc/net
 *
 * Arguments:     none
 *
 * Returns:       true on success, false on fail
 *
 ***************************************************************************/
static unsigned char
zd1205_init_proc_dir(void)
{
	int len;

	/* first check if adapters_proc_dir already exists */
	len = strlen(ADAPTERS_PROC_DIR);
	for (adapters_proc_dir = proc_net->subdir;
	     adapters_proc_dir; adapters_proc_dir = adapters_proc_dir->next) {

		if ((adapters_proc_dir->namelen == len) &&
		    (!memcmp(adapters_proc_dir->name, ADAPTERS_PROC_DIR, len)))
			break;
	}

	if (!adapters_proc_dir)
		adapters_proc_dir =
			create_proc_entry(ADAPTERS_PROC_DIR, S_IFDIR, proc_net);

	if (!adapters_proc_dir)
		return false;

	return true;
}


/****************************************************************************
 * Name:          zd1205_proc_cleanup
 *
 * Description:   This routine clears the top-level /proc directory, if empty.
 *
 * Arguments:     none
 *
 * Returns:       none
 *
 ***************************************************************************/
static void
zd1205_proc_cleanup(void)
{
	struct proc_dir_entry *de;

	if (adapters_proc_dir == NULL) {
		return;
	}

	/* check if subdir list is empty before removing adapters_proc_dir */
	for (de = adapters_proc_dir->subdir; de; de = de->next) {
		/* ignore . and .. */
		if (*(de->name) != '.')
			break;
	}

	if (de)
		return;

	remove_proc_entry(ADAPTERS_PROC_DIR, proc_net);
	adapters_proc_dir = NULL;
}

#endif /* CONFIG_PROC_FS */