Skip to content

L
linux
Commit 6cc9cb58 authored by Kai Germaschewski's avatar Kai Germaschewski
Browse files
Options

ISDN/HiSax: Introduce methods for reset/test/release/ 

This mostly finishes splitting up the multiplexing ->cardmsg.
parent 02f7568c
Hide whitespace changes
Inline Side-by-side
Showing with 608 additions and 682 deletions
drivers/isdn/hisax/asuscom.c
View file @ 6cc9cb58
......@@ -257,52 +257,45 @@ asuscom_ipac_interrupt(int intno, void *dev_id, struct pt_regs *regs)
writereg(cs, cs->hw.asus.isac, IPAC_MASK, 0xC0);
}
void
release_io_asuscom(struct IsdnCardState *cs)
static void
asuscom_release(struct IsdnCardState *cs)
{
int bytecnt = 8;
if (cs->hw.asus.cfg_reg)
release_region(cs->hw.asus.cfg_reg, bytecnt);
release_region(cs->hw.asus.cfg_reg, 8);
}
static void
reset_asuscom(struct IsdnCardState *cs)
static int
asuscom_reset(struct IsdnCardState *cs)
{
if (cs->subtyp == ASUS_IPAC)
writereg(cs, cs->hw.asus.isac, IPAC_POTA2, 0x20);
else
byteout(cs->hw.asus.adr, ASUS_RESET); /* Reset On */
byteout(cs->hw.asus.adr, ASUS_RESET); /* Reset On */
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
if (cs->subtyp == ASUS_IPAC)
writereg(cs, cs->hw.asus.isac, IPAC_POTA2, 0x0);
else
byteout(cs->hw.asus.adr, 0); /* Reset Off */
byteout(cs->hw.asus.adr, 0); /* Reset Off */
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
if (cs->subtyp == ASUS_IPAC) {
writereg(cs, cs->hw.asus.isac, IPAC_CONF, 0x0);
writereg(cs, cs->hw.asus.isac, IPAC_ACFG, 0xff);
writereg(cs, cs->hw.asus.isac, IPAC_AOE, 0x0);
writereg(cs, cs->hw.asus.isac, IPAC_MASK, 0xc0);
writereg(cs, cs->hw.asus.isac, IPAC_PCFG, 0x12);
}
return 0;
}
static int
asuscom_ipac_reset(struct IsdnCardState *cs)
{
writereg(cs, cs->hw.asus.isac, IPAC_POTA2, 0x20);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writereg(cs, cs->hw.asus.isac, IPAC_POTA2, 0x0);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writereg(cs, cs->hw.asus.isac, IPAC_CONF, 0x0);
writereg(cs, cs->hw.asus.isac, IPAC_ACFG, 0xff);
writereg(cs, cs->hw.asus.isac, IPAC_AOE, 0x0);
writereg(cs, cs->hw.asus.isac, IPAC_MASK, 0xc0);
writereg(cs, cs->hw.asus.isac, IPAC_PCFG, 0x12);
return 0;
}
static int
Asus_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_asuscom(cs);
return(0);
case CARD_RELEASE:
release_io_asuscom(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
......@@ -315,11 +308,15 @@ asuscom_init(struct IsdnCardState *cs)
static struct card_ops asuscom_ops = {
.init = asuscom_init,
.reset = asuscom_reset,
.release = asuscom_release,
.irq_func = asuscom_interrupt,
};
static struct card_ops asuscom_ipac_ops = {
.init = asuscom_init,
.reset = asuscom_ipac_reset,
.release = asuscom_release,
.irq_func = asuscom_ipac_interrupt,
};
......@@ -434,11 +431,11 @@ setup_asuscom(struct IsdnCard *card)
if (HscxVersion(cs, "ISDNLink:")) {
printk(KERN_WARNING
"ISDNLink: wrong HSCX versions check IO address\n");
release_io_asuscom(cs);
asuscom_release(cs);
return (0);
}
}
printk(KERN_INFO "ISDNLink: resetting card\n");
reset_asuscom(cs);
cs->card_ops->reset(cs);
return (1);
}
drivers/isdn/hisax/avm_a1.c
View file @ 6cc9cb58
......@@ -167,15 +167,6 @@ release_ioregs(struct IsdnCardState *cs, int mask)
static int
AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
return(0);
case CARD_RELEASE:
release_ioregs(cs, 0x3f);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
......@@ -187,8 +178,15 @@ avm_a1_init(struct IsdnCardState *cs)
inithscxisac(cs);
}
static void
avm_a1_release(struct IsdnCardState *cs)
{
release_ioregs(cs, 0x3f);
}
static struct card_ops avm_a1_ops = {
.init = avm_a1_init,
.release = avm_a1_release,
.irq_func = avm_a1_interrupt,
};
......
drivers/isdn/hisax/avm_a1p.c
View file @ 6cc9cb58
......@@ -192,28 +192,6 @@ avm_a1p_interrupt(int intno, void *dev_id, struct pt_regs *regs)
static int
AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
byteout(cs->hw.avm.cfg_reg+ASL0_OFFSET,0x00);
HZDELAY(HZ / 5 + 1);
byteout(cs->hw.avm.cfg_reg+ASL0_OFFSET,ASL0_W_RESET);
HZDELAY(HZ / 5 + 1);
byteout(cs->hw.avm.cfg_reg+ASL0_OFFSET,0x00);
return 0;
case CARD_RELEASE:
/* free_irq is done in HiSax_closecard(). */
/* free_irq(cs->irq, cs); */
return 0;
case CARD_TEST:
/* we really don't need it for the PCMCIA Version */
return 0;
default:
/* all card drivers ignore others, so we do the same */
return 0;
}
return 0;
}
......@@ -225,8 +203,21 @@ avm_a1p_init(struct IsdnCardState *cs)
inithscxisac(cs);
}
static int
avm_a1p_reset(struct IsdnCardState *cs)
{
byteout(cs->hw.avm.cfg_reg+ASL0_OFFSET,0x00);
HZDELAY(HZ / 5 + 1);
byteout(cs->hw.avm.cfg_reg+ASL0_OFFSET,ASL0_W_RESET);
HZDELAY(HZ / 5 + 1);
byteout(cs->hw.avm.cfg_reg+ASL0_OFFSET,0x00);
return 0;
}
static struct card_ops avm_a1p_ops = {
.init = avm_a1p_init,
.reset = avm_a1p_reset,
.irq_func = avm_a1p_interrupt,
};
......
drivers/isdn/hisax/avm_pci.c
View file @ 6cc9cb58
......@@ -556,8 +556,14 @@ avm_pcipnp_interrupt(int intno, void *dev_id, struct pt_regs *regs)
WriteISAC(cs, ISAC_MASK, 0x0);
}
static void
reset_avmpcipnp(struct IsdnCardState *cs)
static int
AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
return(0);
}
static int
avm_pcipnp_reset(struct IsdnCardState *cs)
{
printk(KERN_INFO "AVM PCI/PnP: reset\n");
outb(AVM_STATUS0_RESET | AVM_STATUS0_DIS_TIMER, cs->hw.avm.cfg_reg + 2);
......@@ -568,27 +574,11 @@ reset_avmpcipnp(struct IsdnCardState *cs)
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000); /* Timeout 10ms */
printk(KERN_INFO "AVM PCI/PnP: S1 %x\n", inb(cs->hw.avm.cfg_reg + 3));
}
static int
AVM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_avmpcipnp(cs);
return(0);
case CARD_RELEASE:
outb(0, cs->hw.avm.cfg_reg + 2);
release_region(cs->hw.avm.cfg_reg, 32);
return(0);
case CARD_TEST:
return(0);
}
return(0);
return 0;
}
static void
avm_pci_init(struct IsdnCardState *cs)
avm_pcipnp_init(struct IsdnCardState *cs)
{
initisac(cs);
inithdlc(cs);
......@@ -598,8 +588,17 @@ avm_pci_init(struct IsdnCardState *cs)
AVM_STATUS0_ENA_IRQ, cs->hw.avm.cfg_reg + 2);
}
static void
avm_pcipnp_release(struct IsdnCardState *cs)
{
outb(0, cs->hw.avm.cfg_reg + 2);
release_region(cs->hw.avm.cfg_reg, 32);
}
static struct card_ops avm_pci_ops = {
.init = avm_pci_init,
.init = avm_pcipnp_init,
.reset = avm_pcipnp_reset,
.release = avm_pcipnp_release,
.irq_func = avm_pcipnp_interrupt,
};
......@@ -714,7 +713,7 @@ setup_avm_pcipnp(struct IsdnCard *card)
val = inb(cs->hw.avm.cfg_reg);
ver = inb(cs->hw.avm.cfg_reg + 1);
printk(KERN_INFO "AVM PnP: Class %X Rev %d\n", val, ver);
reset_avmpcipnp(cs);
avm_pcipnp_reset(cs);
break;
}
printk(KERN_INFO "HiSax: %s config irq:%d base:0x%X\n",
......
drivers/isdn/hisax/bkm_a4t.c
View file @ 6cc9cb58
......@@ -233,21 +233,6 @@ reset_bkm(struct IsdnCardState *cs)
static int
BKM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
/* Disable ints */
enable_bkm_int(cs, 0);
reset_bkm(cs);
return (0);
case CARD_RELEASE:
/* Sanity */
enable_bkm_int(cs, 0);
reset_bkm(cs);
release_io_bkm(cs);
return (0);
case CARD_TEST:
return (0);
}
return (0);
}
......@@ -260,8 +245,27 @@ bkm_a4t_init(struct IsdnCardState *cs)
enable_bkm_int(cs, 1);
}
static int
bkm_a4t_reset(struct IsdnCardState *cs)
{
/* Disable ints */
enable_bkm_int(cs, 0);
reset_bkm(cs);
return 0;
}
static void
bkm_a4t_release(struct IsdnCardState *cs)
{
enable_bkm_int(cs, 0);
reset_bkm(cs);
release_io_bkm(cs);
}
static struct card_ops bkm_a4t_ops = {
.init = bkm_a4t_init,
.reset = bkm_a4t_reset,
.release = bkm_a4t_release,
.irq_func = bkm_interrupt,
};
......
drivers/isdn/hisax/bkm_a8.c
View file @ 6cc9cb58
......@@ -241,22 +241,6 @@ reset_bkm(struct IsdnCardState *cs)
static int
BKM_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
/* Disable ints */
set_ipac_active(cs, 0);
enable_bkm_int(cs, 0);
reset_bkm(cs);
return (0);
case CARD_RELEASE:
/* Sanity */
set_ipac_active(cs, 0);
enable_bkm_int(cs, 0);
release_io_sct_quadro(cs);
return (0);
case CARD_TEST:
return (0);
}
return (0);
}
......@@ -270,8 +254,28 @@ bkm_a8_init(struct IsdnCardState *cs)
enable_bkm_int(cs, 1);
}
static int
bkm_a8_reset(struct IsdnCardState *cs)
{
/* Disable ints */
set_ipac_active(cs, 0);
enable_bkm_int(cs, 0);
reset_bkm(cs);
return 0;
}
static void
bkm_a8_release(struct IsdnCardState *cs)
{
set_ipac_active(cs, 0);
enable_bkm_int(cs, 0);
release_io_sct_quadro(cs);
}
static struct card_ops bkm_a8_ops = {
.init = bkm_a8_init,
.reset = bkm_a8_reset,
.release = bkm_a8_release,
.irq_func = bkm_a8_interrupt,
};
......
drivers/isdn/hisax/callc.c
View file @ 6cc9cb58
......@@ -1458,12 +1458,8 @@ lli_got_fac_req(struct Channel *chanp, capi_msg *cm) {
void
lli_got_manufacturer(struct Channel *chanp, struct IsdnCardState *cs, capi_msg *cm) {
if ((cs->typ == ISDN_CTYPE_ELSA) || (cs->typ == ISDN_CTYPE_ELSA_PNP) ||
(cs->typ == ISDN_CTYPE_ELSA_PCI)) {
if (cs->hw.elsa.MFlag) {
cs->cardmsg(cs, CARD_AUX_IND, cm->para);
}
}
if (cs->card_ops->aux_ind)
cs->card_ops->aux_ind(cs, cm->para);
}
......
drivers/isdn/hisax/config.c
View file @ 6cc9cb58
......@@ -843,8 +843,8 @@ static void closecard(int cardnr)
if (csta->DC_Close != NULL) {
csta->DC_Close(csta);
}
if (csta->cardmsg)
csta->cardmsg(csta, CARD_RELEASE, NULL);
if (csta->card_ops->release)
csta->card_ops->release(csta);
if (csta->dbusytimer.function != NULL) // FIXME?
del_timer(&csta->dbusytimer);
ll_unload(csta);
......@@ -879,11 +879,13 @@ static int __devinit init_card(struct IsdnCardState *cs)
free_irq(cs->irq, cs);
return 2;
} else {
cs->cardmsg(cs, CARD_RESET, NULL);
if (cs->card_ops->reset)
cs->card_ops->reset(cs);
cnt--;
}
} else {
cs->cardmsg(cs, CARD_TEST, NULL);
if (cs->card_ops->test)
cs->card_ops->test(cs);
return 0;
}
}
......
drivers/isdn/hisax/diva.c
View file @ 6cc9cb58
......@@ -506,83 +506,103 @@ diva_ipacx_pci_irq(int intno, void *dev_id, struct pt_regs *regs)
*cfg = PITA_INT0_STATUS; // Reset PLX interrupt
}
void
release_io_diva(struct IsdnCardState *cs)
static void
diva_release(struct IsdnCardState *cs)
{
int bytecnt;
if ((cs->subtyp == DIVA_IPAC_PCI) ||
(cs->subtyp == DIVA_IPACX_PCI) ) {
u_int *cfg = (unsigned int *)cs->hw.diva.pci_cfg;
del_timer(&cs->hw.diva.tl);
if (cs->hw.diva.cfg_reg)
byteout(cs->hw.diva.ctrl, 0); /* LED off, Reset */
*cfg = 0; /* disable INT0/1 */
*cfg = 2; /* reset pending INT0 */
iounmap((void *)cs->hw.diva.cfg_reg);
iounmap((void *)cs->hw.diva.pci_cfg);
return;
} else if (cs->subtyp != DIVA_IPAC_ISA) {
del_timer(&cs->hw.diva.tl);
if (cs->hw.diva.cfg_reg)
byteout(cs->hw.diva.ctrl, 0); /* LED off, Reset */
}
if ((cs->subtyp == DIVA_ISA) || (cs->subtyp == DIVA_IPAC_ISA))
if (cs->subtyp == DIVA_ISA)
bytecnt = 8;
else
bytecnt = 32;
if (cs->hw.diva.cfg_reg) {
if (cs->hw.diva.cfg_reg)
release_region(cs->hw.diva.cfg_reg, bytecnt);
}
}
static void
reset_diva(struct IsdnCardState *cs)
diva_ipac_isa_release(struct IsdnCardState *cs)
{
if (cs->subtyp == DIVA_IPAC_ISA) {
writereg(cs->hw.diva.isac_adr, cs->hw.diva.isac, IPAC_POTA2, 0x20);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writereg(cs->hw.diva.isac_adr, cs->hw.diva.isac, IPAC_POTA2, 0x00);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writereg(cs->hw.diva.isac_adr, cs->hw.diva.isac, IPAC_MASK, 0xc0);
} else if (cs->subtyp == DIVA_IPAC_PCI) {
unsigned int *ireg = (unsigned int *)(cs->hw.diva.pci_cfg +
PITA_MISC_REG);
*ireg = PITA_PARA_SOFTRESET | PITA_PARA_MPX_MODE;
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
*ireg = PITA_PARA_MPX_MODE;
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
memwritereg(cs->hw.diva.cfg_reg, IPAC_MASK, 0xc0);
} else if (cs->subtyp == DIVA_IPACX_PCI) {
unsigned int *ireg = (unsigned int *)(cs->hw.diva.pci_cfg +
PITA_MISC_REG);
*ireg = PITA_PARA_SOFTRESET | PITA_PARA_MPX_MODE;
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
*ireg = PITA_PARA_MPX_MODE | PITA_SER_SOFTRESET;
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
ipacx_dc_write(cs, IPACX_MASK, 0xff); // Interrupts off
} else { /* DIVA 2.0 */
cs->hw.diva.ctrl_reg = 0; /* Reset On */
byteout(cs->hw.diva.ctrl, cs->hw.diva.ctrl_reg);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
cs->hw.diva.ctrl_reg |= DIVA_RESET; /* Reset Off */
byteout(cs->hw.diva.ctrl, cs->hw.diva.ctrl_reg);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
if (cs->subtyp == DIVA_ISA)
cs->hw.diva.ctrl_reg |= DIVA_ISA_LED_A;
else {
/* Workaround PCI9060 */
byteout(cs->hw.diva.pci_cfg + 0x69, 9);
cs->hw.diva.ctrl_reg |= DIVA_PCI_LED_A;
}
byteout(cs->hw.diva.ctrl, cs->hw.diva.ctrl_reg);
if (cs->hw.diva.cfg_reg)
release_region(cs->hw.diva.cfg_reg, 8);
}
static void
diva_ipac_pci_release(struct IsdnCardState *cs)
{
writel(0, cs->hw.diva.pci_cfg); /* disable INT0/1 */
writel(2, cs->hw.diva.pci_cfg); /* reset pending INT0 */
iounmap((void *)cs->hw.diva.cfg_reg);
iounmap((void *)cs->hw.diva.pci_cfg);
}
static int
diva_ipac_isa_reset(struct IsdnCardState *cs)
{
writereg(cs->hw.diva.isac_adr, cs->hw.diva.isac, IPAC_POTA2, 0x20);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writereg(cs->hw.diva.isac_adr, cs->hw.diva.isac, IPAC_POTA2, 0x00);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writereg(cs->hw.diva.isac_adr, cs->hw.diva.isac, IPAC_MASK, 0xc0);
return 0;
}
static int
diva_ipac_pci_reset(struct IsdnCardState *cs)
{
unsigned long misc_reg = cs->hw.diva.pci_cfg + PITA_MISC_REG;
writel(PITA_PARA_SOFTRESET | PITA_PARA_MPX_MODE, misc_reg);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writel(PITA_PARA_MPX_MODE, misc_reg);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
memwritereg(cs->hw.diva.cfg_reg, IPAC_MASK, 0xc0);
return 0;
}
static int
diva_ipacx_pci_reset(struct IsdnCardState *cs)
{
unsigned long misc_reg = cs->hw.diva.pci_cfg + PITA_MISC_REG;
writel(PITA_PARA_SOFTRESET | PITA_PARA_MPX_MODE, misc_reg);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writel(PITA_PARA_MPX_MODE | PITA_SER_SOFTRESET, misc_reg);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
ipacx_dc_write(cs, IPACX_MASK, 0xff); // Interrupts off
return 0;
}
static int
diva_reset(struct IsdnCardState *cs)
{
/* DIVA 2.0 */
cs->hw.diva.ctrl_reg = 0; /* Reset On */
byteout(cs->hw.diva.ctrl, cs->hw.diva.ctrl_reg);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
cs->hw.diva.ctrl_reg |= DIVA_RESET; /* Reset Off */
byteout(cs->hw.diva.ctrl, cs->hw.diva.ctrl_reg);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
if (cs->subtyp == DIVA_ISA) {
cs->hw.diva.ctrl_reg |= DIVA_ISA_LED_A;
} else {
/* Workaround PCI9060 */
byteout(cs->hw.diva.pci_cfg + 0x69, 9);
cs->hw.diva.ctrl_reg |= DIVA_PCI_LED_A;
}
byteout(cs->hw.diva.ctrl, cs->hw.diva.ctrl_reg);
return 0;
}
#define DIVA_ASSIGN 1
......@@ -629,14 +649,6 @@ static int
Diva_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_diva(cs);
return(0);
case CARD_RELEASE:
release_io_diva(cs);
return(0);
case CARD_TEST:
return(0);
case (MDL_REMOVE | REQUEST):
cs->hw.diva.status = 0;
break;
......@@ -688,21 +700,29 @@ diva_ipac_pci_init(struct IsdnCardState *cs)
static struct card_ops diva_ops = {
.init = inithscxisac,
.reset = diva_reset,
.release = diva_release,
.irq_func = diva_interrupt,
};
static struct card_ops diva_ipac_isa_ops = {
.init = inithscxisac,
.reset = diva_ipac_isa_reset,
.release = diva_ipac_isa_release,
.irq_func = diva_ipac_isa_irq,
};
static struct card_ops diva_ipac_pci_ops = {
.init = diva_ipac_pci_init,
.reset = diva_ipac_pci_reset,
.release = diva_ipac_pci_release,
.irq_func = diva_ipac_pci_irq,
};
static struct card_ops diva_ipacx_pci_ops = {
.init = diva_ipacx_pci_init,
.reset = diva_ipacx_pci_reset,
.release = diva_ipac_pci_release,
.irq_func = diva_ipacx_pci_irq,
};
......@@ -939,27 +959,30 @@ setup_diva(struct IsdnCard *card)
request_region(cs->hw.diva.cfg_reg, bytecnt, "diva isdn");
}
}
reset_diva(cs);
cs->bc_hw_ops = &hscx_ops;
cs->cardmsg = &Diva_card_msg;
if (cs->subtyp == DIVA_IPAC_ISA) {
diva_ipac_isa_reset(cs);
cs->dc_hw_ops = &ipac_dc_ops;
cs->card_ops = &diva_ipac_isa_ops;
val = readreg(cs->hw.diva.isac_adr, cs->hw.diva.isac, IPAC_ID);
printk(KERN_INFO "Diva: IPAC version %x\n", val);
} else if (cs->subtyp == DIVA_IPAC_PCI) {
diva_ipac_pci_reset(cs);
cs->dc_hw_ops = &mem_ipac_dc_ops;
cs->bc_hw_ops = &mem_hscx_ops;
cs->card_ops = &diva_ipac_pci_ops;
val = memreadreg(cs->hw.diva.cfg_reg, IPAC_ID);
printk(KERN_INFO "Diva: IPAC version %x\n", val);
} else if (cs->subtyp == DIVA_IPACX_PCI) {
diva_ipacx_pci_reset(cs);
cs->dc_hw_ops = &ipacx_dc_ops;
cs->bc_hw_ops = &ipacx_bc_ops;
cs->card_ops = &diva_ipacx_pci_ops;
printk(KERN_INFO "Diva: IPACX Design Id: %x\n",
ipacx_dc_read(cs, IPACX_ID) &0x3F);
} else { /* DIVA 2.0 */
diva_reset(cs);
cs->hw.diva.tl.function = (void *) diva_led_handler;
cs->hw.diva.tl.data = (long) cs;
init_timer(&cs->hw.diva.tl);
......@@ -969,7 +992,7 @@ setup_diva(struct IsdnCard *card)
if (HscxVersion(cs, "Diva:")) {
printk(KERN_WARNING
"Diva: wrong HSCX versions check IO address\n");
release_io_diva(cs);
diva_release(cs);
return (0);
}
}
......
drivers/isdn/hisax/elsa.c
View file @ 6cc9cb58
......@@ -450,8 +450,8 @@ elsa_interrupt_ipac(int intno, void *dev_id, struct pt_regs *regs)
writereg(cs, cs->hw.elsa.isac, IPAC_MASK, 0xC0);
}
void
release_io_elsa(struct IsdnCardState *cs)
static void
elsa_release(struct IsdnCardState *cs)
{
int bytecnt = 8;
......@@ -488,8 +488,8 @@ release_io_elsa(struct IsdnCardState *cs)
release_region(cs->hw.elsa.base, bytecnt);
}
static void
reset_elsa(struct IsdnCardState *cs)
static int
elsa_reset(struct IsdnCardState *cs)
{
if (cs->hw.elsa.timer) {
/* Wait 1 Timer */
......@@ -531,6 +531,7 @@ reset_elsa(struct IsdnCardState *cs)
else if (cs->subtyp == ELSA_QS3000PCI)
byteout(cs->hw.elsa.cfg + 0x4c, 0x43); /* enable ELSA PCI IRQ */
}
return 0;
}
#if ARCOFI_USE
......@@ -679,50 +680,6 @@ Elsa_card_msg(struct IsdnCardState *cs, int mt, void *arg)
int ret = 0;
switch (mt) {
case CARD_RESET:
reset_elsa(cs);
return(0);
case CARD_RELEASE:
release_io_elsa(cs);
return(0);
case CARD_TEST:
if ((cs->subtyp == ELSA_PCMCIA) ||
(cs->subtyp == ELSA_PCMCIA_IPAC) ||
(cs->subtyp == ELSA_QS1000PCI)) {
return(0);
} else if (cs->subtyp == ELSA_QS3000PCI) {
ret = 0;
} else {
cs->hw.elsa.counter = 0;
cs->hw.elsa.ctrl_reg |= ELSA_ENA_TIMER_INT;
cs->hw.elsa.status |= ELSA_TIMER_AKTIV;
byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
byteout(cs->hw.elsa.timer, 0);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((110*HZ)/1000);
cs->hw.elsa.ctrl_reg &= ~ELSA_ENA_TIMER_INT;
byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
cs->hw.elsa.status &= ~ELSA_TIMER_AKTIV;
printk(KERN_INFO "Elsa: %d timer tics in 110 msek\n",
cs->hw.elsa.counter);
if ((cs->hw.elsa.counter > 10) &&
(cs->hw.elsa.counter < 16)) {
printk(KERN_INFO "Elsa: timer and irq OK\n");
ret = 0;
} else {
printk(KERN_WARNING
"Elsa: timer tic problem (%d/12) maybe an IRQ(%d) conflict\n",
cs->hw.elsa.counter, cs->irq);
ret = 1;
}
}
#if ARCOFI_USE
if (check_arcofi(cs)) {
init_modem(cs);
}
#endif
elsa_led_handler(cs);
return(ret);
case (MDL_REMOVE | REQUEST):
cs->hw.elsa.status &= 0;
break;
......@@ -750,21 +707,6 @@ Elsa_card_msg(struct IsdnCardState *cs, int mt, void *arg)
cs->hw.elsa.status &= ~0x0100;
}
break;
#if ARCOFI_USE
case CARD_AUX_IND:
if (cs->hw.elsa.MFlag) {
int len;
u8 *msg;
if (!arg)
return(0);
msg = arg;
len = *msg;
msg++;
modem_write_cmd(cs, msg, len);
}
break;
#endif
}
if (cs->typ == ISDN_CTYPE_ELSA) {
int pwr = bytein(cs->hw.elsa.ale);
......@@ -777,6 +719,26 @@ Elsa_card_msg(struct IsdnCardState *cs, int mt, void *arg)
return(ret);
}
#if ARCOFI_USE
static void
elsa_aux_ind(struct IsdnCardState *cs, void *arg)
{
if (cs->hw.elsa.MFlag) {
int len;
u8 *msg;
if (!arg)
return;
msg = arg;
len = *msg;
msg++;
modem_write_cmd(cs, msg, len);
}
}
#else
#define elsa_aux_ind NULL
#endif
static void
elsa_init(struct IsdnCardState *cs)
{
......@@ -790,13 +752,59 @@ elsa_init(struct IsdnCardState *cs)
inithscxisac(cs);
}
static void
elsa_test(struct IsdnCardState *cs)
{
if ((cs->subtyp == ELSA_PCMCIA) ||
(cs->subtyp == ELSA_PCMCIA_IPAC) ||
(cs->subtyp == ELSA_QS1000PCI)) {
return;
}
if (cs->subtyp != ELSA_QS3000PCI) {
cs->hw.elsa.counter = 0;
cs->hw.elsa.ctrl_reg |= ELSA_ENA_TIMER_INT;
cs->hw.elsa.status |= ELSA_TIMER_AKTIV;
byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
byteout(cs->hw.elsa.timer, 0);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((110*HZ)/1000);
cs->hw.elsa.ctrl_reg &= ~ELSA_ENA_TIMER_INT;
byteout(cs->hw.elsa.ctrl, cs->hw.elsa.ctrl_reg);
cs->hw.elsa.status &= ~ELSA_TIMER_AKTIV;
printk(KERN_INFO "Elsa: %d timer tics in 110 msek\n",
cs->hw.elsa.counter);
if ((cs->hw.elsa.counter > 10) &&
(cs->hw.elsa.counter < 16)) {
printk(KERN_INFO "Elsa: timer and irq OK\n");
} else {
printk(KERN_WARNING
"Elsa: timer tic problem (%d/12) maybe an IRQ(%d) conflict\n",
cs->hw.elsa.counter, cs->irq);
}
}
#if ARCOFI_USE
if (check_arcofi(cs)) {
init_modem(cs);
}
#endif
elsa_led_handler(cs);
}
static struct card_ops elsa_ops = {
.init = elsa_init,
.init = elsa_init,
.test = elsa_test,
.reset = elsa_reset,
.release = elsa_release,
.aux_ind = elsa_aux_ind,
.irq_func = elsa_interrupt,
};
static struct card_ops elsa_ipac_ops = {
.init = elsa_init,
.test = elsa_test,
.reset = elsa_reset,
.release = elsa_release,
.aux_ind = elsa_aux_ind,
.irq_func = elsa_interrupt_ipac,
};
......@@ -1168,21 +1176,21 @@ setup_elsa(struct IsdnCard *card)
if (!TimerRun(cs)) {
printk(KERN_WARNING
"Elsa: timer do not start\n");
release_io_elsa(cs);
elsa_release(cs);
return (0);
}
}
HZDELAY(1); /* wait >=10 ms */
if (TimerRun(cs)) {
printk(KERN_WARNING "Elsa: timer do not run down\n");
release_io_elsa(cs);
elsa_release(cs);
return (0);
}
printk(KERN_INFO "Elsa: timer OK; resetting card\n");
}
cs->bc_hw_ops = &hscx_ops;
cs->cardmsg = &Elsa_card_msg;
reset_elsa(cs);
elsa_reset(cs);
if ((cs->subtyp == ELSA_QS1000PCI) || (cs->subtyp == ELSA_QS3000PCI) || (cs->subtyp == ELSA_PCMCIA_IPAC)) {
cs->dc_hw_ops = &ipac_dc_ops;
cs->card_ops = &elsa_ipac_ops;
......@@ -1195,7 +1203,7 @@ setup_elsa(struct IsdnCard *card)
if (HscxVersion(cs, "Elsa:")) {
printk(KERN_WARNING
"Elsa: wrong HSCX versions check IO address\n");
release_io_elsa(cs);
elsa_release(cs);
return (0);
}
}
......
drivers/isdn/hisax/enternow_pci.c
View file @ 6cc9cb58
......@@ -162,15 +162,6 @@ enpci_card_msg(struct IsdnCardState *cs, int mt, void *arg)
debugl1(cs, "enter:now PCI: card_msg: 0x%04X", mt);
switch (mt) {
case CARD_RESET:
reset_enpci(cs);
Amd7930_init(cs);
break;
case CARD_RELEASE:
release_io_netjet(cs);
break;
case CARD_TEST:
break;
case MDL_ASSIGN:
/* TEI assigned, LED1 on */
cs->hw.njet.auxd = TJ_AMD_IRQ << 1;
......@@ -221,6 +212,14 @@ enpci_init(struct IsdnCardState *cs)
Amd7930_init(cs);
}
static int
enpci_reset(struct IsdnCardState *cs)
{
reset_enpci(cs);
Amd7930_init(cs);
return 0;
}
static void
enpci_interrupt(int intno, void *dev_id, struct pt_regs *regs)
{
......@@ -270,6 +269,8 @@ enpci_interrupt(int intno, void *dev_id, struct pt_regs *regs)
static struct card_ops enpci_ops = {
.init = enpci_init,
.reset = enpci_reset,
.release = netjet_release,
.irq_func = enpci_interrupt,
};
......
drivers/isdn/hisax/gazel.c
View file @ 6cc9cb58
......@@ -324,104 +324,109 @@ gazel_ipac_interrupt(int intno, void *dev_id, struct pt_regs *regs)
writereg_ipac(cs, IPAC_MASK, 0xFF);
writereg_ipac(cs, IPAC_MASK, 0xC0);
}
void
release_io_gazel(struct IsdnCardState *cs)
static void
gazel_release(struct IsdnCardState *cs)
{
unsigned int i;
switch (cs->subtyp) {
case R647:
for (i = 0x0000; i < 0xC000; i += 0x1000)
release_region(i + cs->hw.gazel.hscx[0], 16);
release_region(0xC000 + cs->hw.gazel.hscx[0], 1);
break;
case R647:
for (i = 0x0000; i < 0xC000; i += 0x1000)
release_region(i + cs->hw.gazel.hscx[0], 16);
release_region(0xC000 + cs->hw.gazel.hscx[0], 1);
break;
case R685:
release_region(cs->hw.gazel.hscx[0], 0x100);
release_region(cs->hw.gazel.cfg_reg, 0x80);
break;
}
}
case R685:
release_region(cs->hw.gazel.hscx[0], 0x100);
release_region(cs->hw.gazel.cfg_reg, 0x80);
break;
static void
gazel_ipac_release(struct IsdnCardState *cs)
{
switch (cs->subtyp) {
case R753:
release_region(cs->hw.gazel.ipac, 0x8);
release_region(cs->hw.gazel.cfg_reg, 0x80);
break;
case R742:
release_region(cs->hw.gazel.ipac, 8);
break;
}
}
case R753:
release_region(cs->hw.gazel.ipac, 0x8);
release_region(cs->hw.gazel.cfg_reg, 0x80);
break;
static int
gazel_reset(struct IsdnCardState *cs)
{
unsigned long plxcntrl, addr = cs->hw.gazel.cfg_reg;
case R742:
release_region(cs->hw.gazel.ipac, 8);
break;
switch (cs->subtyp) {
case R647:
writereg(addr, 0, 0);
HZDELAY(10);
writereg(addr, 0, 1);
HZDELAY(2);
break;
case R685:
plxcntrl = inl(addr + PLX_CNTRL);
plxcntrl |= (RESET_9050 + RESET_GAZEL);
outl(plxcntrl, addr + PLX_CNTRL);
plxcntrl &= ~(RESET_9050 + RESET_GAZEL);
HZDELAY(4);
outl(plxcntrl, addr + PLX_CNTRL);
HZDELAY(10);
outb(INT_ISAC_EN + INT_HSCX_EN + INT_PCI_EN, addr + PLX_INCSR);
break;
}
return 0;
}
static int
reset_gazel(struct IsdnCardState *cs)
gazel_ipac_reset(struct IsdnCardState *cs)
{
unsigned long plxcntrl, addr = cs->hw.gazel.cfg_reg;
switch (cs->subtyp) {
case R647:
writereg(addr, 0, 0);
HZDELAY(10);
writereg(addr, 0, 1);
HZDELAY(2);
break;
case R685:
case R753:
if (test_bit(FLG_BUGGY_PLX9050, &cs->HW_Flags))
/* we can't read, assume the default */
plxcntrl = 0x18784db6;
else
plxcntrl = inl(addr + PLX_CNTRL);
plxcntrl |= (RESET_9050 + RESET_GAZEL);
outl(plxcntrl, addr + PLX_CNTRL);
plxcntrl &= ~(RESET_9050 + RESET_GAZEL);
HZDELAY(4);
outl(plxcntrl, addr + PLX_CNTRL);
HZDELAY(10);
outb(INT_ISAC_EN + INT_HSCX_EN + INT_PCI_EN, addr + PLX_INCSR);
break;
case R753:
if (test_bit(FLG_BUGGY_PLX9050, &cs->HW_Flags))
/* we can't read, assume the default */
plxcntrl = 0x18784db6;
else
plxcntrl = inl(addr + PLX_CNTRL);
plxcntrl |= (RESET_9050 + RESET_GAZEL);
outl(plxcntrl, addr + PLX_CNTRL);
writereg_ipac(cs, IPAC_POTA2, 0x20);
HZDELAY(4);
plxcntrl &= ~(RESET_9050 + RESET_GAZEL);
outl(plxcntrl, addr + PLX_CNTRL);
HZDELAY(10);
writereg_ipac(cs, IPAC_POTA2, 0x00);
writereg_ipac(cs, IPAC_ACFG, 0xff);
writereg_ipac(cs, IPAC_AOE, 0x0);
writereg_ipac(cs, IPAC_MASK, 0xff);
writereg_ipac(cs, IPAC_CONF, 0x1);
outb(INT_IPAC_EN + INT_PCI_EN, addr + PLX_INCSR);
writereg_ipac(cs, IPAC_MASK, 0xc0);
break;
case R742:
writereg_ipac(cs, IPAC_POTA2, 0x20);
HZDELAY(4);
writereg_ipac(cs, IPAC_POTA2, 0x00);
writereg_ipac(cs, IPAC_ACFG, 0xff);
writereg_ipac(cs, IPAC_AOE, 0x0);
writereg_ipac(cs, IPAC_MASK, 0xff);
writereg_ipac(cs, IPAC_CONF, 0x1);
writereg_ipac(cs, IPAC_MASK, 0xc0);
break;
plxcntrl |= (RESET_9050 + RESET_GAZEL);
outl(plxcntrl, addr + PLX_CNTRL);
writereg_ipac(cs, IPAC_POTA2, 0x20);
HZDELAY(4);
plxcntrl &= ~(RESET_9050 + RESET_GAZEL);
outl(plxcntrl, addr + PLX_CNTRL);
HZDELAY(10);
writereg_ipac(cs, IPAC_POTA2, 0x00);
writereg_ipac(cs, IPAC_ACFG, 0xff);
writereg_ipac(cs, IPAC_AOE, 0x0);
writereg_ipac(cs, IPAC_MASK, 0xff);
writereg_ipac(cs, IPAC_CONF, 0x1);
outb(INT_IPAC_EN + INT_PCI_EN, addr + PLX_INCSR);
writereg_ipac(cs, IPAC_MASK, 0xc0);
break;
case R742:
writereg_ipac(cs, IPAC_POTA2, 0x20);
HZDELAY(4);
writereg_ipac(cs, IPAC_POTA2, 0x00);
writereg_ipac(cs, IPAC_ACFG, 0xff);
writereg_ipac(cs, IPAC_AOE, 0x0);
writereg_ipac(cs, IPAC_MASK, 0xff);
writereg_ipac(cs, IPAC_CONF, 0x1);
writereg_ipac(cs, IPAC_MASK, 0xc0);
break;
}
return (0);
return 0;
}
static int
Gazel_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_gazel(cs);
return (0);
case CARD_RELEASE:
release_io_gazel(cs);
return (0);
case CARD_TEST:
return (0);
}
return (0);
}
......@@ -438,11 +443,15 @@ gazel_init(struct IsdnCardState *cs)
static struct card_ops gazel_ops = {
.init = gazel_init,
.reset = gazel_reset,
.release = gazel_release,
.irq_func = gazel_interrupt,
};
static struct card_ops gazel_ipac_ops = {
.init = inithscxisac,
.reset = gazel_ipac_reset,
.release = gazel_ipac_release,
.irq_func = gazel_ipac_interrupt,
};
......@@ -683,11 +692,6 @@ setup_gazel(struct IsdnCard *card)
if (reserve_regions(card, cs)) {
return (0);
}
if (reset_gazel(cs)) {
printk(KERN_WARNING "Gazel: wrong IRQ\n");
release_io_gazel(cs);
return (0);
}
cs->dc_hw_ops = &isac_ops;
cs->bc_hw_ops = &hscx_ops;
cs->cardmsg = &Gazel_card_msg;
......@@ -695,17 +699,19 @@ setup_gazel(struct IsdnCard *card)
switch (cs->subtyp) {
case R647:
case R685:
gazel_reset(cs);
cs->card_ops = &gazel_ops;
ISACVersion(cs, "Gazel:");
if (HscxVersion(cs, "Gazel:")) {
printk(KERN_WARNING
"Gazel: wrong HSCX versions check IO address\n");
release_io_gazel(cs);
gazel_release(cs);
return (0);
}
break;
case R742:
case R753:
gazel_ipac_reset(cs);
cs->card_ops = &gazel_ipac_ops;
val = readreg_ipac(cs, IPAC_ID);
printk(KERN_INFO "Gazel: IPAC version %x\n", val);
......
drivers/isdn/hisax/hfc_pci.c
View file @ 6cc9cb58
......@@ -70,8 +70,8 @@ static const PCI_ENTRY id_list[] =
/******************************************/
/* free hardware resources used by driver */
/******************************************/
void
release_io_hfcpci(struct IsdnCardState *cs)
static void
hfcpci_release(struct IsdnCardState *cs)
{
printk(KERN_INFO "HiSax: release hfcpci at %p\n",
cs->hw.hfcpci.pci_io);
......@@ -91,8 +91,8 @@ release_io_hfcpci(struct IsdnCardState *cs)
/* function called to reset the HFC PCI chip. A complete software reset of chip */
/* and fifos is done. */
/********************************************************************************/
static void
reset_hfcpci(struct IsdnCardState *cs)
static int
hfcpci_reset(struct IsdnCardState *cs)
{
pci_disable_device(cs->hw.hfcpci.pdev);
cs->hw.hfcpci.int_m2 = 0; /* interrupt output off ! */
......@@ -159,6 +159,8 @@ reset_hfcpci(struct IsdnCardState *cs)
cs->hw.hfcpci.int_m2 = HFCPCI_IRQ_ENABLE;
Write_hfc(cs, HFCPCI_INT_M2, cs->hw.hfcpci.int_m2);
if (Read_hfc(cs, HFCPCI_INT_S2));
return 0;
}
/***************************************************/
......@@ -1366,18 +1368,6 @@ inithfcpci(struct IsdnCardState *cs)
static int
hfcpci_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
if (cs->debug & L1_DEB_ISAC)
debugl1(cs, "HFCPCI: card_msg %x", mt);
switch (mt) {
case CARD_RESET:
reset_hfcpci(cs);
return (0);
case CARD_RELEASE:
release_io_hfcpci(cs);
return (0);
case CARD_TEST:
return (0);
}
return (0);
}
......@@ -1396,6 +1386,8 @@ hfcpci_init(struct IsdnCardState *cs)
static struct card_ops hfcpci_ops = {
.init = hfcpci_init,
.reset = hfcpci_reset,
.release = hfcpci_release,
.irq_func = hfcpci_interrupt,
};
......@@ -1488,7 +1480,7 @@ setup_hfcpci(struct IsdnCard *card)
cs->hw.hfcpci.timer.data = (long) cs;
init_timer(&cs->hw.hfcpci.timer);
reset_hfcpci(cs);
hfcpci_reset(cs);
cs->cardmsg = &hfcpci_card_msg;
cs->auxcmd = &hfcpci_auxcmd;
cs->card_ops = &hfcpci_ops;
......
drivers/isdn/hisax/hfc_sx.c
View file @ 6cc9cb58
......@@ -308,8 +308,8 @@ read_fifo(struct IsdnCardState *cs, u8 fifo, int trans_max)
/******************************************/
/* free hardware resources used by driver */
/******************************************/
void
release_io_hfcsx(struct IsdnCardState *cs)
static void
hfcsx_release(struct IsdnCardState *cs)
{
cs->hw.hfcsx.int_m2 = 0; /* interrupt output off ! */
Write_hfc(cs, HFCSX_INT_M2, cs->hw.hfcsx.int_m2);
......@@ -347,8 +347,8 @@ static int set_fifo_size(struct IsdnCardState *cs)
/* function called to reset the HFC SX chip. A complete software reset of chip */
/* and fifos is done. */
/********************************************************************************/
static void
reset_hfcsx(struct IsdnCardState *cs)
static int
hfcsx_reset(struct IsdnCardState *cs)
{
cs->hw.hfcsx.int_m2 = 0; /* interrupt output off ! */
Write_hfc(cs, HFCSX_INT_M2, cs->hw.hfcsx.int_m2);
......@@ -415,6 +415,7 @@ reset_hfcsx(struct IsdnCardState *cs)
cs->hw.hfcsx.int_m2 = HFCSX_IRQ_ENABLE;
Write_hfc(cs, HFCSX_INT_M2, cs->hw.hfcsx.int_m2);
if (Read_hfc(cs, HFCSX_INT_S2));
return 0;
}
/***************************************************/
......@@ -1143,18 +1144,6 @@ inithfcsx(struct IsdnCardState *cs)
static int
hfcsx_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
if (cs->debug & L1_DEB_ISAC)
debugl1(cs, "HFCSX: card_msg %x", mt);
switch (mt) {
case CARD_RESET:
reset_hfcsx(cs);
return (0);
case CARD_RELEASE:
release_io_hfcsx(cs);
return (0);
case CARD_TEST:
return (0);
}
return (0);
}
......@@ -1173,6 +1162,8 @@ hfcsx_init(struct IsdnCardState *cs)
static struct card_ops hfcsx_ops = {
.init = hfcsx_init,
.reset = hfcsx_reset,
.release = hfcsx_release,
.irq_func = hfcsx_interrupt,
};
......@@ -1300,7 +1291,7 @@ setup_hfcsx(struct IsdnCard *card)
cs->hw.hfcsx.cirm = ccd_sp_irqtab[cs->irq & 0xF]; /* RAM not evaluated */
init_timer(&cs->hw.hfcsx.timer);
reset_hfcsx(cs);
hfcsx_reset(cs);
cs->cardmsg = &hfcsx_card_msg;
cs->auxcmd = &hfcsx_auxcmd;
cs->card_ops = &hfcsx_ops;
......
drivers/isdn/hisax/hfcscard.c
View file @ 6cc9cb58
......@@ -64,8 +64,8 @@ hfcs_Timer(struct IsdnCardState *cs)
*/
}
void
release_io_hfcs(struct IsdnCardState *cs)
static void
hfcs_release(struct IsdnCardState *cs)
{
release2bds0(cs);
del_timer(&cs->hw.hfcD.timer);
......@@ -73,8 +73,8 @@ release_io_hfcs(struct IsdnCardState *cs)
release_region(cs->hw.hfcD.addr, 2);
}
static void
reset_hfcs(struct IsdnCardState *cs)
static int
hfcs_reset(struct IsdnCardState *cs)
{
printk(KERN_INFO "HFCS: resetting card\n");
cs->hw.hfcD.cirm = HFCD_RESET;
......@@ -111,23 +111,12 @@ reset_hfcs(struct IsdnCardState *cs)
hfcs_write_reg(cs, HFCD_DATA, HFCD_MST_MODE, cs->hw.hfcD.mst_m); /* HFC Master */
cs->hw.hfcD.sctrl = 0;
hfcs_write_reg(cs, HFCD_DATA, HFCD_SCTRL, cs->hw.hfcD.sctrl);
return 0;
}
static int
hfcs_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
if (cs->debug & L1_DEB_ISAC)
debugl1(cs, "HFCS: card_msg %x", mt);
switch (mt) {
case CARD_RESET:
reset_hfcs(cs);
return(0);
case CARD_RELEASE:
release_io_hfcs(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
......@@ -146,6 +135,8 @@ hfcs_init(struct IsdnCardState *cs)
static struct card_ops hfcs_ops = {
.init = hfcs_init,
.reset = hfcs_reset,
.release = hfcs_release,
.irq_func = hfcs_interrupt,
};
......@@ -270,7 +261,7 @@ setup_hfcs(struct IsdnCard *card)
cs->hw.hfcD.timer.function = (void *) hfcs_Timer;
cs->hw.hfcD.timer.data = (long) cs;
init_timer(&cs->hw.hfcD.timer);
reset_hfcs(cs);
hfcs_reset(cs);
cs->cardmsg = &hfcs_card_msg;
cs->card_ops = &hfcs_ops;
return (1);
......
drivers/isdn/hisax/hisax.h
View file @ 6cc9cb58
......@@ -46,10 +46,6 @@
#define HW_INFO4_P10 0x0048
#define HW_RSYNC 0x0060
#define HW_TESTLOOP 0x0070
#define CARD_RESET 0x00F0
#define CARD_RELEASE 0x00F3
#define CARD_TEST 0x00F4
#define CARD_AUX_IND 0x00F5
#define PH_ACTIVATE 0x0100
#define PH_DEACTIVATE 0x0110
......@@ -858,6 +854,10 @@ struct IsdnCardState;
struct card_ops {
void (*init) (struct IsdnCardState *);
void (*test) (struct IsdnCardState *);
int (*reset) (struct IsdnCardState *);
void (*release) (struct IsdnCardState *);
void (*aux_ind) (struct IsdnCardState *, void *arg);
void (*irq_func) (int, void *, struct pt_regs *);
};
......
drivers/isdn/hisax/isar.c
View file @ 6cc9cb58
......@@ -174,7 +174,7 @@ ISARVersion(struct IsdnCardState *cs, char *s)
u8 len;
int debug;
cs->cardmsg(cs, CARD_RESET, NULL);
cs->card_ops->reset(cs);
/* disable ISAR IRQ */
isar_write_reg(cs, 0, ISAR_IRQBIT, 0);
debug = cs->debug;
......
drivers/isdn/hisax/isurf.c
View file @ 6cc9cb58
......@@ -132,8 +132,8 @@ isurf_interrupt(int intno, void *dev_id, struct pt_regs *regs)
spin_unlock(&cs->lock);
}
void
release_io_isurf(struct IsdnCardState *cs)
static void
isurf_release(struct IsdnCardState *cs)
{
release_region(cs->hw.isurf.reset, 1);
iounmap((unsigned char *)cs->hw.isurf.isar);
......@@ -156,16 +156,6 @@ reset_isurf(struct IsdnCardState *cs, u8 chips)
static int
ISurf_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_isurf(cs, ISURF_RESET);
return(0);
case CARD_RELEASE:
release_io_isurf(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
......@@ -188,13 +178,22 @@ isurf_auxcmd(struct IsdnCardState *cs, isdn_ctrl *ic) {
static void
isurf_init(struct IsdnCardState *cs)
{
writeb(0, cs->hw.isurf.isar+ISAR_IRQBIT);mb();
writeb(0, cs->hw.isurf.isar + ISAR_IRQBIT);
initisac(cs);
initisar(cs);
}
static int
isurf_reset(struct IsdnCardState *cs)
{
reset_isurf(cs, ISURF_RESET);
return 0;
}
static struct card_ops isurf_ops = {
.init = isurf_init,
.reset = isurf_reset,
.release = isurf_release,
.irq_func = isurf_interrupt,
};
......@@ -304,7 +303,7 @@ setup_isurf(struct IsdnCard *card)
if (ver < 0) {
printk(KERN_WARNING
"ISurf: wrong ISAR version (ret = %d)\n", ver);
release_io_isurf(cs);
isurf_release(cs);
return (0);
}
return (1);
......
drivers/isdn/hisax/ix1_micro.c
View file @ 6cc9cb58
......@@ -141,7 +141,7 @@ static struct bc_hw_ops hscx_ops = {
};
static void
ix1micro_interrupt(int intno, void *dev_id, struct pt_regs *regs)
ix1_interrupt(int intno, void *dev_id, struct pt_regs *regs)
{
struct IsdnCardState *cs = dev_id;
u8 val;
......@@ -176,14 +176,14 @@ ix1micro_interrupt(int intno, void *dev_id, struct pt_regs *regs)
spin_unlock(&cs->lock);
}
void
release_io_ix1micro(struct IsdnCardState *cs)
static void
ix1_release(struct IsdnCardState *cs)
{
if (cs->hw.ix1.cfg_reg)
release_region(cs->hw.ix1.cfg_reg, 4);
}
static void
static int
ix1_reset(struct IsdnCardState *cs)
{
int cnt;
......@@ -195,27 +195,20 @@ ix1_reset(struct IsdnCardState *cs)
HZDELAY(1); /* wait >=10 ms */
}
byteout(cs->hw.ix1.cfg_reg + SPECIAL_PORT_OFFSET, 0);
return 0;
}
static int
ix1_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
ix1_reset(cs);
return(0);
case CARD_RELEASE:
release_io_ix1micro(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
static struct card_ops ix1_ops = {
.init = inithscxisac,
.irq_func = ix1micro_interrupt,
.reset = ix1_reset,
.release = ix1_release,
.irq_func = ix1_interrupt,
};
#ifdef __ISAPNP__
......@@ -314,7 +307,7 @@ setup_ix1micro(struct IsdnCard *card)
if (HscxVersion(cs, "ix1-Micro:")) {
printk(KERN_WARNING
"ix1-Micro: wrong HSCX versions check IO address\n");
release_io_ix1micro(cs);
ix1_release(cs);
return (0);
}
return (1);
......
drivers/isdn/hisax/mic.c
View file @ 6cc9cb58
......@@ -168,32 +168,22 @@ mic_interrupt(int intno, void *dev_id, struct pt_regs *regs)
spin_unlock(&cs->lock);
}
void
release_io_mic(struct IsdnCardState *cs)
static void
mic_release(struct IsdnCardState *cs)
{
int bytecnt = 8;
if (cs->hw.mic.cfg_reg)
release_region(cs->hw.mic.cfg_reg, bytecnt);
release_region(cs->hw.mic.cfg_reg, 8);
}
static int
mic_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
return(0);
case CARD_RELEASE:
release_io_mic(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
static struct card_ops mic_ops = {
.init = inithscxisac,
.release = mic_release,
.irq_func = mic_interrupt,
};
......@@ -237,7 +227,7 @@ setup_mic(struct IsdnCard *card)
if (HscxVersion(cs, "mic:")) {
printk(KERN_WARNING
"mic: wrong HSCX versions check IO address\n");
release_io_mic(cs);
mic_release(cs);
return (0);
}
return (1);
......
drivers/isdn/hisax/netjet.c
View file @ 6cc9cb58
......@@ -998,7 +998,7 @@ inittiger(struct IsdnCardState *cs)
cs->hw.njet.last_is0 = 0;
}
void
static void
releasetiger(struct IsdnCardState *cs)
{
if (cs->bcs[0].hw.tiger.send) {
......@@ -1024,7 +1024,7 @@ releasetiger(struct IsdnCardState *cs)
}
void
release_io_netjet(struct IsdnCardState *cs)
netjet_release(struct IsdnCardState *cs)
{
byteout(cs->hw.njet.base + NETJET_IRQMASK0, 0);
byteout(cs->hw.njet.base + NETJET_IRQMASK1, 0);
......
drivers/isdn/hisax/netjet.h
View file @ 6cc9cb58
......@@ -70,5 +70,5 @@ void write_tiger(struct IsdnCardState *cs);
void netjet_fill_dma(struct BCState *bcs);
void netjet_interrupt(int intno, void *dev_id, struct pt_regs *regs);
void inittiger(struct IsdnCardState *cs);
void release_io_netjet(struct IsdnCardState *cs);
void netjet_release(struct IsdnCardState *cs);
drivers/isdn/hisax/niccy.c
View file @ 6cc9cb58
......@@ -195,7 +195,7 @@ niccy_interrupt(int intno, void *dev_id, struct pt_regs *regs)
}
void
release_io_niccy(struct IsdnCardState *cs)
niccy_release(struct IsdnCardState *cs)
{
if (cs->subtyp == NICCY_PCI) {
int val;
......@@ -211,7 +211,7 @@ release_io_niccy(struct IsdnCardState *cs)
}
}
static void
static int
niccy_reset(struct IsdnCardState *cs)
{
if (cs->subtyp == NICCY_PCI) {
......@@ -221,27 +221,19 @@ niccy_reset(struct IsdnCardState *cs)
val |= PCI_IRQ_ENABLE;
outl(val, cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
}
inithscxisac(cs);
return 0;
}
static int
niccy_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
niccy_reset(cs);
return(0);
case CARD_RELEASE:
release_io_niccy(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
static struct card_ops niccy_ops = {
.init = niccy_reset,
.init = inithscxisac,
.reset = niccy_reset,
.release = niccy_release,
.irq_func = niccy_interrupt,
};
......@@ -391,7 +383,7 @@ setup_niccy(struct IsdnCard *card)
if (HscxVersion(cs, "Niccy:")) {
printk(KERN_WARNING
"Niccy: wrong HSCX versions check IO address\n");
release_io_niccy(cs);
niccy_release(cs);
return (0);
}
return (1);
......
drivers/isdn/hisax/nj_s.c
View file @ 6cc9cb58
......@@ -72,8 +72,8 @@ nj_s_interrupt(int intno, void *dev_id, struct pt_regs *regs)
spin_unlock(&cs->lock);
}
static void
reset_netjet_s(struct IsdnCardState *cs)
static int
nj_s_reset(struct IsdnCardState *cs)
{
cs->hw.njet.ctrl_reg = 0xff; /* Reset On */
byteout(cs->hw.njet.base + NETJET_CTRL, cs->hw.njet.ctrl_reg);
......@@ -89,21 +89,12 @@ reset_netjet_s(struct IsdnCardState *cs)
byteout(cs->hw.njet.base + NETJET_AUXCTRL, ~NETJET_ISACIRQ);
byteout(cs->hw.njet.base + NETJET_IRQMASK1, NETJET_ISACIRQ);
byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
return 0;
}
static int
NETjet_S_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_netjet_s(cs);
return(0);
case CARD_RELEASE:
release_io_netjet(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
......@@ -116,6 +107,8 @@ nj_s_init(struct IsdnCardState *cs)
static struct card_ops nj_s_ops = {
.init = nj_s_init,
.reset = nj_s_reset,
.release = netjet_release,
.irq_func = nj_s_interrupt,
};
......@@ -233,7 +226,7 @@ setup_netjet_s(struct IsdnCard *card)
} else {
request_region(cs->hw.njet.base, bytecnt, "netjet-s isdn");
}
reset_netjet_s(cs);
nj_s_reset(cs);
cs->dc_hw_ops = &netjet_dc_ops;
cs->cardmsg = &NETjet_S_card_msg;
cs->irq_flags |= SA_SHIRQ;
......
drivers/isdn/hisax/nj_u.c
View file @ 6cc9cb58
......@@ -72,8 +72,8 @@ nj_u_interrupt(int intno, void *dev_id, struct pt_regs *regs)
spin_unlock(&cs->lock);
}
static void
reset_netjet_u(struct IsdnCardState *cs)
static int
nj_u_reset(struct IsdnCardState *cs)
{
cs->hw.njet.ctrl_reg = 0xff; /* Reset On */
byteout(cs->hw.njet.base + NETJET_CTRL, cs->hw.njet.ctrl_reg);
......@@ -91,21 +91,12 @@ reset_netjet_u(struct IsdnCardState *cs)
byteout(cs->hw.njet.base + NETJET_AUXCTRL, ~NETJET_ISACIRQ);
byteout(cs->hw.njet.base + NETJET_IRQMASK1, NETJET_ISACIRQ);
byteout(cs->hw.njet.auxa, cs->hw.njet.auxd);
return 0;
}
static int
NETjet_U_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_netjet_u(cs);
return(0);
case CARD_RELEASE:
release_io_netjet(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
......@@ -120,6 +111,8 @@ nj_u_init(struct IsdnCardState *cs)
static struct card_ops nj_u_ops = {
.init = nj_u_init,
.reset = nj_u_reset,
.release = netjet_release,
.irq_func = nj_u_interrupt,
};
......@@ -229,7 +222,7 @@ setup_netjet_u(struct IsdnCard *card)
cs->hw.njet.base + bytecnt);
return (0);
}
reset_netjet_u(cs);
nj_u_reset(cs);
cs->dc_hw_ops = &netjet_dc_ops;
cs->cardmsg = &NETjet_U_card_msg;
cs->irq_flags |= SA_SHIRQ;
......
drivers/isdn/hisax/s0box.c
View file @ 6cc9cb58
......@@ -208,7 +208,7 @@ s0box_interrupt(int intno, void *dev_id, struct pt_regs *regs)
}
void
release_io_s0box(struct IsdnCardState *cs)
s0box_release(struct IsdnCardState *cs)
{
release_region(cs->hw.teles3.cfg_reg, 8);
}
......@@ -216,20 +216,12 @@ release_io_s0box(struct IsdnCardState *cs)
static int
S0Box_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
break;
case CARD_RELEASE:
release_io_s0box(cs);
break;
case CARD_TEST:
break;
}
return(0);
}
static struct card_ops s0box_ops = {
.init = inithscxisac,
.release = s0box_release,
.irq_func = s0box_interrupt,
};
......@@ -275,7 +267,7 @@ setup_s0box(struct IsdnCard *card)
if (HscxVersion(cs, "S0Box:")) {
printk(KERN_WARNING
"S0Box: wrong HSCX versions check IO address\n");
release_io_s0box(cs);
s0box_release(cs);
return (0);
}
return (1);
......
drivers/isdn/hisax/saphir.c
View file @ 6cc9cb58
......@@ -182,8 +182,8 @@ SaphirWatchDog(struct IsdnCardState *cs)
mod_timer(&cs->hw.saphir.timer, jiffies+1*HZ);
}
void
release_io_saphir(struct IsdnCardState *cs)
static void
saphir_release(struct IsdnCardState *cs)
{
byteout(cs->hw.saphir.cfg_reg + IRQ_REG, 0xff);
del_timer_sync(&cs->hw.saphir.timer);
......@@ -231,21 +231,13 @@ saphir_reset(struct IsdnCardState *cs)
static int
saphir_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
saphir_reset(cs);
return(0);
case CARD_RELEASE:
release_io_saphir(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
static struct card_ops saphir_ops = {
.init = inithscxisac,
.reset = saphir_reset,
.release = saphir_release,
.irq_func = saphir_interrupt,
};
......@@ -286,7 +278,7 @@ setup_saphir(struct IsdnCard *card)
cs->hw.saphir.timer.expires = jiffies + 4*HZ;
add_timer(&cs->hw.saphir.timer);
if (saphir_reset(cs)) {
release_io_saphir(cs);
saphir_release(cs);
return (0);
}
cs->dc_hw_ops = &isac_ops;
......@@ -297,7 +289,7 @@ setup_saphir(struct IsdnCard *card)
if (HscxVersion(cs, "saphir:")) {
printk(KERN_WARNING
"saphir: wrong HSCX versions check IO address\n");
release_io_saphir(cs);
saphir_release(cs);
return (0);
}
return (1);
......
drivers/isdn/hisax/sedlbauer.c
View file @ 6cc9cb58
......@@ -417,8 +417,61 @@ sedlbauer_isar_interrupt(int intno, void *dev_id, struct pt_regs *regs)
spin_unlock(&cs->lock);
}
void
release_io_sedlbauer(struct IsdnCardState *cs)
static int
sedlbauer_ipac_reset(struct IsdnCardState *cs)
{
writereg(cs, cs->hw.sedl.isac, IPAC_POTA2, 0x20);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writereg(cs, cs->hw.sedl.isac, IPAC_POTA2, 0x0);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writereg(cs, cs->hw.sedl.isac, IPAC_CONF, 0x0);
writereg(cs, cs->hw.sedl.isac, IPAC_ACFG, 0xff);
writereg(cs, cs->hw.sedl.isac, IPAC_AOE, 0x0);
writereg(cs, cs->hw.sedl.isac, IPAC_MASK, 0xc0);
writereg(cs, cs->hw.sedl.isac, IPAC_PCFG, 0x12);
return 0;
}
static int
sedlbauer_isar_pci_reset(struct IsdnCardState *cs)
{
byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_on);
current->state = TASK_UNINTERRUPTIBLE;
schedule_timeout((20*HZ)/1000);
byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_off);
current->state = TASK_UNINTERRUPTIBLE;
schedule_timeout((20*HZ)/1000);
return 0;
}
static int
sedlbauer_reset(struct IsdnCardState *cs)
{
printk(KERN_INFO "Sedlbauer: resetting card\n");
if (cs->hw.sedl.bus == SEDL_BUS_PCMCIA &&
cs->hw.sedl.chip == SEDL_CHIP_ISAC_HSCX)
return 0;
if (cs->hw.sedl.chip == SEDL_CHIP_IPAC) {
return sedlbauer_ipac_reset(cs);
} else if ((cs->hw.sedl.chip == SEDL_CHIP_ISAC_ISAR) &&
(cs->hw.sedl.bus == SEDL_BUS_PCI)) {
return sedlbauer_isar_pci_reset(cs);
} else {
byteout(cs->hw.sedl.reset_on, SEDL_RESET); /* Reset On */
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
byteout(cs->hw.sedl.reset_off, 0); /* Reset Off */
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
}
return 0;
}
static void
sedlbauer_release(struct IsdnCardState *cs)
{
int bytecnt = 8;
......@@ -432,62 +485,20 @@ release_io_sedlbauer(struct IsdnCardState *cs)
}
static void
reset_sedlbauer(struct IsdnCardState *cs)
sedlbauer_isar_release(struct IsdnCardState *cs)
{
printk(KERN_INFO "Sedlbauer: resetting card\n");
if (!((cs->hw.sedl.bus == SEDL_BUS_PCMCIA) &&
(cs->hw.sedl.chip == SEDL_CHIP_ISAC_HSCX))) {
if (cs->hw.sedl.chip == SEDL_CHIP_IPAC) {
writereg(cs, cs->hw.sedl.isac, IPAC_POTA2, 0x20);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writereg(cs, cs->hw.sedl.isac, IPAC_POTA2, 0x0);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
writereg(cs, cs->hw.sedl.isac, IPAC_CONF, 0x0);
writereg(cs, cs->hw.sedl.isac, IPAC_ACFG, 0xff);
writereg(cs, cs->hw.sedl.isac, IPAC_AOE, 0x0);
writereg(cs, cs->hw.sedl.isac, IPAC_MASK, 0xc0);
writereg(cs, cs->hw.sedl.isac, IPAC_PCFG, 0x12);
} else if ((cs->hw.sedl.chip == SEDL_CHIP_ISAC_ISAR) &&
(cs->hw.sedl.bus == SEDL_BUS_PCI)) {
byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_on);
current->state = TASK_UNINTERRUPTIBLE;
schedule_timeout((20*HZ)/1000);
byteout(cs->hw.sedl.cfg_reg +3, cs->hw.sedl.reset_off);
current->state = TASK_UNINTERRUPTIBLE;
schedule_timeout((20*HZ)/1000);
} else {
byteout(cs->hw.sedl.reset_on, SEDL_RESET); /* Reset On */
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
byteout(cs->hw.sedl.reset_off, 0); /* Reset Off */
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
}
}
isar_write(cs, 0, ISAR_IRQBIT, 0);
isac_write(cs, ISAC_MASK, 0xFF);
sedlbauer_reset(cs);
isar_write(cs, 0, ISAR_IRQBIT, 0);
isac_write(cs, ISAC_MASK, 0xFF);
sedlbauer_release(cs);
}
static int
Sedl_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_sedlbauer(cs);
return(0);
case CARD_RELEASE:
if (cs->hw.sedl.chip == SEDL_CHIP_ISAC_ISAR) {
isar_write(cs, 0, ISAR_IRQBIT, 0);
isac_write(cs, ISAC_MASK, 0xFF);
reset_sedlbauer(cs);
isar_write(cs, 0, ISAR_IRQBIT, 0);
isac_write(cs, ISAC_MASK, 0xFF);
}
release_io_sedlbauer(cs);
return(0);
case CARD_TEST:
return(0);
case MDL_INFO_CONN:
if (cs->subtyp != SEDL_SPEEDFAX_PYRAMID)
return(0);
......@@ -520,16 +531,22 @@ sedlbauer_isar_init(struct IsdnCardState *cs)
static struct card_ops sedlbauer_ops = {
.init = inithscxisac,
.reset = sedlbauer_reset,
.release = sedlbauer_release,
.irq_func = sedlbauer_interrupt,
};
static struct card_ops sedlbauer_ipac_ops = {
.init = inithscxisac,
.reset = sedlbauer_reset,
.release = sedlbauer_release,
.irq_func = sedlbauer_ipac_interrupt,
};
static struct card_ops sedlbauer_isar_ops = {
.init = sedlbauer_isar_init,
.reset = sedlbauer_reset,
.release = sedlbauer_isar_release,
.irq_func = sedlbauer_isar_interrupt,
};
......@@ -769,7 +786,7 @@ setup_sedlbauer(struct IsdnCard *card)
val = readreg(cs, cs->hw.sedl.isac, IPAC_ID);
printk(KERN_INFO "Sedlbauer: IPAC version %x\n", val);
reset_sedlbauer(cs);
sedlbauer_reset(cs);
} else {
/* ISAC_HSCX oder ISAC_ISAR */
cs->dc_hw_ops = &isac_ops;
......@@ -804,7 +821,7 @@ setup_sedlbauer(struct IsdnCard *card)
if (ver < 0) {
printk(KERN_WARNING
"Sedlbauer: wrong ISAR version (ret = %d)\n", ver);
release_io_sedlbauer(cs);
sedlbauer_release(cs);
return (0);
}
} else {
......@@ -827,10 +844,10 @@ setup_sedlbauer(struct IsdnCard *card)
if (HscxVersion(cs, "Sedlbauer:")) {
printk(KERN_WARNING
"Sedlbauer: wrong HSCX versions check IO address\n");
release_io_sedlbauer(cs);
sedlbauer_release(cs);
return (0);
}
reset_sedlbauer(cs);
sedlbauer_reset(cs);
}
}
return (1);
......
drivers/isdn/hisax/sportster.c
View file @ 6cc9cb58
......@@ -143,8 +143,8 @@ sportster_interrupt(int intno, void *dev_id, struct pt_regs *regs)
spin_unlock(&cs->lock);
}
void
release_io_sportster(struct IsdnCardState *cs)
static void
sportster_release(struct IsdnCardState *cs)
{
int i, adr;
......@@ -155,8 +155,8 @@ release_io_sportster(struct IsdnCardState *cs)
}
}
void
reset_sportster(struct IsdnCardState *cs)
static int
sportster_reset(struct IsdnCardState *cs)
{
cs->hw.spt.res_irq |= SPORTSTER_RESET; /* Reset On */
byteout(cs->hw.spt.cfg_reg + SPORTSTER_RES_IRQ, cs->hw.spt.res_irq);
......@@ -166,21 +166,12 @@ reset_sportster(struct IsdnCardState *cs)
byteout(cs->hw.spt.cfg_reg + SPORTSTER_RES_IRQ, cs->hw.spt.res_irq);
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
return 0;
}
static int
Sportster_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_sportster(cs);
return(0);
case CARD_RELEASE:
release_io_sportster(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
......@@ -194,6 +185,8 @@ sportster_init(struct IsdnCardState *cs)
static struct card_ops sportster_ops = {
.init = sportster_init,
.reset = sportster_reset,
.release = sportster_release,
.irq_func = sportster_interrupt,
};
......@@ -256,11 +249,11 @@ setup_sportster(struct IsdnCard *card)
break;
case 15:cs->hw.spt.res_irq = 7;
break;
default:release_io_sportster(cs);
default:sportster_release(cs);
printk(KERN_WARNING "Sportster: wrong IRQ\n");
return(0);
}
reset_sportster(cs);
sportster_reset(cs);
printk(KERN_INFO
"HiSax: %s config irq:%d cfg:0x%X\n",
CardType[cs->typ], cs->irq,
......@@ -274,7 +267,7 @@ setup_sportster(struct IsdnCard *card)
if (HscxVersion(cs, "Sportster:")) {
printk(KERN_WARNING
"Sportster: wrong HSCX versions check IO address\n");
release_io_sportster(cs);
sportster_release(cs);
return (0);
}
return (1);
......
drivers/isdn/hisax/teleint.c
View file @ 6cc9cb58
......@@ -217,8 +217,8 @@ TeleInt_Timer(struct IsdnCardState *cs)
add_timer(&cs->hw.hfc.timer);
}
void
release_io_TeleInt(struct IsdnCardState *cs)
static void
teleint_release(struct IsdnCardState *cs)
{
del_timer(&cs->hw.hfc.timer);
releasehfc(cs);
......@@ -226,8 +226,8 @@ release_io_TeleInt(struct IsdnCardState *cs)
release_region(cs->hw.hfc.addr, 2);
}
static void
reset_TeleInt(struct IsdnCardState *cs)
static int
teleint_reset(struct IsdnCardState *cs)
{
printk(KERN_INFO "TeleInt: resetting card\n");
cs->hw.hfc.cirm |= HFC_RESET;
......@@ -238,21 +238,12 @@ reset_TeleInt(struct IsdnCardState *cs)
byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm); /* Reset Off */
set_current_state(TASK_UNINTERRUPTIBLE);
schedule_timeout((10*HZ)/1000);
return 0;
}
static int
TeleInt_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_TeleInt(cs);
return(0);
case CARD_RELEASE:
release_io_TeleInt(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
......@@ -267,6 +258,8 @@ teleint_init(struct IsdnCardState *cs)
static struct card_ops teleint_ops = {
.init = teleint_init,
.reset = teleint_reset,
.release = teleint_release,
.irq_func = teleint_interrupt,
};
......@@ -327,7 +320,7 @@ setup_TeleInt(struct IsdnCard *card)
break;
default:
printk(KERN_WARNING "TeleInt: wrong IRQ\n");
release_io_TeleInt(cs);
teleint_release(cs);
return (0);
}
byteout(cs->hw.hfc.addr | 1, cs->hw.hfc.cirm);
......@@ -338,7 +331,7 @@ setup_TeleInt(struct IsdnCard *card)
cs->hw.hfc.addr,
cs->irq);
reset_TeleInt(cs);
teleint_reset(cs);
cs->dc_hw_ops = &isac_ops;
cs->bc_hw_ops = &hfc_ops;
cs->cardmsg = &TeleInt_card_msg;
......
drivers/isdn/hisax/teles0.c
View file @ 6cc9cb58
......@@ -148,8 +148,8 @@ teles0_interrupt(int intno, void *dev_id, struct pt_regs *regs)
spin_unlock(&cs->lock);
}
void
release_io_teles0(struct IsdnCardState *cs)
static void
teles0_release(struct IsdnCardState *cs)
{
if (cs->hw.teles0.cfg_reg)
release_region(cs->hw.teles0.cfg_reg, 8);
......@@ -158,7 +158,7 @@ release_io_teles0(struct IsdnCardState *cs)
}
static int
reset_teles0(struct IsdnCardState *cs)
teles0_reset(struct IsdnCardState *cs)
{
u8 cfval;
......@@ -208,21 +208,13 @@ reset_teles0(struct IsdnCardState *cs)
static int
Teles_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_teles0(cs);
return(0);
case CARD_RELEASE:
release_io_teles0(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
static struct card_ops teles0_ops = {
.init = inithscxisac,
.reset = teles0_reset,
.release = teles0_release,
.irq_func = teles0_interrupt,
};
......@@ -306,9 +298,9 @@ setup_teles0(struct IsdnCard *card)
"HiSax: %s config irq:%d mem:0x%lX cfg:0x%X\n",
CardType[cs->typ], cs->irq,
cs->hw.teles0.membase, cs->hw.teles0.cfg_reg);
if (reset_teles0(cs)) {
if (teles0_reset(cs)) {
printk(KERN_WARNING "Teles0: wrong IRQ\n");
release_io_teles0(cs);
teles0_release(cs);
return (0);
}
cs->dc_hw_ops = &isac_ops;
......@@ -319,7 +311,7 @@ setup_teles0(struct IsdnCard *card)
if (HscxVersion(cs, "Teles0:")) {
printk(KERN_WARNING
"Teles0: wrong HSCX versions check IO/MEM addresses\n");
release_io_teles0(cs);
teles0_release(cs);
return (0);
}
return (1);
......
drivers/isdn/hisax/teles3.c
View file @ 6cc9cb58
......@@ -165,8 +165,8 @@ release_ioregs(struct IsdnCardState *cs, int mask)
release_region(cs->hw.teles3.hscx[1] + 32, 32);
}
void
release_io_teles3(struct IsdnCardState *cs)
static void
teles3_release(struct IsdnCardState *cs)
{
if (cs->typ == ISDN_CTYPE_TELESPCMCIA) {
release_region(cs->hw.teles3.hscx[1], 96);
......@@ -183,7 +183,7 @@ release_io_teles3(struct IsdnCardState *cs)
}
static int
reset_teles3(struct IsdnCardState *cs)
teles3_reset(struct IsdnCardState *cs)
{
u8 irqcfg;
......@@ -241,21 +241,13 @@ reset_teles3(struct IsdnCardState *cs)
static int
Teles_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
reset_teles3(cs);
return(0);
case CARD_RELEASE:
release_io_teles3(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
static struct card_ops teles3_ops = {
.init = inithscxisac,
.reset = teles3_reset,
.release = teles3_release,
.irq_func = teles3_interrupt,
};
......@@ -445,13 +437,13 @@ setup_teles3(struct IsdnCard *card)
if ((val = bytein(cs->hw.teles3.cfg_reg + 0)) != 0x51) {
printk(KERN_WARNING "Teles: 16.3 Byte at %x is %x\n",
cs->hw.teles3.cfg_reg + 0, val);
release_io_teles3(cs);
teles3_release(cs);
return (0);
}
if ((val = bytein(cs->hw.teles3.cfg_reg + 1)) != 0x93) {
printk(KERN_WARNING "Teles: 16.3 Byte at %x is %x\n",
cs->hw.teles3.cfg_reg + 1, val);
release_io_teles3(cs);
teles3_release(cs);
return (0);
}
val = bytein(cs->hw.teles3.cfg_reg + 2);/* 0x1e=without AB
......@@ -464,7 +456,7 @@ setup_teles3(struct IsdnCard *card)
if (val != 0x46 && val != 0x39 && val != 0x38 && val != 0x1c && val != 0x1e && val != 0x1f) {
printk(KERN_WARNING "Teles: 16.3 Byte at %x is %x\n",
cs->hw.teles3.cfg_reg + 2, val);
release_io_teles3(cs);
teles3_release(cs);
return (0);
}
}
......@@ -476,9 +468,9 @@ setup_teles3(struct IsdnCard *card)
"HiSax: hscx A:0x%X hscx B:0x%X\n",
cs->hw.teles3.hscx[0] + 32, cs->hw.teles3.hscx[1] + 32);
if (reset_teles3(cs)) {
if (teles3_reset(cs)) {
printk(KERN_WARNING "Teles3: wrong IRQ\n");
release_io_teles3(cs);
teles3_release(cs);
return (0);
}
cs->dc_hw_ops = &isac_ops;
......@@ -489,7 +481,7 @@ setup_teles3(struct IsdnCard *card)
if (HscxVersion(cs, "Teles3:")) {
printk(KERN_WARNING
"Teles3: wrong HSCX versions check IO address\n");
release_io_teles3(cs);
teles3_release(cs);
return (0);
}
return (1);
......
drivers/isdn/hisax/telespci.c
View file @ 6cc9cb58
......@@ -226,7 +226,7 @@ telespci_interrupt(int intno, void *dev_id, struct pt_regs *regs)
}
void
release_io_telespci(struct IsdnCardState *cs)
telespci_release(struct IsdnCardState *cs)
{
iounmap((void *)cs->hw.teles0.membase);
}
......@@ -234,20 +234,12 @@ release_io_telespci(struct IsdnCardState *cs)
static int
TelesPCI_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
return(0);
case CARD_RELEASE:
release_io_telespci(cs);
return(0);
case CARD_TEST:
return(0);
}
return(0);
}
static struct card_ops telespci_ops = {
.init = inithscxisac,
.release = telespci_release,
.irq_func = telespci_interrupt,
};
......@@ -316,7 +308,7 @@ setup_telespci(struct IsdnCard *card)
if (HscxVersion(cs, "TelesPCI:")) {
printk(KERN_WARNING
"TelesPCI: wrong HSCX versions check IO/MEM addresses\n");
release_io_telespci(cs);
telespci_release(cs);
return (0);
}
return (1);
......
drivers/isdn/hisax/w6692.c
View file @ 6cc9cb58
......@@ -593,7 +593,8 @@ setstack_w6692(struct PStack *st, struct BCState *bcs)
return (0);
}
void resetW6692(struct IsdnCardState *cs)
static int
w6692_reset(struct IsdnCardState *cs)
{
w6692_write_reg(cs, W_D_CTL, W_D_CTL_SRST);
schedule_timeout((10*HZ)/1000);
......@@ -613,9 +614,10 @@ void resetW6692(struct IsdnCardState *cs)
w6692_write_reg(cs, W_PCTL, 0x80);
w6692_write_reg(cs, W_XDATA, 0x00);
}
return 0;
}
void __init
static void
w6692_init(struct IsdnCardState *cs)
{
INIT_WORK(&cs->work, W6692_bh, cs);
......@@ -624,7 +626,7 @@ w6692_init(struct IsdnCardState *cs)
cs->dbusytimer.function = (void *) dbusy_timer_handler;
cs->dbusytimer.data = (long) cs;
init_timer(&cs->dbusytimer);
resetW6692(cs);
w6692_reset(cs);
ph_command(cs, W_L1CMD_RST);
cs->dc.w6692.ph_state = W_L1CMD_RST;
W6692_new_ph(cs);
......@@ -642,28 +644,26 @@ w6692_init(struct IsdnCardState *cs)
w6692_write_reg(cs, W_D_CMDR, W_D_CMDR_RRST | W_D_CMDR_XRST);
}
static void
w6692_release(struct IsdnCardState *cs)
{
w6692_write_reg(cs, W_IMASK, 0xff);
release_region(cs->hw.w6692.iobase, 256);
if (cs->subtyp == W6692_USR)
w6692_write_reg(cs, W_XDATA, 0x04);
}
static int
w6692_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
switch (mt) {
case CARD_RESET:
resetW6692(cs);
return (0);
case CARD_RELEASE:
w6692_write_reg(cs, W_IMASK, 0xff);
release_region(cs->hw.w6692.iobase, 256);
if (cs->subtyp == W6692_USR) {
w6692_write_reg(cs, W_XDATA, 0x04);
}
return (0);
case CARD_TEST:
return (0);
}
return (0);
}
static struct card_ops w6692_ops = {
.init = w6692_init,
.reset = w6692_reset,
.release = w6692_release,
.irq_func = w6692_interrupt,
};
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7