/* $Id: mntfunc.c,v 1.19.6.4 2005/01/31 12:22:20 armin Exp $
   *
   * Driver for Eicon DIVA Server ISDN cards.
   * Maint module
   *
   * Copyright 2000-2003 by Armin Schindler (mac@melware.de)
   * Copyright 2000-2003 Cytronics & Melware (info@melware.de)
   *
   * This software may be used and distributed according to the terms
   * of the GNU General Public License, incorporated herein by reference.
   */
  
  
  #include "platform.h"
  #include "di_defs.h"
  #include "divasync.h"
  #include "debug_if.h"
  
  extern char *DRIVERRELEASE_MNT;
  
  #define DBG_MINIMUM  (DL_LOG + DL_FTL + DL_ERR)
  #define DBG_DEFAULT  (DBG_MINIMUM + DL_XLOG + DL_REG)
  
  extern void DIVA_DIDD_Read(void *, int);
  
  static dword notify_handle;
  static DESCRIPTOR DAdapter;
  static DESCRIPTOR MAdapter;
  static DESCRIPTOR MaintDescriptor =
  { IDI_DIMAINT, 0, 0, (IDI_CALL) diva_maint_prtComp };
  
  extern int diva_os_copy_to_user(void *os_handle, void __user *dst,
  				const void *src, int length);
  extern int diva_os_copy_from_user(void *os_handle, void *dst,
  				  const void __user *src, int length);
  
  static void no_printf(unsigned char *x, ...)
  {
  	/* dummy debug function */
  }
  
  #include "debuglib.c"
  
  /*
   *  DIDD callback function
   */
  static void *didd_callback(void *context, DESCRIPTOR *adapter,
  			   int removal)
  {
  	if (adapter->type == IDI_DADAPTER) {
  		DBG_ERR(("cb: Change in DAdapter ? Oops ?."));
  	} else if (adapter->type == IDI_DIMAINT) {
  		if (removal) {
  			DbgDeregister();
  			memset(&MAdapter, 0, sizeof(MAdapter));
  			dprintf = no_printf;
  		} else {
  			memcpy(&MAdapter, adapter, sizeof(MAdapter));
  			dprintf = (DIVA_DI_PRINTF) MAdapter.request;
  			DbgRegister("MAINT", DRIVERRELEASE_MNT, DBG_DEFAULT);
  		}
  	} else if ((adapter->type > 0) && (adapter->type < 16)) {
  		if (removal) {
  			diva_mnt_remove_xdi_adapter(adapter);
  		} else {
  			diva_mnt_add_xdi_adapter(adapter);
  		}
  	}
  	return (NULL);
  }
  
  /*
   * connect to didd
   */
  static int __init connect_didd(void)
  {
  	int x = 0;
  	int dadapter = 0;
  	IDI_SYNC_REQ req;
  	DESCRIPTOR DIDD_Table[MAX_DESCRIPTORS];
  
  	DIVA_DIDD_Read(DIDD_Table, sizeof(DIDD_Table));
  
  	for (x = 0; x < MAX_DESCRIPTORS; x++) {
  		if (DIDD_Table[x].type == IDI_DADAPTER) {	/* DADAPTER found */
  			dadapter = 1;
  			memcpy(&DAdapter, &DIDD_Table[x], sizeof(DAdapter));
  			req.didd_notify.e.Req = 0;
  			req.didd_notify.e.Rc =
  				IDI_SYNC_REQ_DIDD_REGISTER_ADAPTER_NOTIFY;
  			req.didd_notify.info.callback = (void *)didd_callback;
  			req.didd_notify.info.context = NULL;
  			DAdapter.request((ENTITY *)&req);
  			if (req.didd_notify.e.Rc != 0xff)
  				return (0);
  			notify_handle = req.didd_notify.info.handle;
  			/* Register MAINT (me) */
  			req.didd_add_adapter.e.Req = 0;
  			req.didd_add_adapter.e.Rc =
  				IDI_SYNC_REQ_DIDD_ADD_ADAPTER;
  			req.didd_add_adapter.info.descriptor =
  				(void *) &MaintDescriptor;
  			DAdapter.request((ENTITY *)&req);
  			if (req.didd_add_adapter.e.Rc != 0xff)
  				return (0);
  		} else if ((DIDD_Table[x].type > 0)
  			   && (DIDD_Table[x].type < 16)) {
  			diva_mnt_add_xdi_adapter(&DIDD_Table[x]);
  		}
  	}
  	return (dadapter);
  }
  
  /*
   * disconnect from didd
   */
  static void __exit disconnect_didd(void)
  {
  	IDI_SYNC_REQ req;
  
  	req.didd_notify.e.Req = 0;
  	req.didd_notify.e.Rc = IDI_SYNC_REQ_DIDD_REMOVE_ADAPTER_NOTIFY;
  	req.didd_notify.info.handle = notify_handle;
  	DAdapter.request((ENTITY *)&req);
  
  	req.didd_remove_adapter.e.Req = 0;
  	req.didd_remove_adapter.e.Rc = IDI_SYNC_REQ_DIDD_REMOVE_ADAPTER;
  	req.didd_remove_adapter.info.p_request =
  		(IDI_CALL) MaintDescriptor.request;
  	DAdapter.request((ENTITY *)&req);
  }
  
  /*
   * read/write maint
   */
  int maint_read_write(void __user *buf, int count)
  {
  	byte data[128];
  	dword cmd, id, mask;
  	int ret = 0;
  
  	if (count < (3 * sizeof(dword)))
  		return (-EFAULT);
  
  	if (diva_os_copy_from_user(NULL, (void *) &data[0],
  				   buf, 3 * sizeof(dword))) {
  		return (-EFAULT);
  	}
  
  	cmd = *(dword *)&data[0];	/* command */
  	id = *(dword *)&data[4];	/* driver id */
  	mask = *(dword *)&data[8];	/* mask or size */
  
  	switch (cmd) {
  	case DITRACE_CMD_GET_DRIVER_INFO:
  		if ((ret = diva_get_driver_info(id, data, sizeof(data))) > 0) {
  			if ((count < ret) || diva_os_copy_to_user
  			    (NULL, buf, (void *) &data[0], ret))
  				ret = -EFAULT;
  		} else {
  			ret = -EINVAL;
  		}
  		break;
  
  	case DITRACE_READ_DRIVER_DBG_MASK:
  		if ((ret = diva_get_driver_dbg_mask(id, (byte *) data)) > 0) {
  			if ((count < ret) || diva_os_copy_to_user
  			    (NULL, buf, (void *) &data[0], ret))
  				ret = -EFAULT;
  		} else {
  			ret = -ENODEV;
  		}
  		break;
  
  	case DITRACE_WRITE_DRIVER_DBG_MASK:
  		if ((ret = diva_set_driver_dbg_mask(id, mask)) <= 0) {
  			ret = -ENODEV;
  		}
  		break;
  
  		/*
  		  Filter commands will ignore the ID due to fact that filtering affects
  		  the B- channel and Audio Tap trace levels only. Also MAINT driver will
  		  select the right trace ID by itself
  		*/
  	case DITRACE_WRITE_SELECTIVE_TRACE_FILTER:
  		if (!mask) {
  			ret = diva_set_trace_filter(1, "*");
  		} else if (mask < sizeof(data)) {
  			if (diva_os_copy_from_user(NULL, data, (char __user *)buf + 12, mask)) {
  				ret = -EFAULT;
  			} else {
  				ret = diva_set_trace_filter((int)mask, data);
  			}
  		} else {
  			ret = -EINVAL;
  		}
  		break;
  
  	case DITRACE_READ_SELECTIVE_TRACE_FILTER:
  		if ((ret = diva_get_trace_filter(sizeof(data), data)) > 0) {
  			if (diva_os_copy_to_user(NULL, buf, data, ret))
  				ret = -EFAULT;
  		} else {
  			ret = -ENODEV;
  		}
  		break;
  
  	case DITRACE_READ_TRACE_ENTRY:{
  		diva_os_spin_lock_magic_t old_irql;
  		word size;
  		diva_dbg_entry_head_t *pmsg;
  		byte *pbuf;
  
  		if (!(pbuf = diva_os_malloc(0, mask))) {
  			return (-ENOMEM);
  		}
  
  		for (;;) {
  			if (!(pmsg =
  			      diva_maint_get_message(&size, &old_irql))) {
  				break;
  			}
  			if (size > mask) {
  				diva_maint_ack_message(0, &old_irql);
  				ret = -EINVAL;
  				break;
  			}
  			ret = size;
  			memcpy(pbuf, pmsg, size);
  			diva_maint_ack_message(1, &old_irql);
  			if ((count < size) ||
  			    diva_os_copy_to_user(NULL, buf, (void *) pbuf, size))
  				ret = -EFAULT;
  			break;
  		}
  		diva_os_free(0, pbuf);
  	}
  		break;
  
  	case DITRACE_READ_TRACE_ENTRYS:{
  		diva_os_spin_lock_magic_t old_irql;
  		word size;
  		diva_dbg_entry_head_t *pmsg;
  		byte *pbuf = NULL;
  		int written = 0;
  
  		if (mask < 4096) {
  			ret = -EINVAL;
  			break;
  		}
  		if (!(pbuf = diva_os_malloc(0, mask))) {
  			return (-ENOMEM);
  		}
  
  		for (;;) {
  			if (!(pmsg =
  			      diva_maint_get_message(&size, &old_irql))) {
  				break;
  			}
  			if ((size + 8) > mask) {
  				diva_maint_ack_message(0, &old_irql);
  				break;
  			}
  			/*
  			  Write entry length
  			*/
  			pbuf[written++] = (byte) size;
  			pbuf[written++] = (byte) (size >> 8);
  			pbuf[written++] = 0;
  			pbuf[written++] = 0;
  			/*
  			  Write message
  			*/
  			memcpy(&pbuf[written], pmsg, size);
  			diva_maint_ack_message(1, &old_irql);
  			written += size;
  			mask -= (size + 4);
  		}
  		pbuf[written++] = 0;
  		pbuf[written++] = 0;
  		pbuf[written++] = 0;
  		pbuf[written++] = 0;
  
  		if ((count < written) || diva_os_copy_to_user(NULL, buf, (void *) pbuf, written)) {
  			ret = -EFAULT;
  		} else {
  			ret = written;
  		}
  		diva_os_free(0, pbuf);
  	}
  		break;
  
  	default:
  		ret = -EINVAL;
  	}
  	return (ret);
  }
  
  /*
   *  init
   */
  int __init mntfunc_init(int *buffer_length, void **buffer,
  				    unsigned long diva_dbg_mem)
  {
  	if (*buffer_length < 64) {
  		*buffer_length = 64;
  	}
  	if (*buffer_length > 512) {
  		*buffer_length = 512;
  	}
  	*buffer_length *= 1024;
  
  	if (diva_dbg_mem) {
  		*buffer = (void *) diva_dbg_mem;
  	} else {
  		while ((*buffer_length >= (64 * 1024))
  		       &&
  		       (!(*buffer = diva_os_malloc(0, *buffer_length)))) {
  			*buffer_length -= 1024;
  		}
  
  		if (!*buffer) {
  			DBG_ERR(("init: Can not alloc trace buffer"));
  			return (0);
  		}
  	}
  
  	if (diva_maint_init(*buffer, *buffer_length, (diva_dbg_mem == 0))) {
  		if (!diva_dbg_mem) {
  			diva_os_free(0, *buffer);
  		}
  		DBG_ERR(("init: maint init failed"));
  		return (0);
  	}
  
  	if (!connect_didd()) {
  		DBG_ERR(("init: failed to connect to DIDD."));
  		diva_maint_finit();
  		if (!diva_dbg_mem) {
  			diva_os_free(0, *buffer);
  		}
  		return (0);
  	}
  	return (1);
  }
  
  /*
   *  exit
   */
  void __exit mntfunc_finit(void)
  {
  	void *buffer;
  	int i = 100;
  
  	DbgDeregister();
  
  	while (diva_mnt_shutdown_xdi_adapters() && i--) {
  		diva_os_sleep(10);
  	}
  
  	disconnect_didd();
  
  	if ((buffer = diva_maint_finit())) {
  		diva_os_free(0, buffer);
  	}
  
  	memset(&MAdapter, 0, sizeof(MAdapter));
  	dprintf = no_printf;
  }