[mirror_ubuntu-zesty-kernel.git] / drivers / isdn / hysdn / hysdn_proclog.c

/* $Id: hysdn_proclog.c,v 1.9.6.3 2001/09/23 22:24:54 kai Exp $
 *
 * Linux driver for HYSDN cards, /proc/net filesystem log functions.
 *
 * Author    Werner Cornelius (werner@titro.de) for Hypercope GmbH
 * Copyright 1999 by Werner Cornelius (werner@titro.de)
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 */

#include <linux/module.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/mutex.h>
#include <linux/kernel.h>

#include "hysdn_defs.h"

/* the proc subdir for the interface is defined in the procconf module */
extern struct proc_dir_entry *hysdn_proc_entry;

static DEFINE_MUTEX(hysdn_log_mutex);
static void put_log_buffer(hysdn_card *card, char *cp);

/*************************************************/
/* structure keeping ascii log for device output */
/*************************************************/
struct log_data {
	struct log_data *next;
	unsigned long usage_cnt;/* number of files still to work */
	void *proc_ctrl;	/* pointer to own control procdata structure */
	char log_start[2];	/* log string start (final len aligned by size) */
};

/**********************************************/
/* structure holding proc entrys for one card */
/**********************************************/
struct procdata {
	struct proc_dir_entry *log;	/* log entry */
	char log_name[15];	/* log filename */
	struct log_data *log_head, *log_tail;	/* head and tail for queue */
	int if_used;		/* open count for interface */
	int volatile del_lock;	/* lock for delete operations */
	unsigned char logtmp[LOG_MAX_LINELEN];
	wait_queue_head_t rd_queue;
};


/**********************************************/
/* log function for cards error log interface */
/**********************************************/
void
hysdn_card_errlog(hysdn_card *card, tErrLogEntry *logp, int maxsize)
{
	char buf[ERRLOG_TEXT_SIZE + 40];

	sprintf(buf, "LOG 0x%08lX 0x%08lX : %s\n", logp->ulErrType, logp->ulErrSubtype, logp->ucText);
	put_log_buffer(card, buf);	/* output the string */
}				/* hysdn_card_errlog */

/***************************************************/
/* Log function using format specifiers for output */
/***************************************************/
void
hysdn_addlog(hysdn_card *card, char *fmt, ...)
{
	struct procdata *pd = card->proclog;
	char *cp;
	va_list args;

	if (!pd)
		return;		/* log structure non existent */

	cp = pd->logtmp;
	cp += sprintf(cp, "HYSDN: card %d ", card->myid);

	va_start(args, fmt);
	cp += vsprintf(cp, fmt, args);
	va_end(args);
	*cp++ = '\n';
	*cp = 0;

	if (card->debug_flags & DEB_OUT_SYSLOG)
		printk(KERN_INFO "%s", pd->logtmp);
	else
		put_log_buffer(card, pd->logtmp);

}				/* hysdn_addlog */

/********************************************/
/* put an log buffer into the log queue.    */
/* This buffer will be kept until all files */
/* opened for read got the contents.        */
/* Flushes buffers not longer in use.       */
/********************************************/
static void
put_log_buffer(hysdn_card *card, char *cp)
{
	struct log_data *ib;
	struct procdata *pd = card->proclog;
	int i;
	unsigned long flags;

	if (!pd)
		return;
	if (!cp)
		return;
	if (!*cp)
		return;
	if (pd->if_used <= 0)
		return;		/* no open file for read */

	if (!(ib = kmalloc(sizeof(struct log_data) + strlen(cp), GFP_ATOMIC)))
		return;	/* no memory */
	strcpy(ib->log_start, cp);	/* set output string */
	ib->next = NULL;
	ib->proc_ctrl = pd;	/* point to own control structure */
	spin_lock_irqsave(&card->hysdn_lock, flags);
	ib->usage_cnt = pd->if_used;
	if (!pd->log_head)
		pd->log_head = ib;	/* new head */
	else
		pd->log_tail->next = ib;	/* follows existing messages */
	pd->log_tail = ib;	/* new tail */
	i = pd->del_lock++;	/* get lock state */
	spin_unlock_irqrestore(&card->hysdn_lock, flags);

	/* delete old entrys */
	if (!i)
		while (pd->log_head->next) {
			if ((pd->log_head->usage_cnt <= 0) &&
			    (pd->log_head->next->usage_cnt <= 0)) {
				ib = pd->log_head;
				pd->log_head = pd->log_head->next;
				kfree(ib);
			} else
				break;
		}		/* pd->log_head->next */
	pd->del_lock--;		/* release lock level */
	wake_up_interruptible(&(pd->rd_queue));		/* announce new entry */
}				/* put_log_buffer */


/******************************/
/* file operations and tables */
/******************************/

/****************************************/
/* write log file -> set log level bits */
/****************************************/
static ssize_t
hysdn_log_write(struct file *file, const char __user *buf, size_t count, loff_t *off)
{
	int rc;
	hysdn_card *card = file->private_data;

	rc = kstrtoul_from_user(buf, count, 0, &card->debug_flags);
	if (rc < 0)
		return rc;
	hysdn_addlog(card, "debug set to 0x%lx", card->debug_flags);
	return (count);
}				/* hysdn_log_write */

/******************/
/* read log file */
/******************/
static ssize_t
hysdn_log_read(struct file *file, char __user *buf, size_t count, loff_t *off)
{
	struct log_data *inf;
	int len;
	hysdn_card *card = PDE_DATA(file_inode(file));

	if (!(inf = *((struct log_data **) file->private_data))) {
		struct procdata *pd = card->proclog;
		if (file->f_flags & O_NONBLOCK)
			return (-EAGAIN);

		wait_event_interruptible(pd->rd_queue, (inf =
				*((struct log_data **) file->private_data)));
	}
	if (!inf)
		return (0);

	inf->usage_cnt--;	/* new usage count */
	file->private_data = &inf->next;	/* next structure */
	if ((len = strlen(inf->log_start)) <= count) {
		if (copy_to_user(buf, inf->log_start, len))
			return -EFAULT;
		*off += len;
		return (len);
	}
	return (0);
}				/* hysdn_log_read */

/******************/
/* open log file */
/******************/
static int
hysdn_log_open(struct inode *ino, struct file *filep)
{
	hysdn_card *card = PDE_DATA(ino);

	mutex_lock(&hysdn_log_mutex);
	if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
		/* write only access -> write log level only */
		filep->private_data = card;	/* remember our own card */
	} else if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ) {
		struct procdata *pd = card->proclog;
		unsigned long flags;

		/* read access -> log/debug read */
		spin_lock_irqsave(&card->hysdn_lock, flags);
		pd->if_used++;
		if (pd->log_head)
			filep->private_data = &pd->log_tail->next;
		else
			filep->private_data = &pd->log_head;
		spin_unlock_irqrestore(&card->hysdn_lock, flags);
	} else {		/* simultaneous read/write access forbidden ! */
		mutex_unlock(&hysdn_log_mutex);
		return (-EPERM);	/* no permission this time */
	}
	mutex_unlock(&hysdn_log_mutex);
	return nonseekable_open(ino, filep);
}				/* hysdn_log_open */

/*******************************************************************************/
/* close a cardlog file. If the file has been opened for exclusive write it is */
/* assumed as pof data input and the pof loader is noticed about.              */
/* Otherwise file is handled as log output. In this case the interface usage   */
/* count is decremented and all buffers are noticed of closing. If this file   */
/* was the last one to be closed, all buffers are freed.                       */
/*******************************************************************************/
static int
hysdn_log_close(struct inode *ino, struct file *filep)
{
	struct log_data *inf;
	struct procdata *pd;
	hysdn_card *card;
	int retval = 0;

	mutex_lock(&hysdn_log_mutex);
	if ((filep->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE) {
		/* write only access -> write debug level written */
		retval = 0;	/* success */
	} else {
		/* read access -> log/debug read, mark one further file as closed */

		inf = *((struct log_data **) filep->private_data);	/* get first log entry */
		if (inf)
			pd = (struct procdata *) inf->proc_ctrl;	/* still entries there */
		else {
			/* no info available -> search card */
			card = PDE_DATA(file_inode(filep));
			pd = card->proclog;	/* pointer to procfs log */
		}
		if (pd)
			pd->if_used--;	/* decrement interface usage count by one */

		while (inf) {
			inf->usage_cnt--;	/* decrement usage count for buffers */
			inf = inf->next;
		}

		if (pd)
			if (pd->if_used <= 0)	/* delete buffers if last file closed */
				while (pd->log_head) {
					inf = pd->log_head;
					pd->log_head = pd->log_head->next;
					kfree(inf);
				}
	}			/* read access */
	mutex_unlock(&hysdn_log_mutex);

	return (retval);
}				/* hysdn_log_close */

/*************************************************/
/* select/poll routine to be able using select() */
/*************************************************/
static unsigned int
hysdn_log_poll(struct file *file, poll_table *wait)
{
	unsigned int mask = 0;
	hysdn_card *card = PDE_DATA(file_inode(file));
	struct procdata *pd = card->proclog;

	if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_WRITE)
		return (mask);	/* no polling for write supported */

	poll_wait(file, &(pd->rd_queue), wait);

	if (*((struct log_data **) file->private_data))
		mask |= POLLIN | POLLRDNORM;

	return mask;
}				/* hysdn_log_poll */

/**************************************************/
/* table for log filesystem functions defined above. */
/**************************************************/
static const struct file_operations log_fops =
{
	.owner		= THIS_MODULE,
	.llseek         = no_llseek,
	.read           = hysdn_log_read,
	.write          = hysdn_log_write,
	.poll           = hysdn_log_poll,
	.open           = hysdn_log_open,
	.release        = hysdn_log_close,
};


/***********************************************************************************/
/* hysdn_proclog_init is called when the module is loaded after creating the cards */
/* conf files.                                                                     */
/***********************************************************************************/
int
hysdn_proclog_init(hysdn_card *card)
{
	struct procdata *pd;

	/* create a cardlog proc entry */

	if ((pd = kzalloc(sizeof(struct procdata), GFP_KERNEL)) != NULL) {
		sprintf(pd->log_name, "%s%d", PROC_LOG_BASENAME, card->myid);
		pd->log = proc_create_data(pd->log_name,
				      S_IFREG | S_IRUGO | S_IWUSR, hysdn_proc_entry,
				      &log_fops, card);

		init_waitqueue_head(&(pd->rd_queue));

		card->proclog = (void *) pd;	/* remember procfs structure */
	}
	return (0);
}				/* hysdn_proclog_init */

/************************************************************************************/
/* hysdn_proclog_release is called when the module is unloaded and before the cards */
/* conf file is released                                                            */
/* The module counter is assumed to be 0 !                                          */
/************************************************************************************/
void
hysdn_proclog_release(hysdn_card *card)
{
	struct procdata *pd;

	if ((pd = (struct procdata *) card->proclog) != NULL) {
		if (pd->log)
			remove_proc_entry(pd->log_name, hysdn_proc_entry);
		kfree(pd);	/* release memory */
		card->proclog = NULL;
	}
}				/* hysdn_proclog_release */
Commit	Line	Data
1da177e4 LT	1	/* $Id: hysdn_proclog.c,v 1.9.6.3 2001/09/23 22:24:54 kai Exp $
	2	*
	3	* Linux driver for HYSDN cards, /proc/net filesystem log functions.
	4	*
	5	* Author Werner Cornelius (werner@titro.de) for Hypercope GmbH
	6	* Copyright 1999 by Werner Cornelius (werner@titro.de)
	7	*
	8	* This software may be used and distributed according to the terms
	9	* of the GNU General Public License, incorporated herein by reference.
	10	*
	11	*/
	12
	13	#include <linux/module.h>
1da177e4 LT	14	#include <linux/poll.h>
1da177e4 LT	15	#include <linux/proc_fs.h>
d43c36dc	16	#include <linux/sched.h>
5a0e3ad6	17	#include <linux/slab.h>
76a64921	18	#include <linux/mutex.h>
3944ad68	19	#include <linux/kernel.h>
1da177e4 LT	20
	21	#include "hysdn_defs.h"
	22
	23	/* the proc subdir for the interface is defined in the procconf module */
	24	extern struct proc_dir_entry *hysdn_proc_entry;
	25
76a64921	26	static DEFINE_MUTEX(hysdn_log_mutex);
475be4d8	27	static void put_log_buffer(hysdn_card card, char cp);
aade0e82	28
1da177e4 LT	29	/*************************************************/
	30	/* structure keeping ascii log for device output */
	31	/*************************************************/
	32	struct log_data {
	33	struct log_data *next;
c721bcce	34	unsigned long usage_cnt;/* number of files still to work */
1da177e4 LT	35	void proc_ctrl; / pointer to own control procdata structure */
	36	char log_start[2]; /* log string start (final len aligned by size) */
	37	};
	38
	39	/**********************************************/
	40	/* structure holding proc entrys for one card */
	41	/**********************************************/
	42	struct procdata {
	43	struct proc_dir_entry log; / log entry */
	44	char log_name[15]; /* log filename */
	45	struct log_data log_head, log_tail; /* head and tail for queue */
	46	int if_used; /* open count for interface */
	47	int volatile del_lock; /* lock for delete operations */
c721bcce	48	unsigned char logtmp[LOG_MAX_LINELEN];
1da177e4 LT	49	wait_queue_head_t rd_queue;
	50	};
	51
	52
	53	/**********************************************/
	54	/* log function for cards error log interface */
	55	/**********************************************/
	56	void
475be4d8	57	hysdn_card_errlog(hysdn_card card, tErrLogEntry logp, int maxsize)
1da177e4 LT	58	{
	59	char buf[ERRLOG_TEXT_SIZE + 40];
	60
	61	sprintf(buf, "LOG 0x%08lX 0x%08lX : %s\n", logp->ulErrType, logp->ulErrSubtype, logp->ucText);
	62	put_log_buffer(card, buf); /* output the string */
	63	} /* hysdn_card_errlog */
	64
	65	/***************************************************/
	66	/* Log function using format specifiers for output */
	67	/***************************************************/
	68	void
475be4d8	69	hysdn_addlog(hysdn_card card, char fmt, ...)
1da177e4 LT	70	{
	71	struct procdata *pd = card->proclog;
	72	char *cp;
	73	va_list args;
	74
	75	if (!pd)
	76	return; /* log structure non existent */
	77
	78	cp = pd->logtmp;
	79	cp += sprintf(cp, "HYSDN: card %d ", card->myid);
	80
	81	va_start(args, fmt);
	82	cp += vsprintf(cp, fmt, args);
	83	va_end(args);
	84	*cp++ = '\n';
	85	*cp = 0;
	86
	87	if (card->debug_flags & DEB_OUT_SYSLOG)
	88	printk(KERN_INFO "%s", pd->logtmp);
	89	else
	90	put_log_buffer(card, pd->logtmp);
	91
	92	} /* hysdn_addlog */
	93
	94	/********************************************/
	95	/* put an log buffer into the log queue. */
	96	/* This buffer will be kept until all files */
	97	/* opened for read got the contents. */
	98	/* Flushes buffers not longer in use. */
	99	/********************************************/
aade0e82	100	static void
475be4d8	101	put_log_buffer(hysdn_card card, char cp)
1da177e4 LT	102	{
	103	struct log_data *ib;
	104	struct procdata *pd = card->proclog;
	105	int i;
	106	unsigned long flags;
	107
	108	if (!pd)
	109	return;
	110	if (!cp)
	111	return;
	112	if (!*cp)
	113	return;
	114	if (pd->if_used <= 0)
	115	return; /* no open file for read */
	116
5cbded58	117	if (!(ib = kmalloc(sizeof(struct log_data) + strlen(cp), GFP_ATOMIC)))
475be4d8	118	return; /* no memory */
1da177e4 LT	119	strcpy(ib->log_start, cp); /* set output string */
	120	ib->next = NULL;
	121	ib->proc_ctrl = pd; /* point to own control structure */
0d9ba869	122	spin_lock_irqsave(&card->hysdn_lock, flags);
1da177e4 LT	123	ib->usage_cnt = pd->if_used;
	124	if (!pd->log_head)
	125	pd->log_head = ib; /* new head */
	126	else
	127	pd->log_tail->next = ib; /* follows existing messages */
	128	pd->log_tail = ib; /* new tail */
	129	i = pd->del_lock++; /* get lock state */
0d9ba869	130	spin_unlock_irqrestore(&card->hysdn_lock, flags);
1da177e4 LT	131
	132	/* delete old entrys */
	133	if (!i)
	134	while (pd->log_head->next) {
	135	if ((pd->log_head->usage_cnt <= 0) &&
	136	(pd->log_head->next->usage_cnt <= 0)) {
	137	ib = pd->log_head;
	138	pd->log_head = pd->log_head->next;
	139	kfree(ib);
	140	} else
	141	break;
	142	} /* pd->log_head->next */
	143	pd->del_lock--; /* release lock level */
	144	wake_up_interruptible(&(pd->rd_queue)); /* announce new entry */
	145	} /* put_log_buffer */
	146
	147
	148	/******************************/
	149	/* file operations and tables */
	150	/******************************/
	151
	152	/****************************************/
	153	/* write log file -> set log level bits */
	154	/****************************************/
	155	static ssize_t
475be4d8	156	hysdn_log_write(struct file file, const char __user buf, size_t count, loff_t *off)
1da177e4	157	{
3944ad68	158	int rc;
54cbb1ca	159	hysdn_card *card = file->private_data;
1da177e4	160
8831a3f2	161	rc = kstrtoul_from_user(buf, count, 0, &card->debug_flags);
19eccc2b AD	162	if (rc < 0)
	163	return rc;
	164	hysdn_addlog(card, "debug set to 0x%lx", card->debug_flags);
1da177e4 LT	165	return (count);
	166	} /* hysdn_log_write */
	167
	168	/******************/
	169	/* read log file */
	170	/******************/
	171	static ssize_t
475be4d8	172	hysdn_log_read(struct file file, char __user buf, size_t count, loff_t *off)
1da177e4 LT	173	{
	174	struct log_data *inf;
	175	int len;
d9dda78b	176	hysdn_card *card = PDE_DATA(file_inode(file));
1da177e4	177
c11da83b	178	if (!(inf = ((struct log_data *) file->private_data))) {
4d8e8d21	179	struct procdata *pd = card->proclog;
1da177e4 LT	180	if (file->f_flags & O_NONBLOCK)
	181	return (-EAGAIN);
	182
c11da83b AB	183	wait_event_interruptible(pd->rd_queue, (inf =
c11da83b AB	184	((struct log_data *) file->private_data)));
1da177e4	185	}
c11da83b	186	if (!inf)
1da177e4 LT	187	return (0);
	188
	189	inf->usage_cnt--; /* new usage count */
	190	file->private_data = &inf->next; /* next structure */
	191	if ((len = strlen(inf->log_start)) <= count) {
	192	if (copy_to_user(buf, inf->log_start, len))
	193	return -EFAULT;
	194	*off += len;
	195	return (len);
	196	}
	197	return (0);
	198	} /* hysdn_log_read */
	199
	200	/******************/
	201	/* open log file */
	202	/******************/
	203	static int
	204	hysdn_log_open(struct inode ino, struct file filep)
	205	{
d9dda78b	206	hysdn_card *card = PDE_DATA(ino);
1da177e4	207
76a64921	208	mutex_lock(&hysdn_log_mutex);
1da177e4 LT	209	if ((filep->f_mode & (FMODE_READ \| FMODE_WRITE)) == FMODE_WRITE) {
1da177e4 LT	210	/* write only access -> write log level only */
4d8e8d21	211	filep->private_data = card; /* remember our own card */
1da177e4	212	} else if ((filep->f_mode & (FMODE_READ \| FMODE_WRITE)) == FMODE_READ) {
4d8e8d21 AV	213	struct procdata *pd = card->proclog;
4d8e8d21 AV	214	unsigned long flags;
1da177e4 LT	215
1da177e4 LT	216	/* read access -> log/debug read */
0d9ba869	217	spin_lock_irqsave(&card->hysdn_lock, flags);
1da177e4 LT	218	pd->if_used++;
	219	if (pd->log_head)
	220	filep->private_data = &pd->log_tail->next;
	221	else
	222	filep->private_data = &pd->log_head;
0d9ba869	223	spin_unlock_irqrestore(&card->hysdn_lock, flags);
1da177e4	224	} else { /* simultaneous read/write access forbidden ! */
76a64921	225	mutex_unlock(&hysdn_log_mutex);
1da177e4 LT	226	return (-EPERM); /* no permission this time */
1da177e4 LT	227	}
76a64921	228	mutex_unlock(&hysdn_log_mutex);
1da177e4 LT	229	return nonseekable_open(ino, filep);
	230	} /* hysdn_log_open */
	231
	232	/*******************************************************************************/
	233	/* close a cardlog file. If the file has been opened for exclusive write it is */
	234	/* assumed as pof data input and the pof loader is noticed about. */
	235	/* Otherwise file is handled as log output. In this case the interface usage */
	236	/* count is decremented and all buffers are noticed of closing. If this file */
	237	/* was the last one to be closed, all buffers are freed. */
	238	/*******************************************************************************/
	239	static int
	240	hysdn_log_close(struct inode ino, struct file filep)
	241	{
	242	struct log_data *inf;
	243	struct procdata *pd;
	244	hysdn_card *card;
	245	int retval = 0;
1da177e4	246
76a64921	247	mutex_lock(&hysdn_log_mutex);
1da177e4 LT	248	if ((filep->f_mode & (FMODE_READ \| FMODE_WRITE)) == FMODE_WRITE) {
	249	/* write only access -> write debug level written */
	250	retval = 0; /* success */
	251	} else {
	252	/* read access -> log/debug read, mark one further file as closed */
	253
1da177e4 LT	254	inf = ((struct log_data ) filep->private_data); / get first log entry */
	255	if (inf)
	256	pd = (struct procdata ) inf->proc_ctrl; / still entries there */
	257	else {
	258	/* no info available -> search card */
d9dda78b	259	card = PDE_DATA(file_inode(filep));
4d8e8d21	260	pd = card->proclog; /* pointer to procfs log */
1da177e4 LT	261	}
	262	if (pd)
	263	pd->if_used--; /* decrement interface usage count by one */
	264
	265	while (inf) {
	266	inf->usage_cnt--; /* decrement usage count for buffers */
	267	inf = inf->next;
	268	}
1da177e4 LT	269
	270	if (pd)
	271	if (pd->if_used <= 0) /* delete buffers if last file closed */
	272	while (pd->log_head) {
	273	inf = pd->log_head;
	274	pd->log_head = pd->log_head->next;
	275	kfree(inf);
	276	}
	277	} /* read access */
76a64921	278	mutex_unlock(&hysdn_log_mutex);
1da177e4 LT	279
	280	return (retval);
	281	} /* hysdn_log_close */
	282
	283	/*************************************************/
	284	/* select/poll routine to be able using select() */
	285	/*************************************************/
	286	static unsigned int
475be4d8	287	hysdn_log_poll(struct file file, poll_table wait)
1da177e4 LT	288	{
1da177e4 LT	289	unsigned int mask = 0;
d9dda78b	290	hysdn_card *card = PDE_DATA(file_inode(file));
4d8e8d21	291	struct procdata *pd = card->proclog;
1da177e4 LT	292
	293	if ((file->f_mode & (FMODE_READ \| FMODE_WRITE)) == FMODE_WRITE)
	294	return (mask); /* no polling for write supported */
	295
1da177e4 LT	296	poll_wait(file, &(pd->rd_queue), wait);
	297
	298	if (((struct log_data *) file->private_data))
	299	mask \|= POLLIN \| POLLRDNORM;
	300
	301	return mask;
	302	} /* hysdn_log_poll */
	303
	304	/**************************************************/
	305	/* table for log filesystem functions defined above. */
	306	/**************************************************/
2b8693c0	307	static const struct file_operations log_fops =
1da177e4	308	{
ac41cfd1	309	.owner = THIS_MODULE,
1da177e4 LT	310	.llseek = no_llseek,
	311	.read = hysdn_log_read,
	312	.write = hysdn_log_write,
	313	.poll = hysdn_log_poll,
	314	.open = hysdn_log_open,
475be4d8	315	.release = hysdn_log_close,
1da177e4 LT	316	};
	317
	318
	319	/***********************************************************************************/
	320	/* hysdn_proclog_init is called when the module is loaded after creating the cards */
	321	/* conf files. */
	322	/***********************************************************************************/
	323	int
475be4d8	324	hysdn_proclog_init(hysdn_card *card)
1da177e4 LT	325	{
	326	struct procdata *pd;
	327
	328	/* create a cardlog proc entry */
	329
41f96935	330	if ((pd = kzalloc(sizeof(struct procdata), GFP_KERNEL)) != NULL) {
1da177e4	331	sprintf(pd->log_name, "%s%d", PROC_LOG_BASENAME, card->myid);
4d8e8d21	332	pd->log = proc_create_data(pd->log_name,
475be4d8	333	S_IFREG \| S_IRUGO \| S_IWUSR, hysdn_proc_entry,
4d8e8d21	334	&log_fops, card);
1da177e4 LT	335
	336	init_waitqueue_head(&(pd->rd_queue));
	337
	338	card->proclog = (void ) pd; / remember procfs structure */
	339	}
	340	return (0);
	341	} /* hysdn_proclog_init */
	342
	343	/************************************************************************************/
	344	/* hysdn_proclog_release is called when the module is unloaded and before the cards */
	345	/* conf file is released */
	346	/* The module counter is assumed to be 0 ! */
	347	/************************************************************************************/
	348	void
475be4d8	349	hysdn_proclog_release(hysdn_card *card)
1da177e4 LT	350	{
	351	struct procdata *pd;
	352
	353	if ((pd = (struct procdata *) card->proclog) != NULL) {
	354	if (pd->log)
	355	remove_proc_entry(pd->log_name, hysdn_proc_entry);
	356	kfree(pd); /* release memory */
	357	card->proclog = NULL;
	358	}
	359	} /* hysdn_proclog_release */