[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / drivers / isdn / hisax / isurf.c

/* $Id: isurf.c,v 1.12.2.4 2004/01/13 21:46:03 keil Exp $
 *
 * low level stuff for Siemens I-Surf/I-Talk cards
 *
 * Author       Karsten Keil
 * Copyright    by Karsten Keil      <keil@isdn4linux.de>
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 */

#include <linux/init.h>
#include "hisax.h"
#include "isac.h"
#include "isar.h"
#include "isdnl1.h"
#include <linux/isapnp.h>

static const char *ISurf_revision = "$Revision: 1.12.2.4 $";

#define byteout(addr, val) outb(val, addr)
#define bytein(addr) inb(addr)

#define ISURF_ISAR_RESET	1
#define ISURF_ISAC_RESET	2
#define ISURF_ISAR_EA		4
#define ISURF_ARCOFI_RESET	8
#define ISURF_RESET (ISURF_ISAR_RESET | ISURF_ISAC_RESET | ISURF_ARCOFI_RESET)

#define ISURF_ISAR_OFFSET	0
#define ISURF_ISAC_OFFSET	0x100
#define ISURF_IOMEM_SIZE	0x400
/* Interface functions */

static u_char
ReadISAC(struct IsdnCardState *cs, u_char offset)
{
	return (readb(cs->hw.isurf.isac + offset));
}

static void
WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
{
	writeb(value, cs->hw.isurf.isac + offset); mb();
}

static void
ReadISACfifo(struct IsdnCardState *cs, u_char *data, int size)
{
	register int i;
	for (i = 0; i < size; i++)
		data[i] = readb(cs->hw.isurf.isac);
}

static void
WriteISACfifo(struct IsdnCardState *cs, u_char *data, int size)
{
	register int i;
	for (i = 0; i < size; i++) {
		writeb(data[i], cs->hw.isurf.isac); mb();
	}
}

/* ISAR access routines
 * mode = 0 access with IRQ on
 * mode = 1 access with IRQ off
 * mode = 2 access with IRQ off and using last offset
 */

static u_char
ReadISAR(struct IsdnCardState *cs, int mode, u_char offset)
{
	return (readb(cs->hw.isurf.isar + offset));
}

static void
WriteISAR(struct IsdnCardState *cs, int mode, u_char offset, u_char value)
{
	writeb(value, cs->hw.isurf.isar + offset); mb();
}

static irqreturn_t
isurf_interrupt(int intno, void *dev_id)
{
	struct IsdnCardState *cs = dev_id;
	u_char val;
	int cnt = 5;
	u_long flags;

	spin_lock_irqsave(&cs->lock, flags);
	val = readb(cs->hw.isurf.isar + ISAR_IRQBIT);
Start_ISAR:
	if (val & ISAR_IRQSTA)
		isar_int_main(cs);
	val = readb(cs->hw.isurf.isac + ISAC_ISTA);
Start_ISAC:
	if (val)
		isac_interrupt(cs, val);
	val = readb(cs->hw.isurf.isar + ISAR_IRQBIT);
	if ((val & ISAR_IRQSTA) && --cnt) {
		if (cs->debug & L1_DEB_HSCX)
			debugl1(cs, "ISAR IntStat after IntRoutine");
		goto Start_ISAR;
	}
	val = readb(cs->hw.isurf.isac + ISAC_ISTA);
	if (val && --cnt) {
		if (cs->debug & L1_DEB_ISAC)
			debugl1(cs, "ISAC IntStat after IntRoutine");
		goto Start_ISAC;
	}
	if (!cnt)
		printk(KERN_WARNING "ISurf IRQ LOOP\n");

	writeb(0, cs->hw.isurf.isar + ISAR_IRQBIT); mb();
	writeb(0xFF, cs->hw.isurf.isac + ISAC_MASK); mb();
	writeb(0, cs->hw.isurf.isac + ISAC_MASK); mb();
	writeb(ISAR_IRQMSK, cs->hw.isurf.isar + ISAR_IRQBIT); mb();
	spin_unlock_irqrestore(&cs->lock, flags);
	return IRQ_HANDLED;
}

static void
release_io_isurf(struct IsdnCardState *cs)
{
	release_region(cs->hw.isurf.reset, 1);
	iounmap(cs->hw.isurf.isar);
	release_mem_region(cs->hw.isurf.phymem, ISURF_IOMEM_SIZE);
}

static void
reset_isurf(struct IsdnCardState *cs, u_char chips)
{
	printk(KERN_INFO "ISurf: resetting card\n");

	byteout(cs->hw.isurf.reset, chips); /* Reset On */
	mdelay(10);
	byteout(cs->hw.isurf.reset, ISURF_ISAR_EA); /* Reset Off */
	mdelay(10);
}

static int
ISurf_card_msg(struct IsdnCardState *cs, int mt, void *arg)
{
	u_long flags;

	switch (mt) {
	case CARD_RESET:
		spin_lock_irqsave(&cs->lock, flags);
		reset_isurf(cs, ISURF_RESET);
		spin_unlock_irqrestore(&cs->lock, flags);
		return (0);
	case CARD_RELEASE:
		release_io_isurf(cs);
		return (0);
	case CARD_INIT:
		spin_lock_irqsave(&cs->lock, flags);
		reset_isurf(cs, ISURF_RESET);
		clear_pending_isac_ints(cs);
		writeb(0, cs->hw.isurf.isar + ISAR_IRQBIT); mb();
		initisac(cs);
		initisar(cs);
		/* Reenable ISAC IRQ */
		cs->writeisac(cs, ISAC_MASK, 0);
		/* RESET Receiver and Transmitter */
		cs->writeisac(cs, ISAC_CMDR, 0x41);
		spin_unlock_irqrestore(&cs->lock, flags);
		return (0);
	case CARD_TEST:
		return (0);
	}
	return (0);
}

static int
isurf_auxcmd(struct IsdnCardState *cs, isdn_ctrl *ic) {
	int ret;
	u_long flags;

	if ((ic->command == ISDN_CMD_IOCTL) && (ic->arg == 9)) {
		ret = isar_auxcmd(cs, ic);
		spin_lock_irqsave(&cs->lock, flags);
		if (!ret) {
			reset_isurf(cs, ISURF_ISAR_EA | ISURF_ISAC_RESET |
				    ISURF_ARCOFI_RESET);
			initisac(cs);
			cs->writeisac(cs, ISAC_MASK, 0);
			cs->writeisac(cs, ISAC_CMDR, 0x41);
		}
		spin_unlock_irqrestore(&cs->lock, flags);
		return (ret);
	}
	return (isar_auxcmd(cs, ic));
}

#ifdef __ISAPNP__
static struct pnp_card *pnp_c = NULL;
#endif

int setup_isurf(struct IsdnCard *card)
{
	int ver;
	struct IsdnCardState *cs = card->cs;
	char tmp[64];

	strcpy(tmp, ISurf_revision);
	printk(KERN_INFO "HiSax: ISurf driver Rev. %s\n", HiSax_getrev(tmp));

	if (cs->typ != ISDN_CTYPE_ISURF)
		return (0);
	if (card->para[1] && card->para[2]) {
		cs->hw.isurf.reset = card->para[1];
		cs->hw.isurf.phymem = card->para[2];
		cs->irq = card->para[0];
	} else {
#ifdef __ISAPNP__
		if (isapnp_present()) {
			struct pnp_dev *pnp_d = NULL;
			int err;

			cs->subtyp = 0;
			if ((pnp_c = pnp_find_card(
				     ISAPNP_VENDOR('S', 'I', 'E'),
				     ISAPNP_FUNCTION(0x0010), pnp_c))) {
				if (!(pnp_d = pnp_find_dev(pnp_c,
							   ISAPNP_VENDOR('S', 'I', 'E'),
							   ISAPNP_FUNCTION(0x0010), pnp_d))) {
					printk(KERN_ERR "ISurfPnP: PnP error card found, no device\n");
					return (0);
				}
				pnp_disable_dev(pnp_d);
				err = pnp_activate_dev(pnp_d);
				if (err < 0) {
					pr_warn("%s: pnp_activate_dev ret=%d\n",
						__func__, err);
					return 0;
				}
				cs->hw.isurf.reset = pnp_port_start(pnp_d, 0);
				cs->hw.isurf.phymem = pnp_mem_start(pnp_d, 1);
				cs->irq = pnp_irq(pnp_d, 0);
				if (!cs->irq || !cs->hw.isurf.reset || !cs->hw.isurf.phymem) {
					printk(KERN_ERR "ISurfPnP:some resources are missing %d/%x/%lx\n",
					       cs->irq, cs->hw.isurf.reset, cs->hw.isurf.phymem);
					pnp_disable_dev(pnp_d);
					return (0);
				}
			} else {
				printk(KERN_INFO "ISurfPnP: no ISAPnP card found\n");
				return (0);
			}
		} else {
			printk(KERN_INFO "ISurfPnP: no ISAPnP bus found\n");
			return (0);
		}
#else
		printk(KERN_WARNING "HiSax: Siemens I-Surf port/mem not set\n");
		return (0);
#endif
	}
	if (!request_region(cs->hw.isurf.reset, 1, "isurf isdn")) {
		printk(KERN_WARNING
		       "HiSax: Siemens I-Surf config port %x already in use\n",
		       cs->hw.isurf.reset);
		return (0);
	}
	if (!request_region(cs->hw.isurf.phymem, ISURF_IOMEM_SIZE, "isurf iomem")) {
		printk(KERN_WARNING "HiSax: Siemens I-Surf memory region "
		       "%lx-%lx already in use\n",
		       cs->hw.isurf.phymem,
		       cs->hw.isurf.phymem + ISURF_IOMEM_SIZE);
		release_region(cs->hw.isurf.reset, 1);
		return (0);
	}
	cs->hw.isurf.isar = ioremap(cs->hw.isurf.phymem, ISURF_IOMEM_SIZE);
	cs->hw.isurf.isac = cs->hw.isurf.isar + ISURF_ISAC_OFFSET;
	printk(KERN_INFO
	       "ISurf: defined at 0x%x 0x%lx IRQ %d\n",
	       cs->hw.isurf.reset,
	       cs->hw.isurf.phymem,
	       cs->irq);

	setup_isac(cs);
	cs->cardmsg = &ISurf_card_msg;
	cs->irq_func = &isurf_interrupt;
	cs->auxcmd = &isurf_auxcmd;
	cs->readisac = &ReadISAC;
	cs->writeisac = &WriteISAC;
	cs->readisacfifo = &ReadISACfifo;
	cs->writeisacfifo = &WriteISACfifo;
	cs->bcs[0].hw.isar.reg = &cs->hw.isurf.isar_r;
	cs->bcs[1].hw.isar.reg = &cs->hw.isurf.isar_r;
	test_and_set_bit(HW_ISAR, &cs->HW_Flags);
	ISACVersion(cs, "ISurf:");
	cs->BC_Read_Reg = &ReadISAR;
	cs->BC_Write_Reg = &WriteISAR;
	cs->BC_Send_Data = &isar_fill_fifo;
	ver = ISARVersion(cs, "ISurf:");
	if (ver < 0) {
		printk(KERN_WARNING
		       "ISurf: wrong ISAR version (ret = %d)\n", ver);
		release_io_isurf(cs);
		return (0);
	}
	return (1);
}
Commit	Line	Data
1da177e4 LT	1	/* $Id: isurf.c,v 1.12.2.4 2004/01/13 21:46:03 keil Exp $
	2	*
	3	* low level stuff for Siemens I-Surf/I-Talk cards
	4	*
	5	* Author Karsten Keil
	6	* Copyright by Karsten Keil <keil@isdn4linux.de>
475be4d8	7	*
1da177e4 LT	8	* This software may be used and distributed according to the terms
	9	* of the GNU General Public License, incorporated herein by reference.
	10	*
	11	*/
	12
	13	#include <linux/init.h>
	14	#include "hisax.h"
	15	#include "isac.h"
	16	#include "isar.h"
	17	#include "isdnl1.h"
	18	#include <linux/isapnp.h>
	19
1da177e4 LT	20	static const char *ISurf_revision = "$Revision: 1.12.2.4 $";
1da177e4 LT	21
475be4d8	22	#define byteout(addr, val) outb(val, addr)
1da177e4 LT	23	#define bytein(addr) inb(addr)
	24
	25	#define ISURF_ISAR_RESET 1
	26	#define ISURF_ISAC_RESET 2
	27	#define ISURF_ISAR_EA 4
	28	#define ISURF_ARCOFI_RESET 8
	29	#define ISURF_RESET (ISURF_ISAR_RESET \| ISURF_ISAC_RESET \| ISURF_ARCOFI_RESET)
	30
	31	#define ISURF_ISAR_OFFSET 0
	32	#define ISURF_ISAC_OFFSET 0x100
	33	#define ISURF_IOMEM_SIZE 0x400
	34	/* Interface functions */
	35
	36	static u_char
	37	ReadISAC(struct IsdnCardState *cs, u_char offset)
	38	{
	39	return (readb(cs->hw.isurf.isac + offset));
	40	}
	41
	42	static void
	43	WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
	44	{
	45	writeb(value, cs->hw.isurf.isac + offset); mb();
	46	}
	47
	48	static void
475be4d8	49	ReadISACfifo(struct IsdnCardState cs, u_char data, int size)
1da177e4 LT	50	{
	51	register int i;
	52	for (i = 0; i < size; i++)
	53	data[i] = readb(cs->hw.isurf.isac);
	54	}
	55
	56	static void
475be4d8	57	WriteISACfifo(struct IsdnCardState cs, u_char data, int size)
1da177e4 LT	58	{
1da177e4 LT	59	register int i;
475be4d8 JP	60	for (i = 0; i < size; i++) {
475be4d8 JP	61	writeb(data[i], cs->hw.isurf.isac); mb();
1da177e4 LT	62	}
	63	}
	64
	65	/* ISAR access routines
	66	* mode = 0 access with IRQ on
	67	* mode = 1 access with IRQ off
	68	* mode = 2 access with IRQ off and using last offset
	69	*/
475be4d8	70
1da177e4 LT	71	static u_char
1da177e4 LT	72	ReadISAR(struct IsdnCardState *cs, int mode, u_char offset)
475be4d8 JP	73	{
475be4d8 JP	74	return (readb(cs->hw.isurf.isar + offset));
1da177e4 LT	75	}
	76
	77	static void
	78	WriteISAR(struct IsdnCardState *cs, int mode, u_char offset, u_char value)
	79	{
475be4d8	80	writeb(value, cs->hw.isurf.isar + offset); mb();
1da177e4 LT	81	}
	82
	83	static irqreturn_t
7d12e780	84	isurf_interrupt(int intno, void *dev_id)
1da177e4 LT	85	{
	86	struct IsdnCardState *cs = dev_id;
	87	u_char val;
	88	int cnt = 5;
	89	u_long flags;
	90
	91	spin_lock_irqsave(&cs->lock, flags);
	92	val = readb(cs->hw.isurf.isar + ISAR_IRQBIT);
475be4d8	93	Start_ISAR:
1da177e4 LT	94	if (val & ISAR_IRQSTA)
	95	isar_int_main(cs);
	96	val = readb(cs->hw.isurf.isac + ISAC_ISTA);
475be4d8	97	Start_ISAC:
1da177e4 LT	98	if (val)
	99	isac_interrupt(cs, val);
	100	val = readb(cs->hw.isurf.isar + ISAR_IRQBIT);
	101	if ((val & ISAR_IRQSTA) && --cnt) {
	102	if (cs->debug & L1_DEB_HSCX)
	103	debugl1(cs, "ISAR IntStat after IntRoutine");
	104	goto Start_ISAR;
	105	}
	106	val = readb(cs->hw.isurf.isac + ISAC_ISTA);
	107	if (val && --cnt) {
	108	if (cs->debug & L1_DEB_ISAC)
	109	debugl1(cs, "ISAC IntStat after IntRoutine");
	110	goto Start_ISAC;
	111	}
	112	if (!cnt)
	113	printk(KERN_WARNING "ISurf IRQ LOOP\n");
	114
	115	writeb(0, cs->hw.isurf.isar + ISAR_IRQBIT); mb();
475be4d8 JP	116	writeb(0xFF, cs->hw.isurf.isac + ISAC_MASK); mb();
475be4d8 JP	117	writeb(0, cs->hw.isurf.isac + ISAC_MASK); mb();
1da177e4 LT	118	writeb(ISAR_IRQMSK, cs->hw.isurf.isar + ISAR_IRQBIT); mb();
	119	spin_unlock_irqrestore(&cs->lock, flags);
	120	return IRQ_HANDLED;
	121	}
	122
672c3fd9	123	static void
1da177e4 LT	124	release_io_isurf(struct IsdnCardState *cs)
	125	{
	126	release_region(cs->hw.isurf.reset, 1);
	127	iounmap(cs->hw.isurf.isar);
	128	release_mem_region(cs->hw.isurf.phymem, ISURF_IOMEM_SIZE);
	129	}
	130
	131	static void
	132	reset_isurf(struct IsdnCardState *cs, u_char chips)
	133	{
	134	printk(KERN_INFO "ISurf: resetting card\n");
	135
	136	byteout(cs->hw.isurf.reset, chips); /* Reset On */
	137	mdelay(10);
	138	byteout(cs->hw.isurf.reset, ISURF_ISAR_EA); /* Reset Off */
	139	mdelay(10);
	140	}
	141
	142	static int
	143	ISurf_card_msg(struct IsdnCardState cs, int mt, void arg)
	144	{
	145	u_long flags;
	146
	147	switch (mt) {
475be4d8 JP	148	case CARD_RESET:
	149	spin_lock_irqsave(&cs->lock, flags);
	150	reset_isurf(cs, ISURF_RESET);
	151	spin_unlock_irqrestore(&cs->lock, flags);
	152	return (0);
	153	case CARD_RELEASE:
	154	release_io_isurf(cs);
	155	return (0);
	156	case CARD_INIT:
	157	spin_lock_irqsave(&cs->lock, flags);
	158	reset_isurf(cs, ISURF_RESET);
	159	clear_pending_isac_ints(cs);
	160	writeb(0, cs->hw.isurf.isar + ISAR_IRQBIT); mb();
	161	initisac(cs);
	162	initisar(cs);
	163	/* Reenable ISAC IRQ */
	164	cs->writeisac(cs, ISAC_MASK, 0);
	165	/* RESET Receiver and Transmitter */
	166	cs->writeisac(cs, ISAC_CMDR, 0x41);
	167	spin_unlock_irqrestore(&cs->lock, flags);
	168	return (0);
	169	case CARD_TEST:
	170	return (0);
1da177e4	171	}
475be4d8	172	return (0);
1da177e4 LT	173	}
	174
	175	static int
	176	isurf_auxcmd(struct IsdnCardState cs, isdn_ctrl ic) {
	177	int ret;
	178	u_long flags;
	179
	180	if ((ic->command == ISDN_CMD_IOCTL) && (ic->arg == 9)) {
	181	ret = isar_auxcmd(cs, ic);
	182	spin_lock_irqsave(&cs->lock, flags);
	183	if (!ret) {
	184	reset_isurf(cs, ISURF_ISAR_EA \| ISURF_ISAC_RESET \|
475be4d8	185	ISURF_ARCOFI_RESET);
1da177e4 LT	186	initisac(cs);
	187	cs->writeisac(cs, ISAC_MASK, 0);
	188	cs->writeisac(cs, ISAC_CMDR, 0x41);
	189	}
	190	spin_unlock_irqrestore(&cs->lock, flags);
475be4d8	191	return (ret);
1da177e4	192	}
475be4d8	193	return (isar_auxcmd(cs, ic));
1da177e4 LT	194	}
	195
	196	#ifdef __ISAPNP__
ed5a84cd	197	static struct pnp_card *pnp_c = NULL;
1da177e4 LT	198	#endif
1da177e4 LT	199
ed5a84cd	200	int setup_isurf(struct IsdnCard *card)
1da177e4 LT	201	{
	202	int ver;
	203	struct IsdnCardState *cs = card->cs;
	204	char tmp[64];
	205
	206	strcpy(tmp, ISurf_revision);
	207	printk(KERN_INFO "HiSax: ISurf driver Rev. %s\n", HiSax_getrev(tmp));
475be4d8 JP	208
	209	if (cs->typ != ISDN_CTYPE_ISURF)
	210	return (0);
1da177e4 LT	211	if (card->para[1] && card->para[2]) {
	212	cs->hw.isurf.reset = card->para[1];
	213	cs->hw.isurf.phymem = card->para[2];
	214	cs->irq = card->para[0];
	215	} else {
	216	#ifdef __ISAPNP__
	217	if (isapnp_present()) {
	218	struct pnp_dev *pnp_d = NULL;
	219	int err;
	220
	221	cs->subtyp = 0;
	222	if ((pnp_c = pnp_find_card(
475be4d8 JP	223	ISAPNP_VENDOR('S', 'I', 'E'),
475be4d8 JP	224	ISAPNP_FUNCTION(0x0010), pnp_c))) {
1da177e4	225	if (!(pnp_d = pnp_find_dev(pnp_c,
475be4d8 JP	226	ISAPNP_VENDOR('S', 'I', 'E'),
475be4d8 JP	227	ISAPNP_FUNCTION(0x0010), pnp_d))) {
1da177e4 LT	228	printk(KERN_ERR "ISurfPnP: PnP error card found, no device\n");
	229	return (0);
	230	}
	231	pnp_disable_dev(pnp_d);
	232	err = pnp_activate_dev(pnp_d);
5b999fd0 KK	233	if (err < 0) {
	234	pr_warn("%s: pnp_activate_dev ret=%d\n",
	235	__func__, err);
	236	return 0;
	237	}
1da177e4 LT	238	cs->hw.isurf.reset = pnp_port_start(pnp_d, 0);
	239	cs->hw.isurf.phymem = pnp_mem_start(pnp_d, 1);
	240	cs->irq = pnp_irq(pnp_d, 0);
	241	if (!cs->irq \|\| !cs->hw.isurf.reset \|\| !cs->hw.isurf.phymem) {
	242	printk(KERN_ERR "ISurfPnP:some resources are missing %d/%x/%lx\n",
475be4d8	243	cs->irq, cs->hw.isurf.reset, cs->hw.isurf.phymem);
1da177e4	244	pnp_disable_dev(pnp_d);
475be4d8	245	return (0);
1da177e4 LT	246	}
	247	} else {
	248	printk(KERN_INFO "ISurfPnP: no ISAPnP card found\n");
475be4d8	249	return (0);
1da177e4 LT	250	}
	251	} else {
	252	printk(KERN_INFO "ISurfPnP: no ISAPnP bus found\n");
475be4d8	253	return (0);
1da177e4 LT	254	}
1da177e4 LT	255	#else
8349304d	256	printk(KERN_WARNING "HiSax: Siemens I-Surf port/mem not set\n");
1da177e4 LT	257	return (0);
	258	#endif
	259	}
	260	if (!request_region(cs->hw.isurf.reset, 1, "isurf isdn")) {
	261	printk(KERN_WARNING
475be4d8 JP	262	"HiSax: Siemens I-Surf config port %x already in use\n",
	263	cs->hw.isurf.reset);
	264	return (0);
1da177e4 LT	265	}
1da177e4 LT	266	if (!request_region(cs->hw.isurf.phymem, ISURF_IOMEM_SIZE, "isurf iomem")) {
8349304d	267	printk(KERN_WARNING "HiSax: Siemens I-Surf memory region "
475be4d8 JP	268	"%lx-%lx already in use\n",
	269	cs->hw.isurf.phymem,
	270	cs->hw.isurf.phymem + ISURF_IOMEM_SIZE);
1da177e4 LT	271	release_region(cs->hw.isurf.reset, 1);
	272	return (0);
	273	}
	274	cs->hw.isurf.isar = ioremap(cs->hw.isurf.phymem, ISURF_IOMEM_SIZE);
	275	cs->hw.isurf.isac = cs->hw.isurf.isar + ISURF_ISAC_OFFSET;
	276	printk(KERN_INFO
	277	"ISurf: defined at 0x%x 0x%lx IRQ %d\n",
	278	cs->hw.isurf.reset,
	279	cs->hw.isurf.phymem,
	280	cs->irq);
	281
	282	setup_isac(cs);
	283	cs->cardmsg = &ISurf_card_msg;
	284	cs->irq_func = &isurf_interrupt;
	285	cs->auxcmd = &isurf_auxcmd;
	286	cs->readisac = &ReadISAC;
	287	cs->writeisac = &WriteISAC;
	288	cs->readisacfifo = &ReadISACfifo;
	289	cs->writeisacfifo = &WriteISACfifo;
	290	cs->bcs[0].hw.isar.reg = &cs->hw.isurf.isar_r;
	291	cs->bcs[1].hw.isar.reg = &cs->hw.isurf.isar_r;
	292	test_and_set_bit(HW_ISAR, &cs->HW_Flags);
	293	ISACVersion(cs, "ISurf:");
	294	cs->BC_Read_Reg = &ReadISAR;
	295	cs->BC_Write_Reg = &WriteISAR;
	296	cs->BC_Send_Data = &isar_fill_fifo;
	297	ver = ISARVersion(cs, "ISurf:");
	298	if (ver < 0) {
	299	printk(KERN_WARNING
475be4d8	300	"ISurf: wrong ISAR version (ret = %d)\n", ver);
1da177e4 LT	301	release_io_isurf(cs);
	302	return (0);
	303	}
	304	return (1);
	305	}