// 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, void *mptr, divas_xdi_copy_from_user_fn_t cp_fn) { diva_xdi_um_cfg_cmd_t *msg = (diva_xdi_um_cfg_cmd_t *)mptr; 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, void *mptr, divas_xdi_copy_from_user_fn_t cp_fn) { diva_xdi_um_cfg_cmd_t *msg = (diva_xdi_um_cfg_cmd_t *)mptr; 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); } if (msg) { *(diva_xdi_um_cfg_cmd_t *)data = *msg; length = (*cp_fn) (os_handle, (char *)data + sizeof(*msg), src + sizeof(*msg), length - sizeof(*msg)); } else { 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) { }