[linux-block.git] / drivers / isdn / hardware / eicon / diva.c

// SPDX-License-Identifier: GPL-2.0
/* $Id: diva.c,v 1.21.4.1 2004/05/08 14:33:43 armin Exp $ */

#define CARDTYPE_H_WANT_DATA            1
#define CARDTYPE_H_WANT_IDI_DATA        0
#define CARDTYPE_H_WANT_RESOURCE_DATA   0
#define CARDTYPE_H_WANT_FILE_DATA       0

#include "platform.h"
#include "debuglib.h"
#include "cardtype.h"
#include "pc.h"
#include "di_defs.h"
#include "di.h"
#include "io.h"
#include "pc_maint.h"
#include "xdi_msg.h"
#include "xdi_adapter.h"
#include "diva_pci.h"
#include "diva.h"

#ifdef CONFIG_ISDN_DIVAS_PRIPCI
#include "os_pri.h"
#endif
#ifdef CONFIG_ISDN_DIVAS_BRIPCI
#include "os_bri.h"
#include "os_4bri.h"
#endif

PISDN_ADAPTER IoAdapters[MAX_ADAPTER];
extern IDI_CALL Requests[MAX_ADAPTER];
extern int create_adapter_proc(diva_os_xdi_adapter_t *a);
extern void remove_adapter_proc(diva_os_xdi_adapter_t *a);

#define DivaIdiReqFunc(N)						\
	static void DivaIdiRequest##N(ENTITY *e)			\
	{ if (IoAdapters[N]) (*IoAdapters[N]->DIRequest)(IoAdapters[N], e); }

/*
**  Create own 32 Adapters
*/
DivaIdiReqFunc(0)
DivaIdiReqFunc(1)
DivaIdiReqFunc(2)
DivaIdiReqFunc(3)
DivaIdiReqFunc(4)
DivaIdiReqFunc(5)
DivaIdiReqFunc(6)
DivaIdiReqFunc(7)
DivaIdiReqFunc(8)
DivaIdiReqFunc(9)
DivaIdiReqFunc(10)
DivaIdiReqFunc(11)
DivaIdiReqFunc(12)
DivaIdiReqFunc(13)
DivaIdiReqFunc(14)
DivaIdiReqFunc(15)
DivaIdiReqFunc(16)
DivaIdiReqFunc(17)
DivaIdiReqFunc(18)
DivaIdiReqFunc(19)
DivaIdiReqFunc(20)
DivaIdiReqFunc(21)
DivaIdiReqFunc(22)
DivaIdiReqFunc(23)
DivaIdiReqFunc(24)
DivaIdiReqFunc(25)
DivaIdiReqFunc(26)
DivaIdiReqFunc(27)
DivaIdiReqFunc(28)
DivaIdiReqFunc(29)
DivaIdiReqFunc(30)
DivaIdiReqFunc(31)

/*
**  LOCALS
*/
static LIST_HEAD(adapter_queue);

typedef struct _diva_get_xlog {
	word command;
	byte req;
	byte rc;
	byte data[sizeof(struct mi_pc_maint)];
} diva_get_xlog_t;

typedef struct _diva_supported_cards_info {
	int CardOrdinal;
	diva_init_card_proc_t init_card;
} diva_supported_cards_info_t;

static diva_supported_cards_info_t divas_supported_cards[] = {
#ifdef CONFIG_ISDN_DIVAS_PRIPCI
	/*
	  PRI Cards
	*/
	{CARDTYPE_DIVASRV_P_30M_PCI, diva_pri_init_card},
	/*
	  PRI Rev.2 Cards
	*/
	{CARDTYPE_DIVASRV_P_30M_V2_PCI, diva_pri_init_card},
	/*
	  PRI Rev.2 VoIP Cards
	*/
	{CARDTYPE_DIVASRV_VOICE_P_30M_V2_PCI, diva_pri_init_card},
#endif
#ifdef CONFIG_ISDN_DIVAS_BRIPCI
	/*
	  4BRI Rev 1 Cards
	*/
	{CARDTYPE_DIVASRV_Q_8M_PCI, diva_4bri_init_card},
	{CARDTYPE_DIVASRV_VOICE_Q_8M_PCI, diva_4bri_init_card},
	/*
	  4BRI Rev 2 Cards
	*/
	{CARDTYPE_DIVASRV_Q_8M_V2_PCI, diva_4bri_init_card},
	{CARDTYPE_DIVASRV_VOICE_Q_8M_V2_PCI, diva_4bri_init_card},
	/*
	  4BRI Based BRI Rev 2 Cards
	*/
	{CARDTYPE_DIVASRV_B_2M_V2_PCI, diva_4bri_init_card},
	{CARDTYPE_DIVASRV_B_2F_PCI, diva_4bri_init_card},
	{CARDTYPE_DIVASRV_VOICE_B_2M_V2_PCI, diva_4bri_init_card},
	/*
	  BRI
	*/
	{CARDTYPE_MAESTRA_PCI, diva_bri_init_card},
#endif

	/*
	  EOL
	*/
	{-1}
};

static void diva_init_request_array(void);
static void *divas_create_pci_card(int handle, void *pci_dev_handle);

static diva_os_spin_lock_t adapter_lock;

static int diva_find_free_adapters(int base, int nr)
{
	int i;

	for (i = 0; i < nr; i++) {
		if (IoAdapters[base + i]) {
			return (-1);
		}
	}

	return (0);
}

static diva_os_xdi_adapter_t *diva_q_get_next(struct list_head *what)
{
	diva_os_xdi_adapter_t *a = NULL;

	if (what && (what->next != &adapter_queue))
		a = list_entry(what->next, diva_os_xdi_adapter_t, link);

	return (a);
}

/* --------------------------------------------------------------------------
   Add card to the card list
   -------------------------------------------------------------------------- */
void *diva_driver_add_card(void *pdev, unsigned long CardOrdinal)
{
	diva_os_spin_lock_magic_t old_irql;
	diva_os_xdi_adapter_t *pdiva, *pa;
	int i, j, max, nr;

	for (i = 0; divas_supported_cards[i].CardOrdinal != -1; i++) {
		if (divas_supported_cards[i].CardOrdinal == CardOrdinal) {
			if (!(pdiva = divas_create_pci_card(i, pdev))) {
				return NULL;
			}
			switch (CardOrdinal) {
			case CARDTYPE_DIVASRV_Q_8M_PCI:
			case CARDTYPE_DIVASRV_VOICE_Q_8M_PCI:
			case CARDTYPE_DIVASRV_Q_8M_V2_PCI:
			case CARDTYPE_DIVASRV_VOICE_Q_8M_V2_PCI:
				max = MAX_ADAPTER - 4;
				nr = 4;
				break;

			default:
				max = MAX_ADAPTER;
				nr = 1;
			}

			diva_os_enter_spin_lock(&adapter_lock, &old_irql, "add card");

			for (i = 0; i < max; i++) {
				if (!diva_find_free_adapters(i, nr)) {
					pdiva->controller = i + 1;
					pdiva->xdi_adapter.ANum = pdiva->controller;
					IoAdapters[i] = &pdiva->xdi_adapter;
					diva_os_leave_spin_lock(&adapter_lock, &old_irql, "add card");
					create_adapter_proc(pdiva);	/* add adapter to proc file system */

					DBG_LOG(("add %s:%d",
						 CardProperties
						 [CardOrdinal].Name,
						 pdiva->controller))

						diva_os_enter_spin_lock(&adapter_lock, &old_irql, "add card");
					pa = pdiva;
					for (j = 1; j < nr; j++) {	/* slave adapters, if any */
						pa = diva_q_get_next(&pa->link);
						if (pa && !pa->interface.cleanup_adapter_proc) {
							pa->controller = i + 1 + j;
							pa->xdi_adapter.ANum = pa->controller;
							IoAdapters[i + j] = &pa->xdi_adapter;
							diva_os_leave_spin_lock(&adapter_lock, &old_irql, "add card");
							DBG_LOG(("add slave adapter (%d)",
								 pa->controller))
								create_adapter_proc(pa);	/* add adapter to proc file system */
							diva_os_enter_spin_lock(&adapter_lock, &old_irql, "add card");
						} else {
							DBG_ERR(("slave adapter problem"))
								break;
						}
					}

					diva_os_leave_spin_lock(&adapter_lock, &old_irql, "add card");
					return (pdiva);
				}
			}

			diva_os_leave_spin_lock(&adapter_lock, &old_irql, "add card");

			/*
			  Not able to add adapter - remove it and return error
			*/
			DBG_ERR(("can not alloc request array"))
				diva_driver_remove_card(pdiva);

			return NULL;
		}
	}

	return NULL;
}

/* --------------------------------------------------------------------------
   Called on driver load, MAIN, main, DriverEntry
   -------------------------------------------------------------------------- */
int divasa_xdi_driver_entry(void)
{
	diva_os_initialize_spin_lock(&adapter_lock, "adapter");
	memset(&IoAdapters[0], 0x00, sizeof(IoAdapters));
	diva_init_request_array();

	return (0);
}

/* --------------------------------------------------------------------------
   Remove adapter from list
   -------------------------------------------------------------------------- */
static diva_os_xdi_adapter_t *get_and_remove_from_queue(void)
{
	diva_os_spin_lock_magic_t old_irql;
	diva_os_xdi_adapter_t *a = NULL;

	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "driver_unload");

	if (!list_empty(&adapter_queue)) {
		a = list_entry(adapter_queue.next, diva_os_xdi_adapter_t, link);
		list_del(adapter_queue.next);
	}

	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "driver_unload");
	return (a);
}

/* --------------------------------------------------------------------------
   Remove card from the card list
   -------------------------------------------------------------------------- */
void diva_driver_remove_card(void *pdiva)
{
	diva_os_spin_lock_magic_t old_irql;
	diva_os_xdi_adapter_t *a[4];
	diva_os_xdi_adapter_t *pa;
	int i;

	pa = a[0] = (diva_os_xdi_adapter_t *) pdiva;
	a[1] = a[2] = a[3] = NULL;

	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "remode adapter");

	for (i = 1; i < 4; i++) {
		if ((pa = diva_q_get_next(&pa->link))
		    && !pa->interface.cleanup_adapter_proc) {
			a[i] = pa;
		} else {
			break;
		}
	}

	for (i = 0; ((i < 4) && a[i]); i++) {
		list_del(&a[i]->link);
	}

	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "driver_unload");

	(*(a[0]->interface.cleanup_adapter_proc)) (a[0]);

	for (i = 0; i < 4; i++) {
		if (a[i]) {
			if (a[i]->controller) {
				DBG_LOG(("remove adapter (%d)",
					 a[i]->controller)) IoAdapters[a[i]->controller - 1] = NULL;
				remove_adapter_proc(a[i]);
			}
			diva_os_free(0, a[i]);
		}
	}
}

/* --------------------------------------------------------------------------
   Create diva PCI adapter and init internal adapter structures
   -------------------------------------------------------------------------- */
static void *divas_create_pci_card(int handle, void *pci_dev_handle)
{
	diva_supported_cards_info_t *pI = &divas_supported_cards[handle];
	diva_os_spin_lock_magic_t old_irql;
	diva_os_xdi_adapter_t *a;

	DBG_LOG(("found %d-%s", pI->CardOrdinal, CardProperties[pI->CardOrdinal].Name))

		if (!(a = (diva_os_xdi_adapter_t *) diva_os_malloc(0, sizeof(*a)))) {
			DBG_ERR(("A: can't alloc adapter"));
			return NULL;
		}

	memset(a, 0x00, sizeof(*a));

	a->CardIndex = handle;
	a->CardOrdinal = pI->CardOrdinal;
	a->Bus = DIVAS_XDI_ADAPTER_BUS_PCI;
	a->xdi_adapter.cardType = a->CardOrdinal;
	a->resources.pci.bus = diva_os_get_pci_bus(pci_dev_handle);
	a->resources.pci.func = diva_os_get_pci_func(pci_dev_handle);
	a->resources.pci.hdev = pci_dev_handle;

	/*
	  Add master adapter first, so slave adapters will receive higher
	  numbers as master adapter
	*/
	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "found_pci_card");
	list_add_tail(&a->link, &adapter_queue);
	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "found_pci_card");

	if ((*(pI->init_card)) (a)) {
		diva_os_enter_spin_lock(&adapter_lock, &old_irql, "found_pci_card");
		list_del(&a->link);
		diva_os_leave_spin_lock(&adapter_lock, &old_irql, "found_pci_card");
		diva_os_free(0, a);
		DBG_ERR(("A: can't get adapter resources"));
		return NULL;
	}

	return (a);
}

/* --------------------------------------------------------------------------
   Called on driver unload FINIT, finit, Unload
   -------------------------------------------------------------------------- */
void divasa_xdi_driver_unload(void)
{
	diva_os_xdi_adapter_t *a;

	while ((a = get_and_remove_from_queue())) {
		if (a->interface.cleanup_adapter_proc) {
			(*(a->interface.cleanup_adapter_proc)) (a);
		}
		if (a->controller) {
			IoAdapters[a->controller - 1] = NULL;
			remove_adapter_proc(a);
		}
		diva_os_free(0, a);
	}
	diva_os_destroy_spin_lock(&adapter_lock, "adapter");
}

/*
**  Receive and process command from user mode utility
*/
void *diva_xdi_open_adapter(void *os_handle, const void __user *src,
			    int length,
			    divas_xdi_copy_from_user_fn_t cp_fn)
{
	diva_xdi_um_cfg_cmd_t msg;
	diva_os_xdi_adapter_t *a = NULL;
	diva_os_spin_lock_magic_t old_irql;
	struct list_head *tmp;

	if (length < sizeof(diva_xdi_um_cfg_cmd_t)) {
		DBG_ERR(("A: A(?) open, msg too small (%d < %d)",
			 length, sizeof(diva_xdi_um_cfg_cmd_t)))
			return NULL;
	}
	if ((*cp_fn) (os_handle, &msg, src, sizeof(msg)) <= 0) {
		DBG_ERR(("A: A(?) open, write error"))
			return NULL;
	}
	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "open_adapter");
	list_for_each(tmp, &adapter_queue) {
		a = list_entry(tmp, diva_os_xdi_adapter_t, link);
		if (a->controller == (int)msg.adapter)
			break;
		a = NULL;
	}
	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "open_adapter");

	if (!a) {
		DBG_ERR(("A: A(%d) open, adapter not found", msg.adapter))
			}

	return (a);
}

/*
**  Easy cleanup mailbox status
*/
void diva_xdi_close_adapter(void *adapter, void *os_handle)
{
	diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) adapter;

	a->xdi_mbox.status &= ~DIVA_XDI_MBOX_BUSY;
	if (a->xdi_mbox.data) {
		diva_os_free(0, a->xdi_mbox.data);
		a->xdi_mbox.data = NULL;
	}
}

int
diva_xdi_write(void *adapter, void *os_handle, const void __user *src,
	       int length, divas_xdi_copy_from_user_fn_t cp_fn)
{
	diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) adapter;
	void *data;

	if (a->xdi_mbox.status & DIVA_XDI_MBOX_BUSY) {
		DBG_ERR(("A: A(%d) write, mbox busy", a->controller))
			return (-1);
	}

	if (length < sizeof(diva_xdi_um_cfg_cmd_t)) {
		DBG_ERR(("A: A(%d) write, message too small (%d < %d)",
			 a->controller, length,
			 sizeof(diva_xdi_um_cfg_cmd_t)))
			return (-3);
	}

	if (!(data = diva_os_malloc(0, length))) {
		DBG_ERR(("A: A(%d) write, ENOMEM", a->controller))
			return (-2);
	}

	length = (*cp_fn) (os_handle, data, src, length);
	if (length > 0) {
		if ((*(a->interface.cmd_proc))
		    (a, (diva_xdi_um_cfg_cmd_t *) data, length)) {
			length = -3;
		}
	} else {
		DBG_ERR(("A: A(%d) write error (%d)", a->controller,
			 length))
			}

	diva_os_free(0, data);

	return (length);
}

/*
**  Write answers to user mode utility, if any
*/
int
diva_xdi_read(void *adapter, void *os_handle, void __user *dst,
	      int max_length, divas_xdi_copy_to_user_fn_t cp_fn)
{
	diva_os_xdi_adapter_t *a = (diva_os_xdi_adapter_t *) adapter;
	int ret;

	if (!(a->xdi_mbox.status & DIVA_XDI_MBOX_BUSY)) {
		DBG_ERR(("A: A(%d) rx mbox empty", a->controller))
			return (-1);
	}
	if (!a->xdi_mbox.data) {
		a->xdi_mbox.status &= ~DIVA_XDI_MBOX_BUSY;
		DBG_ERR(("A: A(%d) rx ENOMEM", a->controller))
			return (-2);
	}

	if (max_length < a->xdi_mbox.data_length) {
		DBG_ERR(("A: A(%d) rx buffer too short(%d < %d)",
			 a->controller, max_length,
			 a->xdi_mbox.data_length))
			return (-3);
	}

	ret = (*cp_fn) (os_handle, dst, a->xdi_mbox.data,
			a->xdi_mbox.data_length);
	if (ret > 0) {
		diva_os_free(0, a->xdi_mbox.data);
		a->xdi_mbox.data = NULL;
		a->xdi_mbox.status &= ~DIVA_XDI_MBOX_BUSY;
	}

	return (ret);
}


irqreturn_t diva_os_irq_wrapper(int irq, void *context)
{
	diva_os_xdi_adapter_t *a = context;
	diva_xdi_clear_interrupts_proc_t clear_int_proc;

	if (!a || !a->xdi_adapter.diva_isr_handler)
		return IRQ_NONE;

	if ((clear_int_proc = a->clear_interrupts_proc)) {
		(*clear_int_proc) (a);
		a->clear_interrupts_proc = NULL;
		return IRQ_HANDLED;
	}

	(*(a->xdi_adapter.diva_isr_handler)) (&a->xdi_adapter);
	return IRQ_HANDLED;
}

static void diva_init_request_array(void)
{
	Requests[0] = DivaIdiRequest0;
	Requests[1] = DivaIdiRequest1;
	Requests[2] = DivaIdiRequest2;
	Requests[3] = DivaIdiRequest3;
	Requests[4] = DivaIdiRequest4;
	Requests[5] = DivaIdiRequest5;
	Requests[6] = DivaIdiRequest6;
	Requests[7] = DivaIdiRequest7;
	Requests[8] = DivaIdiRequest8;
	Requests[9] = DivaIdiRequest9;
	Requests[10] = DivaIdiRequest10;
	Requests[11] = DivaIdiRequest11;
	Requests[12] = DivaIdiRequest12;
	Requests[13] = DivaIdiRequest13;
	Requests[14] = DivaIdiRequest14;
	Requests[15] = DivaIdiRequest15;
	Requests[16] = DivaIdiRequest16;
	Requests[17] = DivaIdiRequest17;
	Requests[18] = DivaIdiRequest18;
	Requests[19] = DivaIdiRequest19;
	Requests[20] = DivaIdiRequest20;
	Requests[21] = DivaIdiRequest21;
	Requests[22] = DivaIdiRequest22;
	Requests[23] = DivaIdiRequest23;
	Requests[24] = DivaIdiRequest24;
	Requests[25] = DivaIdiRequest25;
	Requests[26] = DivaIdiRequest26;
	Requests[27] = DivaIdiRequest27;
	Requests[28] = DivaIdiRequest28;
	Requests[29] = DivaIdiRequest29;
	Requests[30] = DivaIdiRequest30;
	Requests[31] = DivaIdiRequest31;
}

void diva_xdi_display_adapter_features(int card)
{
	dword features;
	if (!card || ((card - 1) >= MAX_ADAPTER) || !IoAdapters[card - 1]) {
		return;
	}
	card--;
	features = IoAdapters[card]->Properties.Features;

	DBG_LOG(("FEATURES FOR ADAPTER: %d", card + 1))
		DBG_LOG((" DI_FAX3          :  %s",
			 (features & DI_FAX3) ? "Y" : "N"))
		DBG_LOG((" DI_MODEM         :  %s",
			 (features & DI_MODEM) ? "Y" : "N"))
		DBG_LOG((" DI_POST          :  %s",
			 (features & DI_POST) ? "Y" : "N"))
		DBG_LOG((" DI_V110          :  %s",
			 (features & DI_V110) ? "Y" : "N"))
		DBG_LOG((" DI_V120          :  %s",
			 (features & DI_V120) ? "Y" : "N"))
		DBG_LOG((" DI_POTS          :  %s",
			 (features & DI_POTS) ? "Y" : "N"))
		DBG_LOG((" DI_CODEC         :  %s",
			 (features & DI_CODEC) ? "Y" : "N"))
		DBG_LOG((" DI_MANAGE        :  %s",
			 (features & DI_MANAGE) ? "Y" : "N"))
		DBG_LOG((" DI_V_42          :  %s",
			 (features & DI_V_42) ? "Y" : "N"))
		DBG_LOG((" DI_EXTD_FAX      :  %s",
			 (features & DI_EXTD_FAX) ? "Y" : "N"))
		DBG_LOG((" DI_AT_PARSER     :  %s",
			 (features & DI_AT_PARSER) ? "Y" : "N"))
		DBG_LOG((" DI_VOICE_OVER_IP :  %s",
			 (features & DI_VOICE_OVER_IP) ? "Y" : "N"))
		}

void diva_add_slave_adapter(diva_os_xdi_adapter_t *a)
{
	diva_os_spin_lock_magic_t old_irql;

	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "add_slave");
	list_add_tail(&a->link, &adapter_queue);
	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "add_slave");
}

int diva_card_read_xlog(diva_os_xdi_adapter_t *a)
{
	diva_get_xlog_t *req;
	byte *data;

	if (!a->xdi_adapter.Initialized || !a->xdi_adapter.DIRequest) {
		return (-1);
	}
	if (!(data = diva_os_malloc(0, sizeof(struct mi_pc_maint)))) {
		return (-1);
	}
	memset(data, 0x00, sizeof(struct mi_pc_maint));

	if (!(req = diva_os_malloc(0, sizeof(*req)))) {
		diva_os_free(0, data);
		return (-1);
	}
	req->command = 0x0400;
	req->req = LOG;
	req->rc = 0x00;

	(*(a->xdi_adapter.DIRequest)) (&a->xdi_adapter, (ENTITY *) req);

	if (!req->rc || req->req) {
		diva_os_free(0, data);
		diva_os_free(0, req);
		return (-1);
	}

	memcpy(data, &req->req, sizeof(struct mi_pc_maint));

	diva_os_free(0, req);

	a->xdi_mbox.data_length = sizeof(struct mi_pc_maint);
	a->xdi_mbox.data = data;
	a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;

	return (0);
}

void xdiFreeFile(void *handle)
{
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/* $Id: diva.c,v 1.21.4.1 2004/05/08 14:33:43 armin Exp $ */
	3
	4	#define CARDTYPE_H_WANT_DATA 1
	5	#define CARDTYPE_H_WANT_IDI_DATA 0
	6	#define CARDTYPE_H_WANT_RESOURCE_DATA 0
	7	#define CARDTYPE_H_WANT_FILE_DATA 0
	8
	9	#include "platform.h"
	10	#include "debuglib.h"
	11	#include "cardtype.h"
	12	#include "pc.h"
	13	#include "di_defs.h"
	14	#include "di.h"
	15	#include "io.h"
	16	#include "pc_maint.h"
	17	#include "xdi_msg.h"
	18	#include "xdi_adapter.h"
	19	#include "diva_pci.h"
	20	#include "diva.h"
	21
	22	#ifdef CONFIG_ISDN_DIVAS_PRIPCI
	23	#include "os_pri.h"
	24	#endif
	25	#ifdef CONFIG_ISDN_DIVAS_BRIPCI
	26	#include "os_bri.h"
	27	#include "os_4bri.h"
	28	#endif
	29
	30	PISDN_ADAPTER IoAdapters[MAX_ADAPTER];
	31	extern IDI_CALL Requests[MAX_ADAPTER];
475be4d8 JP	32	extern int create_adapter_proc(diva_os_xdi_adapter_t *a);
475be4d8 JP	33	extern void remove_adapter_proc(diva_os_xdi_adapter_t *a);
1da177e4	34
475be4d8 JP	35	#define DivaIdiReqFunc(N) \
	36	static void DivaIdiRequest##N(ENTITY *e) \
	37	{ if (IoAdapters[N]) (*IoAdapters[N]->DIRequest)(IoAdapters[N], e); }
1da177e4 LT	38
	39	/*
	40	** Create own 32 Adapters
	41	*/
	42	DivaIdiReqFunc(0)
	43	DivaIdiReqFunc(1)
	44	DivaIdiReqFunc(2)
	45	DivaIdiReqFunc(3)
	46	DivaIdiReqFunc(4)
	47	DivaIdiReqFunc(5)
	48	DivaIdiReqFunc(6)
	49	DivaIdiReqFunc(7)
	50	DivaIdiReqFunc(8)
	51	DivaIdiReqFunc(9)
	52	DivaIdiReqFunc(10)
	53	DivaIdiReqFunc(11)
	54	DivaIdiReqFunc(12)
	55	DivaIdiReqFunc(13)
	56	DivaIdiReqFunc(14)
	57	DivaIdiReqFunc(15)
	58	DivaIdiReqFunc(16)
	59	DivaIdiReqFunc(17)
	60	DivaIdiReqFunc(18)
	61	DivaIdiReqFunc(19)
	62	DivaIdiReqFunc(20)
	63	DivaIdiReqFunc(21)
	64	DivaIdiReqFunc(22)
	65	DivaIdiReqFunc(23)
	66	DivaIdiReqFunc(24)
	67	DivaIdiReqFunc(25)
	68	DivaIdiReqFunc(26)
	69	DivaIdiReqFunc(27)
	70	DivaIdiReqFunc(28)
	71	DivaIdiReqFunc(29)
	72	DivaIdiReqFunc(30)
	73	DivaIdiReqFunc(31)
	74
1da177e4 LT	75	/*
	76	** LOCALS
	77	*/
	78	static LIST_HEAD(adapter_queue);
	79
	80	typedef struct _diva_get_xlog {
	81	word command;
	82	byte req;
	83	byte rc;
	84	byte data[sizeof(struct mi_pc_maint)];
	85	} diva_get_xlog_t;
	86
	87	typedef struct _diva_supported_cards_info {
	88	int CardOrdinal;
	89	diva_init_card_proc_t init_card;
	90	} diva_supported_cards_info_t;
	91
	92	static diva_supported_cards_info_t divas_supported_cards[] = {
	93	#ifdef CONFIG_ISDN_DIVAS_PRIPCI
	94	/*
475be4d8 JP	95	PRI Cards
475be4d8 JP	96	*/
1da177e4 LT	97	{CARDTYPE_DIVASRV_P_30M_PCI, diva_pri_init_card},
1da177e4 LT	98	/*
475be4d8 JP	99	PRI Rev.2 Cards
475be4d8 JP	100	*/
1da177e4 LT	101	{CARDTYPE_DIVASRV_P_30M_V2_PCI, diva_pri_init_card},
1da177e4 LT	102	/*
475be4d8 JP	103	PRI Rev.2 VoIP Cards
475be4d8 JP	104	*/
1da177e4 LT	105	{CARDTYPE_DIVASRV_VOICE_P_30M_V2_PCI, diva_pri_init_card},
	106	#endif
	107	#ifdef CONFIG_ISDN_DIVAS_BRIPCI
	108	/*
475be4d8 JP	109	4BRI Rev 1 Cards
475be4d8 JP	110	*/
1da177e4 LT	111	{CARDTYPE_DIVASRV_Q_8M_PCI, diva_4bri_init_card},
	112	{CARDTYPE_DIVASRV_VOICE_Q_8M_PCI, diva_4bri_init_card},
	113	/*
475be4d8 JP	114	4BRI Rev 2 Cards
475be4d8 JP	115	*/
1da177e4 LT	116	{CARDTYPE_DIVASRV_Q_8M_V2_PCI, diva_4bri_init_card},
	117	{CARDTYPE_DIVASRV_VOICE_Q_8M_V2_PCI, diva_4bri_init_card},
	118	/*
475be4d8 JP	119	4BRI Based BRI Rev 2 Cards
475be4d8 JP	120	*/
1da177e4 LT	121	{CARDTYPE_DIVASRV_B_2M_V2_PCI, diva_4bri_init_card},
	122	{CARDTYPE_DIVASRV_B_2F_PCI, diva_4bri_init_card},
	123	{CARDTYPE_DIVASRV_VOICE_B_2M_V2_PCI, diva_4bri_init_card},
	124	/*
475be4d8 JP	125	BRI
475be4d8 JP	126	*/
1da177e4 LT	127	{CARDTYPE_MAESTRA_PCI, diva_bri_init_card},
	128	#endif
	129
	130	/*
475be4d8 JP	131	EOL
475be4d8 JP	132	*/
1da177e4 LT	133	{-1}
	134	};
	135
	136	static void diva_init_request_array(void);
	137	static void divas_create_pci_card(int handle, void pci_dev_handle);
	138
	139	static diva_os_spin_lock_t adapter_lock;
	140
	141	static int diva_find_free_adapters(int base, int nr)
	142	{
	143	int i;
	144
	145	for (i = 0; i < nr; i++) {
	146	if (IoAdapters[base + i]) {
	147	return (-1);
	148	}
	149	}
	150
	151	return (0);
	152	}
	153
475be4d8	154	static diva_os_xdi_adapter_t diva_q_get_next(struct list_head what)
1da177e4 LT	155	{
	156	diva_os_xdi_adapter_t *a = NULL;
	157
	158	if (what && (what->next != &adapter_queue))
	159	a = list_entry(what->next, diva_os_xdi_adapter_t, link);
	160
475be4d8	161	return (a);
1da177e4 LT	162	}
	163
	164	/* --------------------------------------------------------------------------
475be4d8	165	Add card to the card list
1da177e4 LT	166	-------------------------------------------------------------------------- */
	167	void diva_driver_add_card(void pdev, unsigned long CardOrdinal)
	168	{
	169	diva_os_spin_lock_magic_t old_irql;
	170	diva_os_xdi_adapter_t pdiva, pa;
	171	int i, j, max, nr;
	172
	173	for (i = 0; divas_supported_cards[i].CardOrdinal != -1; i++) {
	174	if (divas_supported_cards[i].CardOrdinal == CardOrdinal) {
	175	if (!(pdiva = divas_create_pci_card(i, pdev))) {
	176	return NULL;
	177	}
	178	switch (CardOrdinal) {
	179	case CARDTYPE_DIVASRV_Q_8M_PCI:
	180	case CARDTYPE_DIVASRV_VOICE_Q_8M_PCI:
	181	case CARDTYPE_DIVASRV_Q_8M_V2_PCI:
	182	case CARDTYPE_DIVASRV_VOICE_Q_8M_V2_PCI:
	183	max = MAX_ADAPTER - 4;
	184	nr = 4;
	185	break;
	186
	187	default:
	188	max = MAX_ADAPTER;
	189	nr = 1;
	190	}
	191
	192	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "add card");
	193
	194	for (i = 0; i < max; i++) {
	195	if (!diva_find_free_adapters(i, nr)) {
	196	pdiva->controller = i + 1;
	197	pdiva->xdi_adapter.ANum = pdiva->controller;
	198	IoAdapters[i] = &pdiva->xdi_adapter;
	199	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "add card");
	200	create_adapter_proc(pdiva); /* add adapter to proc file system */
	201
	202	DBG_LOG(("add %s:%d",
	203	CardProperties
	204	[CardOrdinal].Name,
	205	pdiva->controller))
	206
475be4d8	207	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "add card");
1da177e4 LT	208	pa = pdiva;
	209	for (j = 1; j < nr; j++) { /* slave adapters, if any */
	210	pa = diva_q_get_next(&pa->link);
	211	if (pa && !pa->interface.cleanup_adapter_proc) {
	212	pa->controller = i + 1 + j;
	213	pa->xdi_adapter.ANum = pa->controller;
	214	IoAdapters[i + j] = &pa->xdi_adapter;
	215	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "add card");
	216	DBG_LOG(("add slave adapter (%d)",
	217	pa->controller))
475be4d8	218	create_adapter_proc(pa); /* add adapter to proc file system */
1da177e4 LT	219	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "add card");
	220	} else {
	221	DBG_ERR(("slave adapter problem"))
475be4d8	222	break;
1da177e4 LT	223	}
	224	}
	225
	226	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "add card");
	227	return (pdiva);
	228	}
	229	}
	230
	231	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "add card");
	232
	233	/*
475be4d8 JP	234	Not able to add adapter - remove it and return error
475be4d8 JP	235	*/
1da177e4	236	DBG_ERR(("can not alloc request array"))
475be4d8	237	diva_driver_remove_card(pdiva);
1da177e4 LT	238
	239	return NULL;
	240	}
	241	}
	242
	243	return NULL;
	244	}
	245
	246	/* --------------------------------------------------------------------------
475be4d8	247	Called on driver load, MAIN, main, DriverEntry
1da177e4 LT	248	-------------------------------------------------------------------------- */
	249	int divasa_xdi_driver_entry(void)
	250	{
	251	diva_os_initialize_spin_lock(&adapter_lock, "adapter");
	252	memset(&IoAdapters[0], 0x00, sizeof(IoAdapters));
	253	diva_init_request_array();
	254
	255	return (0);
	256	}
	257
	258	/* --------------------------------------------------------------------------
475be4d8	259	Remove adapter from list
1da177e4 LT	260	-------------------------------------------------------------------------- */
	261	static diva_os_xdi_adapter_t *get_and_remove_from_queue(void)
	262	{
	263	diva_os_spin_lock_magic_t old_irql;
	264	diva_os_xdi_adapter_t *a = NULL;
	265
	266	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "driver_unload");
	267
	268	if (!list_empty(&adapter_queue)) {
	269	a = list_entry(adapter_queue.next, diva_os_xdi_adapter_t, link);
	270	list_del(adapter_queue.next);
	271	}
	272
	273	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "driver_unload");
	274	return (a);
	275	}
	276
	277	/* --------------------------------------------------------------------------
475be4d8	278	Remove card from the card list
1da177e4 LT	279	-------------------------------------------------------------------------- */
	280	void diva_driver_remove_card(void *pdiva)
	281	{
	282	diva_os_spin_lock_magic_t old_irql;
	283	diva_os_xdi_adapter_t *a[4];
	284	diva_os_xdi_adapter_t *pa;
	285	int i;
	286
	287	pa = a[0] = (diva_os_xdi_adapter_t *) pdiva;
	288	a[1] = a[2] = a[3] = NULL;
	289
	290	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "remode adapter");
	291
	292	for (i = 1; i < 4; i++) {
	293	if ((pa = diva_q_get_next(&pa->link))
	294	&& !pa->interface.cleanup_adapter_proc) {
	295	a[i] = pa;
	296	} else {
	297	break;
	298	}
	299	}
	300
	301	for (i = 0; ((i < 4) && a[i]); i++) {
	302	list_del(&a[i]->link);
	303	}
	304
	305	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "driver_unload");
	306
	307	(*(a[0]->interface.cleanup_adapter_proc)) (a[0]);
	308
	309	for (i = 0; i < 4; i++) {
	310	if (a[i]) {
	311	if (a[i]->controller) {
	312	DBG_LOG(("remove adapter (%d)",
	313	a[i]->controller)) IoAdapters[a[i]->controller - 1] = NULL;
	314	remove_adapter_proc(a[i]);
	315	}
	316	diva_os_free(0, a[i]);
	317	}
	318	}
	319	}
	320
	321	/* --------------------------------------------------------------------------
475be4d8	322	Create diva PCI adapter and init internal adapter structures
1da177e4 LT	323	-------------------------------------------------------------------------- */
	324	static void divas_create_pci_card(int handle, void pci_dev_handle)
	325	{
	326	diva_supported_cards_info_t *pI = &divas_supported_cards[handle];
	327	diva_os_spin_lock_magic_t old_irql;
	328	diva_os_xdi_adapter_t *a;
	329
	330	DBG_LOG(("found %d-%s", pI->CardOrdinal, CardProperties[pI->CardOrdinal].Name))
	331
475be4d8 JP	332	if (!(a = (diva_os_xdi_adapter_t ) diva_os_malloc(0, sizeof(a)))) {
	333	DBG_ERR(("A: can't alloc adapter"));
	334	return NULL;
	335	}
1da177e4 LT	336
	337	memset(a, 0x00, sizeof(*a));
	338
	339	a->CardIndex = handle;
	340	a->CardOrdinal = pI->CardOrdinal;
	341	a->Bus = DIVAS_XDI_ADAPTER_BUS_PCI;
	342	a->xdi_adapter.cardType = a->CardOrdinal;
	343	a->resources.pci.bus = diva_os_get_pci_bus(pci_dev_handle);
	344	a->resources.pci.func = diva_os_get_pci_func(pci_dev_handle);
	345	a->resources.pci.hdev = pci_dev_handle;
	346
	347	/*
475be4d8 JP	348	Add master adapter first, so slave adapters will receive higher
	349	numbers as master adapter
	350	*/
1da177e4 LT	351	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "found_pci_card");
	352	list_add_tail(&a->link, &adapter_queue);
	353	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "found_pci_card");
	354
	355	if ((*(pI->init_card)) (a)) {
	356	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "found_pci_card");
	357	list_del(&a->link);
	358	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "found_pci_card");
	359	diva_os_free(0, a);
	360	DBG_ERR(("A: can't get adapter resources"));
	361	return NULL;
	362	}
	363
	364	return (a);
	365	}
	366
	367	/* --------------------------------------------------------------------------
475be4d8	368	Called on driver unload FINIT, finit, Unload
1da177e4 LT	369	-------------------------------------------------------------------------- */
	370	void divasa_xdi_driver_unload(void)
	371	{
	372	diva_os_xdi_adapter_t *a;
	373
	374	while ((a = get_and_remove_from_queue())) {
	375	if (a->interface.cleanup_adapter_proc) {
	376	(*(a->interface.cleanup_adapter_proc)) (a);
	377	}
	378	if (a->controller) {
	379	IoAdapters[a->controller - 1] = NULL;
	380	remove_adapter_proc(a);
	381	}
	382	diva_os_free(0, a);
	383	}
	384	diva_os_destroy_spin_lock(&adapter_lock, "adapter");
	385	}
	386
	387	/*
	388	** Receive and process command from user mode utility
	389	*/
	390	void diva_xdi_open_adapter(void os_handle, const void __user *src,
	391	int length,
	392	divas_xdi_copy_from_user_fn_t cp_fn)
	393	{
	394	diva_xdi_um_cfg_cmd_t msg;
	395	diva_os_xdi_adapter_t *a = NULL;
	396	diva_os_spin_lock_magic_t old_irql;
	397	struct list_head *tmp;
	398
	399	if (length < sizeof(diva_xdi_um_cfg_cmd_t)) {
	400	DBG_ERR(("A: A(?) open, msg too small (%d < %d)",
	401	length, sizeof(diva_xdi_um_cfg_cmd_t)))
475be4d8	402	return NULL;
1da177e4 LT	403	}
	404	if ((*cp_fn) (os_handle, &msg, src, sizeof(msg)) <= 0) {
	405	DBG_ERR(("A: A(?) open, write error"))
475be4d8	406	return NULL;
1da177e4 LT	407	}
	408	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "open_adapter");
	409	list_for_each(tmp, &adapter_queue) {
	410	a = list_entry(tmp, diva_os_xdi_adapter_t, link);
	411	if (a->controller == (int)msg.adapter)
	412	break;
	413	a = NULL;
	414	}
	415	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "open_adapter");
	416
	417	if (!a) {
	418	DBG_ERR(("A: A(%d) open, adapter not found", msg.adapter))
475be4d8	419	}
1da177e4 LT	420
	421	return (a);
	422	}
	423
	424	/*
	425	** Easy cleanup mailbox status
	426	*/
	427	void diva_xdi_close_adapter(void adapter, void os_handle)
	428	{
	429	diva_os_xdi_adapter_t a = (diva_os_xdi_adapter_t ) adapter;
	430
	431	a->xdi_mbox.status &= ~DIVA_XDI_MBOX_BUSY;
	432	if (a->xdi_mbox.data) {
	433	diva_os_free(0, a->xdi_mbox.data);
	434	a->xdi_mbox.data = NULL;
	435	}
	436	}
	437
	438	int
	439	diva_xdi_write(void adapter, void os_handle, const void __user *src,
	440	int length, divas_xdi_copy_from_user_fn_t cp_fn)
	441	{
	442	diva_os_xdi_adapter_t a = (diva_os_xdi_adapter_t ) adapter;
	443	void *data;
	444
	445	if (a->xdi_mbox.status & DIVA_XDI_MBOX_BUSY) {
	446	DBG_ERR(("A: A(%d) write, mbox busy", a->controller))
475be4d8	447	return (-1);
1da177e4 LT	448	}
	449
	450	if (length < sizeof(diva_xdi_um_cfg_cmd_t)) {
	451	DBG_ERR(("A: A(%d) write, message too small (%d < %d)",
	452	a->controller, length,
	453	sizeof(diva_xdi_um_cfg_cmd_t)))
475be4d8	454	return (-3);
1da177e4 LT	455	}
	456
	457	if (!(data = diva_os_malloc(0, length))) {
	458	DBG_ERR(("A: A(%d) write, ENOMEM", a->controller))
475be4d8	459	return (-2);
1da177e4 LT	460	}
	461
	462	length = (*cp_fn) (os_handle, data, src, length);
	463	if (length > 0) {
	464	if ((*(a->interface.cmd_proc))
	465	(a, (diva_xdi_um_cfg_cmd_t *) data, length)) {
	466	length = -3;
	467	}
	468	} else {
	469	DBG_ERR(("A: A(%d) write error (%d)", a->controller,
	470	length))
475be4d8	471	}
1da177e4 LT	472
	473	diva_os_free(0, data);
	474
	475	return (length);
	476	}
	477
	478	/*
	479	** Write answers to user mode utility, if any
	480	*/
	481	int
	482	diva_xdi_read(void adapter, void os_handle, void __user *dst,
	483	int max_length, divas_xdi_copy_to_user_fn_t cp_fn)
	484	{
	485	diva_os_xdi_adapter_t a = (diva_os_xdi_adapter_t ) adapter;
	486	int ret;
	487
	488	if (!(a->xdi_mbox.status & DIVA_XDI_MBOX_BUSY)) {
	489	DBG_ERR(("A: A(%d) rx mbox empty", a->controller))
475be4d8	490	return (-1);
1da177e4 LT	491	}
	492	if (!a->xdi_mbox.data) {
	493	a->xdi_mbox.status &= ~DIVA_XDI_MBOX_BUSY;
	494	DBG_ERR(("A: A(%d) rx ENOMEM", a->controller))
475be4d8	495	return (-2);
1da177e4 LT	496	}
	497
	498	if (max_length < a->xdi_mbox.data_length) {
	499	DBG_ERR(("A: A(%d) rx buffer too short(%d < %d)",
	500	a->controller, max_length,
	501	a->xdi_mbox.data_length))
475be4d8	502	return (-3);
1da177e4 LT	503	}
	504
	505	ret = (*cp_fn) (os_handle, dst, a->xdi_mbox.data,
475be4d8	506	a->xdi_mbox.data_length);
1da177e4 LT	507	if (ret > 0) {
	508	diva_os_free(0, a->xdi_mbox.data);
	509	a->xdi_mbox.data = NULL;
	510	a->xdi_mbox.status &= ~DIVA_XDI_MBOX_BUSY;
	511	}
	512
	513	return (ret);
	514	}
	515
	516
7d12e780	517	irqreturn_t diva_os_irq_wrapper(int irq, void *context)
1da177e4	518	{
15aafa2f	519	diva_os_xdi_adapter_t *a = context;
1da177e4 LT	520	diva_xdi_clear_interrupts_proc_t clear_int_proc;
1da177e4 LT	521
15aafa2f	522	if (!a \|\| !a->xdi_adapter.diva_isr_handler)
1da177e4	523	return IRQ_NONE;
1da177e4 LT	524
	525	if ((clear_int_proc = a->clear_interrupts_proc)) {
	526	(*clear_int_proc) (a);
	527	a->clear_interrupts_proc = NULL;
	528	return IRQ_HANDLED;
	529	}
	530
	531	(*(a->xdi_adapter.diva_isr_handler)) (&a->xdi_adapter);
	532	return IRQ_HANDLED;
	533	}
	534
	535	static void diva_init_request_array(void)
	536	{
	537	Requests[0] = DivaIdiRequest0;
	538	Requests[1] = DivaIdiRequest1;
	539	Requests[2] = DivaIdiRequest2;
	540	Requests[3] = DivaIdiRequest3;
	541	Requests[4] = DivaIdiRequest4;
	542	Requests[5] = DivaIdiRequest5;
	543	Requests[6] = DivaIdiRequest6;
	544	Requests[7] = DivaIdiRequest7;
	545	Requests[8] = DivaIdiRequest8;
	546	Requests[9] = DivaIdiRequest9;
	547	Requests[10] = DivaIdiRequest10;
	548	Requests[11] = DivaIdiRequest11;
	549	Requests[12] = DivaIdiRequest12;
	550	Requests[13] = DivaIdiRequest13;
	551	Requests[14] = DivaIdiRequest14;
	552	Requests[15] = DivaIdiRequest15;
	553	Requests[16] = DivaIdiRequest16;
	554	Requests[17] = DivaIdiRequest17;
	555	Requests[18] = DivaIdiRequest18;
	556	Requests[19] = DivaIdiRequest19;
	557	Requests[20] = DivaIdiRequest20;
	558	Requests[21] = DivaIdiRequest21;
	559	Requests[22] = DivaIdiRequest22;
	560	Requests[23] = DivaIdiRequest23;
	561	Requests[24] = DivaIdiRequest24;
	562	Requests[25] = DivaIdiRequest25;
	563	Requests[26] = DivaIdiRequest26;
	564	Requests[27] = DivaIdiRequest27;
	565	Requests[28] = DivaIdiRequest28;
	566	Requests[29] = DivaIdiRequest29;
	567	Requests[30] = DivaIdiRequest30;
	568	Requests[31] = DivaIdiRequest31;
	569	}
	570
	571	void diva_xdi_display_adapter_features(int card)
	572	{
	573	dword features;
	574	if (!card \|\| ((card - 1) >= MAX_ADAPTER) \|\| !IoAdapters[card - 1]) {
	575	return;
	576	}
	577	card--;
	578	features = IoAdapters[card]->Properties.Features;
	579
	580	DBG_LOG(("FEATURES FOR ADAPTER: %d", card + 1))
475be4d8 JP	581	DBG_LOG((" DI_FAX3 : %s",
	582	(features & DI_FAX3) ? "Y" : "N"))
	583	DBG_LOG((" DI_MODEM : %s",
	584	(features & DI_MODEM) ? "Y" : "N"))
	585	DBG_LOG((" DI_POST : %s",
	586	(features & DI_POST) ? "Y" : "N"))
	587	DBG_LOG((" DI_V110 : %s",
	588	(features & DI_V110) ? "Y" : "N"))
	589	DBG_LOG((" DI_V120 : %s",
	590	(features & DI_V120) ? "Y" : "N"))
	591	DBG_LOG((" DI_POTS : %s",
	592	(features & DI_POTS) ? "Y" : "N"))
	593	DBG_LOG((" DI_CODEC : %s",
	594	(features & DI_CODEC) ? "Y" : "N"))
	595	DBG_LOG((" DI_MANAGE : %s",
	596	(features & DI_MANAGE) ? "Y" : "N"))
	597	DBG_LOG((" DI_V_42 : %s",
	598	(features & DI_V_42) ? "Y" : "N"))
	599	DBG_LOG((" DI_EXTD_FAX : %s",
	600	(features & DI_EXTD_FAX) ? "Y" : "N"))
	601	DBG_LOG((" DI_AT_PARSER : %s",
	602	(features & DI_AT_PARSER) ? "Y" : "N"))
	603	DBG_LOG((" DI_VOICE_OVER_IP : %s",
	604	(features & DI_VOICE_OVER_IP) ? "Y" : "N"))
	605	}
1da177e4	606
475be4d8	607	void diva_add_slave_adapter(diva_os_xdi_adapter_t *a)
1da177e4 LT	608	{
	609	diva_os_spin_lock_magic_t old_irql;
	610
	611	diva_os_enter_spin_lock(&adapter_lock, &old_irql, "add_slave");
	612	list_add_tail(&a->link, &adapter_queue);
	613	diva_os_leave_spin_lock(&adapter_lock, &old_irql, "add_slave");
	614	}
	615
475be4d8	616	int diva_card_read_xlog(diva_os_xdi_adapter_t *a)
1da177e4 LT	617	{
	618	diva_get_xlog_t *req;
	619	byte *data;
	620
	621	if (!a->xdi_adapter.Initialized \|\| !a->xdi_adapter.DIRequest) {
	622	return (-1);
	623	}
	624	if (!(data = diva_os_malloc(0, sizeof(struct mi_pc_maint)))) {
	625	return (-1);
	626	}
	627	memset(data, 0x00, sizeof(struct mi_pc_maint));
	628
	629	if (!(req = diva_os_malloc(0, sizeof(*req)))) {
	630	diva_os_free(0, data);
	631	return (-1);
	632	}
	633	req->command = 0x0400;
	634	req->req = LOG;
	635	req->rc = 0x00;
	636
	637	((a->xdi_adapter.DIRequest)) (&a->xdi_adapter, (ENTITY ) req);
	638
	639	if (!req->rc \|\| req->req) {
	640	diva_os_free(0, data);
	641	diva_os_free(0, req);
	642	return (-1);
	643	}
	644
	645	memcpy(data, &req->req, sizeof(struct mi_pc_maint));
	646
	647	diva_os_free(0, req);
	648
	649	a->xdi_mbox.data_length = sizeof(struct mi_pc_maint);
	650	a->xdi_mbox.data = data;
	651	a->xdi_mbox.status = DIVA_XDI_MBOX_BUSY;
	652
	653	return (0);
	654	}
	655
	656	void xdiFreeFile(void *handle)
	657	{
	658	}